Ki dZddlmZddlZddlmZmZddlmZm Z m Z ddl m Z ddl mZddlmZmZmZmZmZd d lmZmZd d lmZed ZGd deeZGddZeddZeddZeddZeddZddZy)z9App-scoped shared dependencies: Shared and SharedContext.) annotationsN) AwaitableCallable)AbstractAsyncContextManagerAbstractContextManagerAsyncExitStack) ContextVar) TracebackType)AnyClassVarTypeVarcastoverload)DependencyFactory_FunctionalDependency)get_dependency_parametersRc eZdZdZddZddZy)_SharedzApp-scoped dependency resolved once and reused across all calls. Unlike _Depends (which resolves per-call), _Shared dependencies initialize once within a SharedContext and the same instance is provided to all subsequent resolutions. cpKtjj}|j|vr||jS|j d{}tj j4d{|j|vr ||jcdddd{Stj j}|jdi|}|j||d{}|||j<|cdddd{S777u7,7 #1d{7swYyxYww)N) SharedContextresolvedgetfactory_resolve_parameterslockstack_resolve_factory_value)selfr argumentsr raw_valueresolved_values _/home/jay/workspace/scripts/.codegraph-venv/lib/python3.12/site-packages/uncalled_for/shared.py __aenter__z_Shared.__aenter__s ))--/ <<8 #DLL) )2244  %%))+ " "||x' - " " ""''++-E$ 1y1I#'#>#>ui#PPN%3HT\\ "! " " "5 " " Q " " " "sAD6D&D68D9D6<D! D6%D&D6+AD!0D1D! D6DD6D6D6D!D6!D3'D* (D3/D6cKtjj}i}t|j}|j D]!\}}|j |d{||<#|S7 wN)rrrrritemsenter_async_context)r!rr" parameters parameter dependencys r%rz_Shared._resolve_parameters1sr##'')$& .t||< %/%5%5%7 O !Iz).)B)B:)N#NIi  O$OsA A0"A.# A0N)returnr)r.zdict[str, Any])__name__ __module__ __qualname____doc__r&rrr%rrs"&r3rceZdZUdZedZded<edZded<edZd ed <dd Z dd Z y )raManages app-scoped Shared dependency lifecycle. Use as an async context manager to establish a scope for Shared dependencies. All Shared factories resolved within this scope will be cached and reused. Context managers are cleaned up when the SharedContext exits. Example:: async with SharedContext(): async with resolved_dependencies(my_func) as dependencies: # Shared dependencies are resolved once and cached here ... async with resolved_dependencies(my_func) as dependencies: # Same Shared instances reused ... # Shared context managers are cleaned up here shared_resolvedz7ClassVar[ContextVar[dict[DependencyFactory[Any], Any]]]r shared_lockz"ClassVar[ContextVar[asyncio.Lock]]r shared_stackz$ClassVar[ContextVar[AsyncExitStack]]rcKt|_|jjd{tjj i|_tjj tj|_ tjj |j|_ |S7wr() r_stackr&rrset_resolved_tokenrasyncioLock _lock_tokenr _stack_token)r!s r%r&zSharedContext.__aenter__Vs$& kk$$&&&,5599"=(--11',,.A)//33DKK@ 's-CB>BCcPK|jj|||d{tjj |j tj j |jtjj |jy7wr() r9 __aexit__rrresetr?rr>rr;)r!exc_type exc_value tracebacks r%rAzSharedContext.__aexit__`sx kk##HiCCC!!$"3"34  !1!12$$T%9%9: Ds!B&B$BB&N)r.r)rCztype[BaseException] | NonerDzBaseException | NonerEzTracebackType | Noner.None) r/r0r1r2r r__annotations__rrr&rArr3r%rr<ss&ISIHE0:-/HD ,H2<^2LE /L ;, ;( ;( ;  ;r3rcyr(rrs r%SharedrJmsILr3cyr(rrIs r%rJrJosDGr3cyr(rrIs r%rJrJqs7:r3cyr(rrIs r%rJrJss,/r3c4ttt|S)ubDeclare an app-scoped dependency shared across all calls. The factory initializes once within a ``SharedContext`` and the value is reused for all subsequent resolutions. Factories may be: - A sync function returning a value - An async function returning a value - A sync generator (context manager) yielding a value - An async generator (async context manager) yielding a value Context managers are cleaned up when the SharedContext exits. Identity is the factory function — multiple ``Shared(same_factory)`` declarations anywhere resolve to the same cached value. )rrrrIs r%rJrJus 77# $$r3)rz-Callable[..., AbstractAsyncContextManager[R]]r.r)rz(Callable[..., AbstractContextManager[R]]r.r)rzCallable[..., Awaitable[R]]r.r)rzCallable[..., R]r.r)rzDependencyFactory[R]r.r)r2 __future__rr<collections.abcrr contextlibrrr contextvarsr typesr typingr r r rr functionalrr introspectionrrrrrJrr3r%rWs?"/ #99@4 CL##A&#L.;.;b L L G G : : / /%r3