a `*j"G@s@dZddlZddlZddlmZddlmZmZmZm Z m Z ddl m Z m Z ddlmZmZmZddlmZGd d d eZGd d d eZGd ddeZGdddeZGdddeZGdddeZGdddeZGdddeZd(ddddZd)ddddZddZd d!Zd"d#Z d$d%Z!d&d'Z"e e"_#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_COROUTINEiscoroutinefunction)LockRLock)BoundFunctionWrapperCallableObjectProxyFunctionWrapper) decoratorcs*eZdZdfdd ZeddZZS)_SyncCodeProxyNcst|||_dSNsuper__init___self_generatorselfwrapped generator __class__Q/var/www/html/assistant/venv/lib/python3.9/site-packages/wrapt/synchronization.pyr"s z_SyncCodeProxy.__init__cCsX|jj}|ttBtB@}|jdur.|tO}n&|jdurD|tM}n|t@rT|tO}|SNTF) __wrapped__co_flagsrrrrrroriginalflagsrrrr&s    z_SyncCodeProxy.co_flags)N__name__ __module__ __qualname__rpropertyr __classcell__rrrrr srcs*eZdZdfdd ZeddZZS)_SyncFunctionSurrogateNcst|||_dSrrrrrrr;s z_SyncFunctionSurrogate.__init__cCst|jj|jSrrr__code__rrrrrr+?sz_SyncFunctionSurrogate.__code__)Nr$r%r&rr'r+r(rrrrr)9sr)cs(eZdZfddZeddZZS)_BoundSyncFunctionWrappercstj|i|d|_dSNT)rr_self_is_not_coroutine)rargskwargsrrrrFsz"_BoundSyncFunctionWrapper.__init__cCst|jj|jjSr)r)r__func__ _self_parentrr,rrrr3Js z"_BoundSyncFunctionWrapper.__func__)r$r%r&rr'r3r(rrrrr.Ds r.cs.eZdZeZdfdd ZeddZZS)_SyncFunctionWrapperNcst||d|_||_dSr/)rrr0rrrwrapperrrrrrUsz_SyncFunctionWrapper.__init__cCst|jj|jSrr*r,rrrr+Zsz_SyncFunctionWrapper.__code__)N) r$r%r&r.__bound_function_wrapper__rr'r+r(rrrrr5Qsr5cs*eZdZdfdd ZeddZZS)_AsyncCodeProxyNcst|||_dSrrrrrrras z_AsyncCodeProxy.__init__cCsh|jj}|ttBtBtB@}|jdur2|tO}n2|jdurF|tO}n|ttB@r\|tO}n|tO}|Sr)rrrrrrrr rrrres      z_AsyncCodeProxy.co_flags)Nr#rrrrr9_sr9cs*eZdZdfdd ZeddZZS)_AsyncFunctionSurrogateNcst|||_dSrrrrrrr|s z _AsyncFunctionSurrogate.__init__cCst|jj|jSrr9rr+rr,rrrr+sz _AsyncFunctionSurrogate.__code__)Nr-rrrrr:zsr:c@seZdZeddZdS)_BoundAsyncFunctionWrappercCst|jj|jjSr)r:rr3r4rr,rrrr3s z#_BoundAsyncFunctionWrapper.__func__N)r$r%r&r'r3rrrrr<sr<cs.eZdZeZdfdd ZeddZZS)_AsyncFunctionWrapperNcst||||_dSrrr6rrrrsz_AsyncFunctionWrapper.__init__cCst|jj|jSrr;r,rrrr+sz_AsyncFunctionWrapper.__code__)N) r$r%r&r<r8rr'r+r(rrrrr=sr=rcs fdd}|dur|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). csdd}t||dS)NcSs||i|Srrrinstancer1r2rrr_wrappersz2mark_as_sync.._decorator.._wrapperr>r5)rrAr>rr _decoratorsz mark_as_sync.._decoratorNrrrrCrr>r mark_as_syncs rEcs*ddfdd}|dur"|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). cs||i|Srrr?rrrrAszmark_as_async.._wrappercst|dS)Nr>r=rrArrrrCsz!mark_as_async.._decoratorNrrDrrHr mark_as_asyncs rIcCsdd}t||S)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.cSst||i|Sr)asynciorunr?rrrr7szasync_to_sync..wrapperrBrr7rrr async_to_syncsrMcCsdd}t||S)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.cs,t}|dt|g|Ri|IdHSr)rJZget_running_loopZrun_in_executorr)rr@r1r2looprrrr7szsync_to_async..wrapperrFrLrrr sync_to_asyncsrOcCstt|ddS)Nacquire)rgetattr)objrrr_synchronized_is_async_locksrScCst||i}t}|}t|ttfrxt|dd}|dur@|j}|}t|}||vs`t||krnt d ||||<qt|ddrdSt |rdSt|dd}|dus||urdS|}t|}||vst||krt d ||||<qdS)Nrz!wrapper loop when unwrapping {!r}r0FT) idsysgetrecursionlimit isinstance classmethod staticmethodrQr3len ValueErrorformatr)rRmemorecursion_limittargetinnerZ id_targetZ next_targetrrr_synchronized_is_async_callables2    racst|dr|t|dr||trNtfdd}Gfdddt}||dStfdd}Gfd d d t}||dSd d d dfdd}fdd}Gfdddt}t|r|||dS|||dS)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. rPreleasec sP4IdH*||i|IdHWdIdHS1IdHsB0YdSrrr?lockrr _synchronizedXsz#synchronized.._synchronizedcs$eZdZfddZfddZdS)z1synchronized.._AsyncSynchronizedLockProxycsIdHSrrPr,rcrr __aenter___sz._AsyncSynchronizedLockProxy.__aenter__cs dSrrbrr1rcrr __aexit__csz;synchronized.._AsyncSynchronizedLockProxy.__aexit__N)r$r%r&rgrjrrcrr_AsyncSynchronizedLockProxy]s rkrGcs6||i|WdS1s(0YdSrrr?rcrrrehscs$eZdZfddZfddZdS)z,synchronized.._SynchronizedLockProxycs Srrfr,rcrr __enter__rsz6synchronized.._SynchronizedLockProxy.__enter__cs dSrrhrircrr__exit__vsz5synchronized.._SynchronizedLockProxy.__exit__N)r$r%r&rlrmrrcrr_SynchronizedLockProxyps rncSslt|dd}|durhtj:t|dd}|durJt}t|d|Wdn1s^0Y|S)N_synchronized_lock)varsget synchronized_synchronized_meta_lockr setattrcontextrdrrrros *z(synchronized.._synchronized_lockcSsnt|dd}|durjtj<t|dd}|durLt}t|d|Wdn1s`0Y|S)N_synchronized_async_lock)rprqrrrsrJrrtrurrrrws*z.synchronized.._synchronized_async_lockcsF|dur|n|||i|WdS1s80YdSrrr?rorr_synchronized_wrappersz+synchronized.._synchronized_wrapperc s`|dur|n|4IdH*||i|IdHWdIdHS1IdHsR0YdSrrr?rwrr_synchronized_async_wrappersz1synchronized.._synchronized_async_wrappercs4eZdZfddZddZfddZddZd S) z2synchronized.._SynchronizedFunctionWrappercs|j|_|j|jSr)r _self_lockrPr,rxrrrls  z._SynchronizedFunctionWrapper.__enter__cWs|jdSr)r|rbrirrrrmsz;synchronized.._SynchronizedFunctionWrapper.__exit__cs"|j|_|jIdH|jSr)r_self_async_lockrPr,rzrrrgs z=synchronized.._SynchronizedFunctionWrapper.__aenter__cs|jdSr)r}rbrirrrrjsz._SynchronizedFunctionWrapper.__aexit__N)r$r%r&rlrmrgrjr)rwrorr_SynchronizedFunctionWrappers  r~rL)hasattrrSrr r ra)rrerkrnryr{r~r)rwrordrrr1s*     rr)N)N)$__doc__rJrU functoolsrinspectrrrrr threadingrr Z __wrapt__r r r Z decoratorsrrr)r.r5r9r:r<r=rErIrMrOrSrarrrsrrrrs0       !# 3+