+Kj7USrSSKrSSKrSSKrSSKJr SSKJrJrJ r J r J r J r J r SSKJrJr SSKJrJrJr SSKJr "S S \5r"S S \5r"S S\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5rS!SS.SjjrS!SS.Sjjr Sr!Sr"Sr#Sr$S r%\"5\%l&g)"aISynchronization decorators and calling-convention markers/bridges. Provides ``synchronized`` for thread and async locking, ``mark_as_sync`` and ``mark_as_async`` for declaring the effective calling convention of a wrapped callable (without converting it), and ``async_to_sync`` / ``sync_to_async`` for bridging between the two. N)partial)CO_ASYNC_GENERATOR CO_COROUTINE CO_GENERATORCO_ITERABLE_COROUTINEisasyncgenfunctioniscoroutinefunctionisgeneratorfunction)LockRLock)BoundFunctionWrapperCallableObjectProxyFunctionWrapper) decoratorc<^\rSrSrSU4Sjjr\S5rSrU=r$)_SyncCodeProxy#c0>[TU]U5 X lgNsuper__init___self_generatorselfwrapped generator __class__s ڣC:\Users\johnn\AppData\Local\Packages\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\LocalCache\local-packages\Python313\site-packages\wrapt/synchronization.pyr_SyncCodeProxy.__init__% !(cURRnU[[-[-)-nUR SLa U[ -nU$UR SLa U[ )-nU$U[-(a U[ -nU$NTF) __wrapped__co_flagsrrrrrroriginalflagss r r'_SyncCodeProxy.co_flags)s##,,\,>>AVVWW   4 ' \ !E  ! !U * l] "E ,,% r#rr __name__ __module__ __qualname____firstlineno__rpropertyr'__static_attributes__ __classcell__rs@r rr#s)r#rc<^\rSrSrSU4Sjjr\S5rSrU=r$)_SyncFunctionSurrogate<c0>[TU]U5 X lgrrrs r r_SyncFunctionSurrogate.__init__>r"r#cV[URRUR5$rrr&__code__rrs r r=_SyncFunctionSurrogate.__code__B!d..779M9MNNr#r,r r.r/r0r1rr2r=r3r4r5s@r r7r7<s)OOr#r7c8^\rSrSrU4Sjr\S5rSrU=r$)_BoundSyncFunctionWrapperGc4>[TU]"U0UD6 SUlgNT)rr_self_is_not_coroutine)rargskwargsrs r r"_BoundSyncFunctionWrapper.__init__Is $)&)&*#r#cj[URRURR5$r)r7r&__func__ _self_parentrr>s r rL"_BoundSyncFunctionWrapper.__func__Ms,%    % %t'8'8'H'H  r#)rG) r.r/r0r1rr2rLr3r4r5s@r rCrCGs+  r#rCc@^\rSrSr\rSU4Sjjr\S5rSr U=r $)_SyncFunctionWrapperTc>>[TU]X5 SUlX0lgrF)rrrGrrrwrapperrrs r r_SyncFunctionWrapper.__init__Xs *&*#(r#cV[URRUR5$rr<r>s r r=_SyncFunctionWrapper.__code__]r@r#)rrGr) r.r/r0r1rC__bound_function_wrapper__rr2r=r3r4r5s@r rPrPTs$!:) OOr#rPc<^\rSrSrSU4Sjjr\S5rSrU=r$)_AsyncCodeProxybc0>[TU]U5 X lgrrrs r r_AsyncCodeProxy.__init__dr"r#c*URRnU[[-[-[ -)-nUR SLa U[ -nU$UR SLa U[-nU$U[[ --(a U[ -nU$U[-nU$r%)r&r'rrrrrr(s r r'_AsyncCodeProxy.co_flagshs##,, < '*? ?BT T     4 ' ' 'E  ! !U * \ !E <*<<=++ % r#r,rr-r5s@r rZrZbs)r#rZc<^\rSrSrSU4Sjjr\S5rSrU=r$)_AsyncFunctionSurrogate}c0>[TU]U5 X lgrrrs r r _AsyncFunctionSurrogate.__init__r"r#cV[URRUR5$rrZr&r=rr>s r r= _AsyncFunctionSurrogate.__code__!t//88$:N:NOOr#r,rrAr5s@r rara}s)PPr#rac$\rSrSr\S5rSrg)_BoundAsyncFunctionWrappercj[URRURR5$r)rar&rLrMrr>s r rL#_BoundAsyncFunctionWrapper.__func__s,&    % %t'8'8'H'H  r#N)r.r/r0r1r2rLr3rnr#r rjrjs   r#rjc@^\rSrSr\rSU4Sjjr\S5rSr U=r $)_AsyncFunctionWrapperc0>[TU]X5 X0lgrrrSs r r_AsyncFunctionWrapper.__init__s *(r#cV[URRUR5$rrfr>s r r=_AsyncFunctionWrapper.__code__rhr#r,r) r.r/r0r1rjrXrr2r=r3r4r5s@r rprps$!;)PPr#rprc*^U4SjnUcU$U"U5$)aMark a callable as synchronous from the perspective of calling convention detection. The returned wrapper is a pass-through that reports `inspect.iscoroutinefunction()` as False regardless of whether the underlying callable is declared `async def`. Useful when a stacked decorator has already collapsed an async function into a synchronous one (for example by using `asyncio.run()`). The `generator` keyword toggles the sync generator bit (`CO_GENERATOR`) on the resulting wrapper. Tri-state: - `None` (default): auto. Preserve generator-ness from the input -- if the input was an async generator, the wrapper reports as a sync generator; otherwise CO_GENERATOR is copied through unchanged. - `True`: force CO_GENERATOR on. Wrapper reports as a sync generator. - `False`: force CO_GENERATOR off. Wrapper reports as a plain sync function even if the input had CO_GENERATOR set. Regardless of `generator`, CO_COROUTINE, CO_ASYNC_GENERATOR, and CO_ITERABLE_COROUTINE are all cleared (sync means none of those). c>Sn[XTS9$)NcU"U0UD6$rrnrinstancerHrIs r _wrapper2mark_as_sync.._decorator.._wrapperD+F+ +r#rv)rPrr|rs r _decorator mark_as_sync.._decorators ,$GKKr#rnrrrs ` r mark_as_syncrs!,L  g r#c*^U4SjnUcU$U"U5$)aMark a callable as asynchronous from the perspective of calling convention detection. The returned wrapper reports `inspect.iscoroutinefunction()` as True regardless of whether the underlying callable is declared `async def`. Useful when a stacked decorator returns a coroutine from a plain `def` wrapper. The `generator` keyword chooses between coroutine function and async generator reporting. Tri-state: - `None` (default): auto. If the input was a sync or async generator, the wrapper reports as an async generator (`CO_ASYNC_GENERATOR`); otherwise it reports as a coroutine function (`CO_COROUTINE`). - `True`: force async generator reporting (`CO_ASYNC_GENERATOR` set, `CO_COROUTINE` cleared). These two flags are mutually exclusive at the CPython code-object level. - `False`: force coroutine function reporting (`CO_COROUTINE` set, `CO_ASYNC_GENERATOR` cleared). CO_GENERATOR and CO_ITERABLE_COROUTINE are always cleared (the async path does not use either). c>Sn[XTS9$)NcU"U0UD6$rrnrzs r r|3mark_as_async.._decorator.._wrapperr~r#rv)rprs r r!mark_as_async.._decorators ,%W)LLr#rnrs ` r mark_as_asyncrs!0M  g r#c[U5(a [S5e[U5(a [S5e[U5(d[R "S[ SS9 Sn[XSS9$) aAdapt an async callable so it can be called synchronously. Each call runs the coroutine to completion via `asyncio.run()`. The returned wrapper reports as synchronous under `inspect.iscoroutinefunction()`. Naming follows the asgiref convention. Generator functions of either convention are rejected with a `TypeError`: `asyncio.run()` cannot run an async generator, and a sync generator has nothing to run to completion. A callable not reporting as a coroutine function produces a `UserWarning` rather than an error, since convention detection has false negatives such as a plain function wrapper which returns a coroutine; if the callable really is asynchronous in behaviour, apply `mark_as_async` to it first so it reports as such.zlasync_to_sync cannot be applied to an async generator function; asyncio.run() cannot run an async generator.zasync_to_sync cannot be applied to a generator function; there is no coroutine to run to completion. If the callable is misreported and actually asynchronous in behaviour, apply mark_as_async to it first.zasync_to_sync was applied to a callable not reporting as a coroutine function. If it is asynchronous in behaviour, apply mark_as_async to it first so it reports as such.) stacklevelc:[R"U"U0UD65$r)asynciorunrzs r rTasync_to_sync..wrapper s{{7D3F344r#Frv)r TypeErrorr r warningswarn UserWarningrPrrTs r async_to_syncrs~ '"" E  7## )   w ' '   E   5 E BBr#c[U5(d[U5(a [S5e[U5(a [S5eSn[ XSS9$)aAdapt a sync callable so it can be awaited. Each call dispatches the synchronous work to the default executor via `loop.run_in_executor()`. The returned wrapper reports as asynchronous under `inspect.iscoroutinefunction()`. Naming follows the asgiref convention. Callables reporting as coroutine functions or generator functions of either convention are rejected with a `TypeError`. For a generator function the adaptation would be an illusion: only creation of the generator would be dispatched to the executor, which executes no body code, while each iteration would still block the event loop. A callable misreported as asynchronous but synchronous in behaviour can have `mark_as_sync` applied to it first so it reports as such.zsync_to_async can only be applied to a synchronous callable. If the callable is misreported and actually synchronous in behaviour, apply mark_as_sync to it first.zsync_to_async cannot be applied to a generator function; creating the generator executes no code, and iterating it would still block the event loop.c# [R"5nURS[U/UQ70UD65IShvN $N7fr)rget_running_looprun_in_executorr)rr{rHrIloops r rTsync_to_async..wrapper4s;'')))$0Q$0Q&0QRRRRs8A?AFrv)r rrr rprs r sync_to_asyncrsc 7##'9''B'B H  7## 0  S !U CCr#c.[[USS55$)Nacquire)r getattr)objs r _synchronized_is_async_lockr;s wsIt< ==r#c0[U5U0n[R"5nUn[U[[ 45(a][ USS5nUc URnUn[U5nXQ;d[U5U:a[SRU55eX1U'My[ USS5(ag[U5(ag[ USS5nUbXcLagUn[U5nXQ;d[U5U:a[SRU55eX1U'M)NTr&z!wrapper loop when unwrapping {!r}rGF) idsysgetrecursionlimit isinstance classmethod staticmethodrrLlen ValueErrorformatr )rmemorecursion_limittargetinner id_target next_targets r _synchronized_is_async_callabler?s sGS>D++-O F  f{L9 : :FM48E}F6 I CI$@ !D!K!KC!PQQ$O  63U ; ; v & &fmT:  +"7vJ  D _ <@GGLM M Y3 r#c^^^ [US5(aq[US5(a`Um [T 5(a'[U 4Sj5n"U 4SjS[5nU"US9$[U 4Sj5n"U 4SjS [5nU"US9$S mS mU4S jnU4S jn"UU4SjS[5n[ U5(aU"XS9$U"XS9$)aDepending on the nature of the `wrapped` object, will either return a decorator which can be used to wrap a function or method, or a context manager, both of which will act accordingly depending on how used, to synchronize access to calling of the wrapped function, or the block of code within the context manager. If it is an object which is a synchronization primitive, such as a threading Lock, RLock, Semaphore, Condition, or Event, then it is assumed that the object is to be used directly as the synchronization primitive, otherwise a lock is created automatically and attached to the wrapped object and used as the synchronization primitive. Async functions are supported: if the wrapped callable is an async function, an `asyncio.Lock` is created for the context and the wrapper awaits the lock. The returned object also exposes `__aenter__` and `__aexit__` so it can be used with `async with` to synchronise a block of code using an independent per-context `asyncio.Lock`. If an object with coroutine `acquire`/`release` methods (such as an `asyncio.Lock`) is supplied directly, the returned decorator and context manager will use it via the async protocol. rreleasec># TIShvN U"U0UD6IShvN sSSS5IShvN $N%NN !,IShvN (df  g=f7frrnrr{rHrIlocks r _synchronized#synchronized.._synchronizeds24!($!9&!99 449 444sEA0A 626 A4A6AA ? A  Ac.>\rSrSrU4SjrU4SjrSrg)1synchronized.._AsyncSynchronizedLockProxyicD># TR5IShvN T$N7frrrrs r __aenter__._AsyncSynchronizedLockProxy.__aenter__s,,.((K)s   c.># TR5 g7frrrrHrs r __aexit__;synchronized.._AsyncSynchronizedLockProxy.__aexit__sLLNsrnN)r.r/r0r1rrr3rsr _AsyncSynchronizedLockProxyrs ##r#r)rcN>T U"U0UD6sSSS5 $!,(df  g=frrnrs r rrs //s $c.>\rSrSrU4SjrU4SjrSrg),synchronized.._SynchronizedLockProxyic(>TR5 T$rrrs r __enter__6synchronized.._SynchronizedLockProxy.__enter__s  r#c&>TR5 grrrs r __exit__5synchronized.._SynchronizedLockProxy.__exit__s  r#rnN)r.r/r0r1rrr3rsr _SynchronizedLockProxyrs   r#rc[U5RSS5nUcP[R [U5RSS5nUc[ 5n[ USU5 SSS5 U$U$!,(df  U$=f)N_synchronized_lock)varsget synchronized_synchronized_meta_lockr setattrcontextrs r r(synchronized.._synchronized_locks}G}  !5t< <55 G}(()=tD< 7DG%94@6 t 65 s 6A11 Bc[U5RSS5nUc[[R [U5RSS5nUc"[R "5n[ USU5 SSS5 U$U$!,(df  U$=f)N_synchronized_async_lock)rrrrrr rrs r r.synchronized.._synchronized_async_locks} G}  !;TB <55G}(()CTJ<"<<>DG%?F 6 t 65 s AA<< B cd>T"UbUOU5 U"U0UD6sSSS5 $!,(df  g=frrn)rr{rHrIrs r _synchronized_wrapper+synchronized.._synchronized_wrappers.  H,@g ND+F+O N Ns! /c># T"UbUOU5IShvN U"U0UD6IShvN sSSS5IShvN $N%NN !,IShvN (df  g=f7frrn)rr{rHrIrs r _synchronized_async_wrapper1synchronized.._synchronized_async_wrappersW+ ,H'  !$1&11   2    sLA;A A=A A?AAAAA  AAc:>\rSrSrU4SjrSrU4SjrSrSrg)2synchronized.._SynchronizedFunctionWrapperic~>T"UR5UlURR5 UR$r)r& _self_lockr)rrs r r._SynchronizedFunctionWrapper.__enter__s/01A1ABDO OO # # %?? "r#c8URR5 gr)rrrrHs r r;synchronized.._SynchronizedFunctionWrapper.__exit__ s OO # # %r#c># T"UR5UlURR5IShvN UR$N7fr)r&_self_async_lockr)rrs r r=synchronized.._SynchronizedFunctionWrapper.__aenter__ sB$._SynchronizedFunctionWrapper.__aexit__s  ! ! ) ) +s)rrN) r.r/r0r1rrrrr3)rrsr _SynchronizedFunctionWrapperrs #  & )  ,r#rr)hasattrrrrrr) rrrrrrrrrrs @@@r rrrs8w ""ww 'B'B &t , ,  : : #.A #/}E E  0  0 %8 &m<<@$,2 ,,,$'w//+   ( WWr#r)'__doc__rrr functoolsrinspectrrrrrr r threadingr r __wrapt__rrr decoratorsrrr7rCrPrZrarjrprrrrrrrrrnr#r rs "QQ!(2O0O  4   O? O)6P1P !5  PO PtB  F.Cb%DP>%!fgXT(,v $r#