rj'ddlmZddlZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlZddlmZddlmZddlmZedeZededZedeZd(dZ Gdd eeZ!Gd!d"e eejDZ#Gd#d$e#eZ$ d)d%Z%Gd&d'e!eZ&y)*) annotationsN)Any)AsyncGenerator) AsyncIterator) Awaitable)Callable)ClassVar) Coroutine)Dict) Generator)Generic)Literal)NoReturn)Optional)overload)Tuple)TypeVar)exc)util)Self_T)bound_T_coT)r covariant_PTcKtj|}d} tj|d{} |||S7 #tj$r}|j r|}Yd}~nd}~wwxYw[w)abRun ``coro`` in a task of its own and wait for it to complete, even if the calling task is cancelled meanwhile. Used for cleanup, such as the ``close()`` performed by an async context manager on exit, that must not be abandoned partway through. A cancellation received while waiting is re-raised once ``coro`` has completed, so that the caller does not return before its cleanup has finished; were it to return early, the cleanup would carry on in the background, where for example it could return a connection into a pool that the application has meanwhile disposed of. N)asyncio create_taskshieldCancelledErrordone)corotask cancelledresulterrs f/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/sqlalchemy/ext/asyncio/base.py_run_to_completionr**s|   t $DI  ">>$//F  M0%% yy{I  s=A6AAAA6AA2A-(A6-A22A6c eZdZUiZded<dZed dZeddZddZe d ddZ e dd Z ee d dd Z ee d dd Z e d dd Z y)ReversibleProxyzCClassVar[Dict[weakref.ref[Any], weakref.ref[ReversibleProxy[Any]]]]_proxy_objects) __weakref__cyNselftargets r)_assign_proxiedzReversibleProxy._assign_proxiedMs36cyr0r1r2s r)r5zReversibleProxy._assign_proxiedPs58r6c|otj|tj}tj|t j tj|}|tj |<|Sr0)weakrefrefr, _target_gced functoolspartialr-)r3r4 target_ref proxy_refs r)r5zReversibleProxy._assign_proxiedSsb  +2;;44,J !!/">"> KI:CO * *: 6 r6Nc<|jj|dyr0)r-pop)clsr:r?s r)r;zReversibleProxy._target_gced`s sD)r6c tr0NotImplementedError)rBr4 additional_kws r)_regenerate_proxy_for_targetz,ReversibleProxy._regenerate_proxy_for_targeths "##r6c yr0r1rBr4 regeneraterFs r)_retrieve_proxy_for_targetz*ReversibleProxy._retrieve_proxy_for_targetnsr6c yr0r1rIs r)rKz*ReversibleProxy._retrieve_proxy_for_targettsr6c  |jtj|}|}||S|r|j|fi|Sy#t$rY!wxYwr0)r-r9r:KeyErrorrG)rBr4rJrFr?proxys r)rKz*ReversibleProxy._retrieve_proxy_for_targetzsf **7;;v+>?IKE  3333FLmL L   s"A AA)r4rreturnr)r4NonerPrQ)r4 Optional[_PT]rPrRr0)r:zweakref.ref[_PT]r?zOptional[weakref.ref[Self]]rPrQ)r4rrFrrPr).)r4rrJz Literal[True]rFrrPr)T)r4rrJboolrFrrPzOptional[Self]) __name__ __module__ __qualname__r-__annotations__ __slots__rr5 classmethodr;rGrKr1r6r)r,r,GsT  !I 66 88 26* */*  **$$+.$ $$ 69&3LO -1&*DG -1&*DG r6r,ceZdZdZej dd dZd dZd dZej d dZ d dZ y)StartableContextr1cKtwr0rD)r3 is_ctxmanagers r)startzStartableContext.starts!##s c>|jjSr0)r^ __await__r3s r)r`zStartableContext.__await__szz|%%''r6cBK|jdd{S7w)NT)r])r^ras r) __aenter__zStartableContext.__aenter__sZZdZ3333s c Kywr0r1)r3type_value tracebacks r) __aexit__zStartableContext.__aexit__s  scZtjd|jjz)Nz@%s context has not been started and object has not been awaited.) async_excAsyncContextNotStarted __class__rTras r)_raise_for_not_startedz'StartableContext._raise_for_not_starteds*.. N~~&& (  r6NFr]rSrPr)rPzGenerator[Any, Any, _T_co])rPr)rerrfrrgrrPOptional[bool])rPr) rTrUrVrXabcabstractmethodr^r`rcrhrmr1r6r)r[r[shI$$(4   !$ 14    r6r[cReZdZUdZded< ddZd d dZ d dZy) GeneratorStartableContextgenzAsyncGenerator[_T_co, Any]rvc||i||_yr0ru)r3funcargskwdss r)__init__z"GeneratorStartableContext.__init__s &&r6cK t|jd{}|s"|jj d{|S7*#t$r tddwxYw7!w)Nzgenerator didn't yield)anextrvStopAsyncIteration RuntimeErroraclose)r3r] start_values r)r^zGeneratorStartableContext.startsd C %dhh/K((//# # #0! C78d B C $s7A$A AA A$A"A$A AA$cK|) t|jd{td||} |jj |d{td7G#t$rYywxYw7 #t$r}||ucYd}~Sd}~wt$r8}||urYd}~yt |t tfr|j|urYd}~yd}~wt$r}||urYd}~yd}~wwxYww)Nzgenerator didn't stopFz$generator didn't stop after athrow()) r}rvrr~athrow isinstance StopIteration __cause__ BaseException)r3typrfrgrs r)rhz#GeneratorStartableContext.__aexit__s ; <DHHo%%##:;;}! hhooe,,,BEF FY&%  -% (%'' %< u}6H&IJ .  e# sC(A(A&A(C(A9A7A9 C(&A(( A41C(3A44C(7A99 C%B C%C( C%C C( $C C( C  C%C C( C%%C(N)rx#Callable[..., AsyncIterator[_T_co]]ryzTuple[Any, ...]rzzDict[str, Any]rnro)rrrfrrgrrPrp)rTrUrVrXrWr{r^rhr1r6r)rtrts]I ##'1'' ' 2G2G"2G/22G 2Gr6rtcDtjdfd }|S)a=@asyncstartablecontext decorator. the decorated function can be called either as ``async with fn()``, **or** ``await fn()``. This is decidedly different from what ``@contextlib.asynccontextmanager`` supports, and the usage pattern is different as well. Typical usage: .. sourcecode:: text @asyncstartablecontext async def some_async_generator(): try: yield except GeneratorExit: # return value was awaited, no context manager is present # and caller will .close() the resource explicitly pass else: Above, ``GeneratorExit`` is caught if the function were used as an ``await``. In this case, it's essential that the cleanup does **not** occur, so there should not be a ``finally`` block. If ``GeneratorExit`` is not invoked, this means we're in ``__aexit__`` and we were invoked as a context manager, and cleanup should proceed. ct||Sr0)rt)ryrzrxs r)helperz%asyncstartablecontext..helpers(tT::r6)ryrrzrrPz GeneratorStartableContext[_T_co])r<wraps)rxrs` r)asyncstartablecontextrs(J__T;; Mr6cNeZdZdZej ddZddZd dZd dZ y) ProxyComparabler1ctr0rDras r)_proxiedzProxyComparable._proxied's !##r6ct|Sr0)idras r)__hash__zProxyComparable.__hash__+s $xr6cdt||jxr|j|jk(Sr0rrlrr3others r)__eq__zProxyComparable.__eq__.s* udnn - 0 / r6cft||j xs|j|jk7Sr0rrs r)__ne__zProxyComparable.__ne__4s-5$..1 1 /}}. r6N)rPr)rPint)rrrPrS) rTrUrVrXrro_non_memoized_propertyrrrrr1r6r)rr$s.I ""$#$  r6r)r$zCoroutine[Any, Any, _T]rPr)rxrrPz/Callable[..., GeneratorStartableContext[_T_co]])' __future__rrqrr<typingrrrrrr r r r r rrrrrrr9rrjr util.typingrrrrr*r,ABCr[rtrrr1r6r)rs# !  Tsd3e3:CgclCL y' 4NG 0 7NGb) -)4)X oc* r6