4j"GzSrSSKrSSKrSSKJr SSKJrJrJrJ r J r SSK J r J r SSKJrJrJr SSKJr "S S \5r"S S \5r"S S\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5rS!SS.SjjrS!SS.SjjrSrSrSr 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_COROUTINEiscoroutinefunction)LockRLock)BoundFunctionWrapperCallableObjectProxyFunctionWrapper) decoratorc<^\rSrSrSU4Sjjr\S5rSrU=r$)_SyncCodeProxy c0>[TU]U5 X lgNsuper__init___self_generatorselfwrapped generator __class__s T/root/lseg-credit/backend/venv/lib/python3.13/site-packages/wrapt/synchronization.pyr_SyncCodeProxy.__init__" !(cURRnU[[-[-)-nUR SLa U[ -nU$UR SLa U[ )-nU$U[-(a U[ -nU$NTF) __wrapped__co_flagsrrrrrroriginalflagss rr%_SyncCodeProxy.co_flags&s##,,\,>>AVVWW   4 ' \ !E  ! !U * l] "E ,,% r!rr __name__ __module__ __qualname____firstlineno__rpropertyr%__static_attributes__ __classcell__rs@rrr s)r!rc<^\rSrSrSU4Sjjr\S5rSrU=r$)_SyncFunctionSurrogate9c0>[TU]U5 X lgrrrs rr_SyncFunctionSurrogate.__init__;r r!cV[URRUR5$rrr$__code__rrs rr;_SyncFunctionSurrogate.__code__?!d..779M9MNNr!r*r r,r-r.r/rr0r;r1r2r3s@rr5r59s)OOr!r5c8^\rSrSrU4Sjr\S5rSrU=r$)_BoundSyncFunctionWrapperDc4>[TU]"U0UD6 SUlgNT)rr_self_is_not_coroutine)rargskwargsrs rr"_BoundSyncFunctionWrapper.__init__Fs $)&)&*#r!cj[URRURR5$r)r5r$__func__ _self_parentrr<s rrJ"_BoundSyncFunctionWrapper.__func__Js,%    % %t'8'8'H'H  r!)rE) r,r-r.r/rr0rJr1r2r3s@rrArADs+  r!rAc@^\rSrSr\rSU4Sjjr\S5rSr U=r $)_SyncFunctionWrapperQc>>[TU]X5 SUlX0lgrD)rrrErrrwrapperrrs rr_SyncFunctionWrapper.__init__Us *&*#(r!cV[URRUR5$rr:r<s rr;_SyncFunctionWrapper.__code__Zr>r!)rrEr) r,r-r.r/rA__bound_function_wrapper__rr0r;r1r2r3s@rrNrNQs$!:) OOr!rNc<^\rSrSrSU4Sjjr\S5rSrU=r$)_AsyncCodeProxy_c0>[TU]U5 X lgrrrs rr_AsyncCodeProxy.__init__ar r!c*URRnU[[-[-[ -)-nUR SLa U[ -nU$UR SLa U[-nU$U[[ --(a U[ -nU$U[-nU$r#)r$r%rrrrrr&s rr%_AsyncCodeProxy.co_flagses##,, < '*? ?BT T     4 ' ' 'E  ! !U * \ !E <*<<=++ % r!r*rr+r3s@rrXrX_s)r!rXc<^\rSrSrSU4Sjjr\S5rSrU=r$)_AsyncFunctionSurrogatezc0>[TU]U5 X lgrrrs rr _AsyncFunctionSurrogate.__init__|r r!cV[URRUR5$rrXr$r;rr<s rr; _AsyncFunctionSurrogate.__code__!t//88$:N:NOOr!r*rr?r3s@rr_r_zs)PPr!r_c$\rSrSr\S5rSrg)_BoundAsyncFunctionWrappercj[URRURR5$r)r_r$rJrKrr<s rrJ#_BoundAsyncFunctionWrapper.__func__s,&    % %t'8'8'H'H  r!N)r,r-r.r/r0rJr1rlr!rrhrhs   r!rhc@^\rSrSr\rSU4Sjjr\S5rSr U=r $)_AsyncFunctionWrapperc0>[TU]X5 X0lgrrrQs rr_AsyncFunctionWrapper.__init__s *(r!cV[URRUR5$rrdr<s rr;_AsyncFunctionWrapper.__code__rfr!r*r) r,r-r.r/rhrVrr0r;r1r2r3s@rrnrns$!;)PPr!rnrc*^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$rrlrinstancerFrGs r_wrapper2mark_as_sync.._decorator.._wrappersD+F+ +r!rtrNrrzrs r _decorator mark_as_sync.._decorators ,$GKKr!rl)rrr~s ` r mark_as_syncrs!,L  g r!c4^^SmUU4SjnUcU$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# U"U0UD6$7frrlrxs rrzmark_as_async.._wrappers'''s c>[UTTS9$)Nrtrnr}s rr~!mark_as_async.._decorators$Wh)LLr!rl)rrr~rzs ` @r mark_as_asyncrs&0(M g r!cSn[X5$)zAdapt 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.c:[R"U"U0UD65$r)asynciorunrxs rrRasync_to_sync..wrappers{{7D3F344r!r|rrRs r async_to_syncrs5  11r!cSn[X5$)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.c# [R"5nURS[U/UQ70UD65IShvN $N7fr)rget_running_looprun_in_executorr)rryrFrGloops rrRsync_to_async..wrappers;'')))$0Q$0Q&0QRRRRs8A?Arrs r sync_to_asyncrsS ! 22r!c.[[USS55$)Nacquire)rgetattr)objs r_synchronized_is_async_lockrs 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}rEF) idsysgetrecursionlimit isinstance classmethod staticmethodrrJlen ValueErrorformatr)rmemorecursion_limittargetinner id_target next_targets r_synchronized_is_async_callablers 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=f7frrlrryrFrGlocks r _synchronized#synchronized.._synchronizedXs24!($!9&!99 449 444sEA0A 626 A4A6AA ? A  Ac.>\rSrSrU4SjrU4SjrSrg)1synchronized.._AsyncSynchronizedLockProxyi]cD># TR5IShvN T$N7frrrrs r __aenter__._AsyncSynchronizedLockProxy.__aenter___s,,.((K)s   c.># TR5 g7frrrrFrs r __aexit__;synchronized.._AsyncSynchronizedLockProxy.__aexit__csLLNsrlN)r,r-r.r/rrr1rsr_AsyncSynchronizedLockProxyr]s ##r!r)rcN>T U"U0UD6sSSS5 $!,(df  g=frrlrs rrrhs //s $c.>\rSrSrU4SjrU4SjrSrg),synchronized.._SynchronizedLockProxyipc(>TR5 T$rrrs r __enter__6synchronized.._SynchronizedLockProxy.__enter__rs  r!c&>TR5 grrrs r__exit__5synchronized.._SynchronizedLockProxy.__exit__vs  r!rlN)r,r-r.r/rrr1rsr_SynchronizedLockProxyrps   r!rc[U5RSS5nUcP[R [U5RSS5nUc[ 5n[ USU5 SSS5 U$U$!,(df  U$=f)N_synchronized_lock)varsget synchronized_synchronized_meta_lockr setattrcontextrs rr(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 rr.synchronized.._synchronized_async_locks} G}  !;TB <55G}(()CTJ<"<<>DG%?F 6 t 65 s AA<< B cd>T"UbUOU5 U"U0UD6sSSS5 $!,(df  g=frrl)rryrFrGrs r_synchronized_wrapper+synchronized.._synchronized_wrappers.  H,@g ND+F+O N Ns! /c># T"UbUOU5IShvN U"U0UD6IShvN sSSS5IShvN $N%NN !,IShvN (df  g=f7frrl)rryrFrGrs 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 rr._SynchronizedFunctionWrapper.__enter__s/01A1ABDO OO # # %?? "r!c8URR5 gr)rrrrFs rr;synchronized.._SynchronizedFunctionWrapper.__exit__s OO # # %r!c># T"UR5UlURR5IShvN UR$N7fr)r$_self_async_lockr)rrs rr=synchronized.._SynchronizedFunctionWrapper.__aenter__sB$._SynchronizedFunctionWrapper.__aexit__s  ! ! ) ) +s)rrN) r,r-r.r/rrrrr1)rrsr_SynchronizedFunctionWrapperrs #  & )  ,r!rr)hasattrrrr rr) rrrrrrrrrrs @@@rrr1s8w ""ww 'B'B &t , ,  : : #.A #/}E E  0  0 %8 &m<<@$,2 ,,,$'w//+   ( WWr!r)$__doc__rr functoolsrinspectrrrrr threadingr r __wrapt__r r r decoratorsrrr5rArNrXr_rhrnrrrrrrrrrlr!rrs "QQ!(2O0O  4   O? O)6P1P !5  PO PtB  F 2 3>%!fgXT(,v $r!