%jRdZddlmZddlZddlmZmZddlmZm Z m Z ddl m Z ddl mZddlmZmZmZmZmZd d lmZmZd d lmZed ZGd deeZGddZeddZeddZeddZed dZd!dZdS)"z9App-scoped shared dependencies: Shared and SharedContext.) annotationsN) AwaitableCallable)AbstractAsyncContextManagerAbstractContextManagerAsyncExitStack) ContextVar) TracebackType)AnyClassVarTypeVarcastoverload)DependencyFactory_FunctionalDependency)get_dependency_parametersRc"eZdZdZddZd dZdS) _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. returnrc,Ktj}|j|vr ||jS|d{V}tj4d{V|j|vr||jcdddd{VStj}|jdi|}|||d{V}|||j<|cdddd{VS#1d{VswxYwYdS)N) SharedContextresolvedgetfactory_resolve_parameterslockstack_resolve_factory_value)selfr argumentsr raw_valueresolved_values [/home/rurouni/.hermes/hermes-agent/venv/lib/python3.11/site-packages/uncalled_for/shared.py __aenter__z_Shared.__aenter__s )--// <8 # #DL) )2244444444  %))++ " " " " " " " "|x'' - " " " " " " " " " " " " " ""'++--E$ 11y11I#'#>#>ui#P#PPPPPPPN%3HT\ "! " " " " " " " " " " " " " " " " " " " " " " " " " " " " " "s5DAD D D dict[str, Any]cKtj}i}t|j}|D]#\}}||d{V||<$|SN)rr rrritemsenter_async_context)r"r r# parameters parameter dependencys r&rz_Shared._resolve_parameters1s#''))$& .t|<< %/%5%5%7%7 O O !Iz).)B)B:)N)N#N#N#N#N#N#NIi N)rr)rr()__name__ __module__ __qualname____doc__r'rrr0r&rrsF""""&r0rceZdZUdZedZded<edZded<edZd ed <dd Z ddZ dS)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]]r rcrKt|_|jd{Vtji|_tjtj |_ tj |j|_ |Sr*) r_stackr'rrset_resolved_tokenrasyncioLock _lock_tokenr _stack_token)r"s r&r'zSharedContext.__aenter__Vs$&& k$$&&&&&&&&&,599"==(-11',..AA)/33DK@@ r0exc_typetype[BaseException] | None exc_valueBaseException | None tracebackTracebackType | NoneNonec&K|j|||d{Vtj|jtj|jtj|j dSr*) r: __aexit__rr resetr@rr?rr<)r"rArCrEs r&rIzSharedContext.__aexit__`s k##HiCCCCCCCCC!!$"3444  !1222$$T%9:::::r0N)rr)rArBrCrDrErFrrG) r1r2r3r4r r__annotations__rr r'rIrr0r&rr<s&IS IIH0:z-/H/HDHHHH2<*^2L2LELLLL ; ; ; ; ; ;r0rr-Callable[..., AbstractAsyncContextManager[R]]rcdSr*rrs r&SharedrOmsILr0(Callable[..., AbstractContextManager[R]]cdSr*rrNs r&rOrOosDGCr0Callable[..., Awaitable[R]]cdSr*rrNs r&rOrOqs7:sr0Callable[..., R]cdSr*rrNs r&rOrOss,/Cr0DependencyFactory[R]cFttt|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. )rrrrNs r&rOrOus 77## $ $$r0)rrLrr)rrPrr)rrRrr)rrTrr)rrVrr)r4 __future__rr=collections.abcrr contextlibrrr contextvarsr typesr typingr r r rr functionalrr introspectionrrrrrOrr0r&r`s??""""""//////// #"""""99999999999999@@@@@@@@444444 GCLL######A&###L.;.;.;.;.;.;.;.;b LLL L GGG G ::: : /// /%%%%%%r0