˔j7UdZddlZddlZddlZddlmZddlmZmZm Z m Z m Z m Z m Z ddlmZmZddlmZmZmZddlmZGd d eZGd d eZGd deZGddeZGddeZGddeZGddeZGddeZd!dddZd!dddZ dZ!dZ"dZ#dZ$d Z%ee%_&dS)"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) decoratorc6eZdZdfd ZedZxZS)_SyncCodeProxyNcXt|||_dSNsuper__init___self_generatorselfwrapped generator __class__s CC:\Projects\DSCons\.venv\Lib\site-packages\wrapt/synchronization.pyrz_SyncCodeProxy.__init__%) !!!(c|jj}|ttztzz}|jdur |t z}n)|jdur |t z}n|tzr |t z}|SNTF) __wrapped__co_flagsrrrrrroriginalflagss rr%z_SyncCodeProxy.co_flags)s}#,\,>>AVVWW  4 ' ' \ !EE  !U * * l] "EE ,, &% r!r__name__ __module__ __qualname__rpropertyr% __classcell__rs@rrr#sX))))))Xr!rc6eZdZdfd ZedZxZS)_SyncFunctionSurrogateNcXt|||_dSrrrs rrz_SyncFunctionSurrogate.__init__>r r!c@t|jj|jSrrr$__code__rrs rr5z_SyncFunctionSurrogate.__code__Bd.79MNNNr!rr*r+r,rr-r5r.r/s@rr1r1<s_))))))OOXOOOOOr!r1c4eZdZfdZedZxZS)_BoundSyncFunctionWrappercHtj|i|d|_dSNT)rr_self_is_not_coroutine)rargskwargsrs rrz"_BoundSyncFunctionWrapper.__init__Is-$)&)))&*###r!cJt|jj|jjSr)r1r$__func__ _self_parentrr6s rrAz"_BoundSyncFunctionWrapper.__func__Ms%%   %t'8'H   r!)r*r+r,rr-rAr.r/s@rr:r:GsS+++++  X     r!r:c:eZdZeZdfd ZedZxZS)_SyncFunctionWrapperNcht||d|_||_dSr<)rrr=rrrwrapperrrs rrz_SyncFunctionWrapper.__init__Xs3 '***&*#(r!c@t|jj|jSrr4r6s rr5z_SyncFunctionWrapper.__code__]r7r!r) r*r+r,r:__bound_function_wrapper__rr-r5r.r/s@rrDrDTse!:)))))) OOXOOOOOr!rDc6eZdZdfd ZedZxZS)_AsyncCodeProxyNcXt|||_dSrrrs rrz_AsyncCodeProxy.__init__dr r!c|jj}|ttztzt zz}|jdur |t z}n;|jdur |tz}n'|tt zzr |t z}n |tz}|Sr#)r$r%rrrrrr&s rr%z_AsyncCodeProxy.co_flagshs#, < '*? ?BT T    4 ' ' ' 'EE  !U * * \ !EE<*<<= &++% r!rr)r/s@rrKrKbsX))))))Xr!rKc6eZdZdfd ZedZxZS)_AsyncFunctionSurrogateNcXt|||_dSrrrs rrz _AsyncFunctionSurrogate.__init__r r!c@t|jj|jSrrKr$r5rr6s rr5z _AsyncFunctionSurrogate.__code__t/8$:NOOOr!rr8r/s@rrOrO}s_))))))PPXPPPPPr!rOc$eZdZedZdS)_BoundAsyncFunctionWrappercJt|jj|jjSr)rOr$rArBrr6s rrAz#_BoundAsyncFunctionWrapper.__func__s%&   %t'8'H   r!N)r*r+r,r-rAr!rrUrUs-   X   r!rUc:eZdZeZdfd ZedZxZS)_AsyncFunctionWrapperNcZt||||_dSrrrFs rrz_AsyncFunctionWrapper.__init__s+ '***(r!c@t|jj|jSrrRr6s rr5z_AsyncFunctionWrapper.__code__rSr!r) r*r+r,rUrIrr-r5r.r/s@rrYrYse!;))))))PPXPPPPPr!rYrc,fd}||S||S)a9Mark 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.d}t||S)Nc||i|SrrWrinstancer>r?s r_wrapperz2mark_as_sync.._decorator.._wrapper7D+F++ +r!r\)rDrrbrs r _decoratorz mark_as_sync.._decorators) , , ,$GXKKKKr!rWrrres ` r mark_as_syncrgs>,LLLLL  :g  r!c,fd}||S||S)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.d}t||S)Nc||i|SrrWr`s rrbz3mark_as_async.._decorator.._wrapperrcr!r\)rYrds rrez!mark_as_async.._decorators) , , ,%Wh)LLLLr!rWrfs ` r mark_as_asyncrks>0MMMMM  :g  r!ct|rtdt|rtdt|st jdt dd}t||dS) 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.) stacklevelc6tj||i|Sr)asynciorunr`s rrGzasync_to_sync..wrapper s!{77D3F33444r!Fr\)r TypeErrorr r warningswarn UserWarningrDrrGs r async_to_syncrws '""  E   7##  )    w ' '    E      555 E B B BBr!ct|st|rtdt|rtdd}t ||dS)a Adapt 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.cKtj}|dt|g|Ri|d{VSr)rpget_running_looprun_in_executorr)rrar>r?loops rrGzsync_to_async..wrapper4sT'))))$0Q$0Q0Q0Q&0Q0QRRRRRRRRRr!Fr\)r rrrr rYrvs r sync_to_asyncr}s 7## '9''B'B  H   7##  0   SSS !'U C C CCr!c>tt|ddS)Nacquire)r getattr)objs r_synchronized_is_async_lockr;s wsIt<< = ==r!cxt||i}tj}|} t|tt frjt |dd}||j}|}t|}||vst||kr"td ||||<t |ddrdSt|rdSt |dd}|||urdS|}t|}||vst||kr"td ||||<)NTr$z!wrapper loop when unwrapping {!r}r=F) idsysgetrecursionlimit isinstance classmethod staticmethodrrAlen ValueErrorformatr )rmemorecursion_limittargetinner id_target next_targets r_synchronized_is_async_callabler?s^ sGGS>D+--O F! f{L9 : : FM488E}F6 ID  CII$@$@ !D!K!KC!P!PQQQ$DO  63U ; ; 5 v & & 4fmT::  +"7"75vJJ   D _ < <@GGLLMM M Y3!r!c t|drt|drw| t r3t fd}G fddt}||St fd}G fdd t}||Sd d fd }fd }Gfddt}t |r |||S|||S)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. rreleasecK4d{V||i|d{Vcdddd{VS#1d{VswxYwYdSrrWrrar>r?locks r _synchronizedz#synchronized.._synchronizeds::::::::!($!9&!9!9999999::::::::::::::::::::::::::::::s - 77c$eZdZfdZfdZdS)1synchronized.._AsyncSynchronizedLockProxyc@Kd{VSrrrrs r __aenter__z._AsyncSynchronizedLockProxy.__aenter__s,,,..(((((((Kr!c4KdSrrrr>rs r __aexit__z;synchronized.._AsyncSynchronizedLockProxy.__aexit__sLLNNNNNr!N)r*r+r,rrrsr_AsyncSynchronizedLockProxyrsG     #######r!r)rcL5||i|cdddS#1swxYwYdSrrWrs rrz#synchronized.._synchronizeds  0 0w/// 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0s c$eZdZfdZfdZdS),synchronized.._SynchronizedLockProxyc0Srrrs r __enter__z6synchronized.._SynchronizedLockProxy.__enter__s  r!c0dSrrrs r__exit__z5synchronized.._SynchronizedLockProxy.__exit__s r!N)r*r+r,rrrsr_SynchronizedLockProxyrsG            r!rc t|dd}|htj5t|dd}|t }t |d|dddn #1swxYwY|S)N_synchronized_lock)varsget synchronized_synchronized_meta_lockr setattrcontextrs rrz(synchronized.._synchronized_locksG}}  !5t<< <5 A A G}}(()=tDD< 77DG%94@@@ A A A A A A A A A A A A A A A sABB Bc*t|dd}|mtj5t|dd}|$t j}t |d|dddn #1swxYwY|S)N_synchronized_async_lock)rrrrrpr rrs rrz.synchronized.._synchronized_async_locks G}}  !;TBB <5 G GG}}(()CTJJ<"<>>DG%?FFF  G G G G G G G G G G G G G G G sA BB B cf||n|5||i|cdddS#1swxYwYdSrrW)rrar>r?rs r_synchronized_wrapperz+synchronized.._synchronized_wrappers  H,@g N N , ,7D+F++ , , , , , , , , , , , , , , , , , ,s &**cK||n|4d{V||i|d{Vcdddd{VS#1d{VswxYwYdSrrW)rrar>r?rs r_synchronized_async_wrapperz1synchronized.._synchronized_async_wrappers ++ ,HH'   2 2 2 2 2 2 2 2!$1&11111111 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2s: AAc0eZdZfdZdZfdZdZdS)2synchronized.._SynchronizedFunctionWrappercn|j|_|j|jSr)r$ _self_lockr)rrs rrz._SynchronizedFunctionWrapper.__enter__s4001ABBDO O # # % % %? "r!c8|jdSr)rrrr>s rrz;synchronized.._SynchronizedFunctionWrapper.__exit__ s O # # % % % % %r!c~K|j|_|jd{V|jSr)r$_self_async_lockr)rrs rrz=synchronized.._SynchronizedFunctionWrapper.__aenter__ sM$<$._SynchronizedFunctionWrapper.__aexit__s!  ! ) ) + + + + +r!N)r*r+r,rrrr)rrsr_SynchronizedFunctionWrapperrse # # # # #  & & & ) ) ) ) )  , , , , ,r!rrv)hasattrrrrrr) rrrrrrrrrrs @@@rrrrs8w "",=ww 'B'B,= &t , , F  : : : :Y : # # # # # # #.A # # #/.}EEE E  0 0 0 0  0       %8   &%m<<<<@$,,,,,22222 ,,,,,,,,,,,$'w// ++%@     ( 'AV W W WWr!r)'__doc__rprrs functoolsrinspectrrrrrr r threadingr r __wrapt__rrr decoratorsrrr1r:rDrKrOrUrYrgrkrwr}rrrrrWr!rrs  "!!!!!!!QQQQQQQQQQ!!!!!!(2OOOOO0OOO      4     O O O O O? O O O)6PPPPP1PPP     !5    P P P P PO P P PtB      F.C.C.Cb%D%D%DP>>>%!%!%!fgXgXgXT(,tvv $$$r!