o ".hP @sddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z ddl mZmZmZmZmZddlmZddlmZddZd ed efd d Zd ed efd dZd ed efddZGdddZGdddZGdddZeZe   d d ddededd eedefgeffddZ e  d!d edefdededd efddZ   d ddZ dS)"N)FutureThreadPoolExecutor)AnyCallableDictOptionaloverload)CurrentThreadExecutor)Localc CsV|D]&}z|||kr|||Wqty(|||YqwdSN)getset LookupError)contextcvarrK/var/www/supernova/superenvnew/lib/python3.10/site-packages/asgiref/sync.py_restore_contexts rfuncreturncCs"ttdr t|Stjj|_|SNmarkcoroutinefunction)hasattrinspectrasyncio coroutines _is_coroutinerrrrr$s   rcCsttdr t|St|Sr)rriscoroutinefunctionrrrrrr,s   rcCsRtjdkr t|St|r|j}t|st|tjr%|j }t|tjst|S)N)) sys version_inforrismethod__func__ isinstance functoolspartialrrrrr_iscoroutinefunction_or_partial3s    r)c@s(eZdZdZddZddZddZdS) ThreadSensitiveContextaiAsync context manager to manage context for thread sensitive mode This context manager controls which thread pool executor is used when in thread sensitive mode. By default, a single thread pool executor is shared within a process. In Python 3.7+, the ThreadSensitiveContext() context manager may be used to specify a thread pool per context. This context manager is re-entrant, so only the outer-most call to ThreadSensitiveContext will set the context. Usage: >>> import time >>> async with ThreadSensitiveContext(): ... await sync_to_async(time.sleep, 1)() cCs d|_dSr )tokenselfrrr__init__Vs zThreadSensitiveContext.__init__cs6ztjW|Stytj||_Y|Swr ) SyncToAsyncthread_sensitive_contextr rrr+r,rrr __aenter__Ys  z!ThreadSensitiveContext.__aenter__cs8|jsdStj|d}|r|tj|jdSr )r+r/context_to_thread_executorpopshutdownr0reset)r-excvaluetbexecutorrrr __aexit__asz ThreadSensitiveContext.__aexit__N)__name__ __module__ __qualname____doc__r.r1r:rrrrr*Bs  r*c@sZeZdZUdZiZded<eZiZded<dddZ d d Z d d Z d dZ ddZ dS) AsyncToSynca Utility class which turns an awaitable that only works on the thread with the event loop into a synchronous callable that works in a subthread. If the call stack contains an async loop, the code runs there. Otherwise, the code runs in a new loop in a new thread. Either way, this thread then pauses and waits to run any thread_sensitive code called from further down the call stack using SyncToAsync, before finally exiting once the async task returns. z,Dict[asyncio.Task[object], threading.Thread] launch_mapz6Dict[asyncio.AbstractEventLoop, CurrentThreadExecutor]loop_thread_executorsFcCst|rt|stt|d|stjddd||_z|jj|_Wn ty*Ynw|r2d|_dSzt |_WdSt yatt j dd}|r[|tkr[tt j dd|_YdSd|_YdSw)N__call__z4async_to_sync was passed a non-async-marked callable) stacklevelmain_event_loop_pidmain_event_loop)callabler)getattrwarningswarn awaitable__self__AttributeErrorrFrget_running_loop RuntimeErrorr/ threadlocalosgetpid)r-rKforce_new_looprErrrr.s<     zAsyncToSync.__init__c Oszt}Wn tyYn w|rtdtg}t}t}t |j dr/|j j }nd}t }||j _ d} zh| ||||t|} |jrO|jsqt} ||j| <tdd} | |j| | } |rl|| | n|j|jj| |r||W| dur|j| =t |j dr|j ` |r||j _ t|d|S| dur|j| =t |j dr|j ` |r||j _ t|dw)NznYou cannot use AsyncToSync in the same thread as an async event loop - just await the async function directly.currentr  max_workersr)rrNrO is_running contextvars copy_contextr threadingcurrent_threadr executorsrTr main_wrapr"exc_inforFnew_event_looprArsubmit_run_event_looprun_until_futureresultcall_soon_threadsafe create_taskr) r-argskwargs event_loopr call_result source_threadold_current_executorcurrent_executorlooprK loop_executor loop_futurerrrrBsj             zAsyncToSync.__call__cst|zm||Wz[t|D]}|qfdd}||D]}|r0q)|durA|d||dq)t|dr[|| W| t|j dSW| t|j dS| t|j wzYt|D]}|q{fdd}||D]}|rq|dur|d||dqt|dr|| W| t|j wW| t|j w| t|j w)zP Runs the given event loop (designed to be called in a thread). cstjddiIdHdS)Nreturn_exceptionsT)rgatherrtasksrrrqsz+AsyncToSync._run_event_loop..gatherNz(unhandled exception during loop shutdown)message exceptiontaskshutdown_asyncgens) rset_event_looprun_until_complete all_taskscancel cancelledrucall_exception_handlerrrwcloserF)r-rmcororvrqrrrrrasn              zAsyncToSync._run_event_loopcCt|j|}t||jSz* Include self for methods )r'r(rBupdate_wrapperrKr-parentobjtyperrrr__get__zAsyncToSync.__get__c s|dur t|dt}||j|<zaz*|dr3z|dty2|j|i|IdH}Yn w|j|i|IdH}WntyV} z || WYd} ~ nd} ~ ww||W|j|=t |d<dSW|j|=t |d<dS|j|=t |d<w)zs Wraps the awaitable with something that puts the result into the result/exception future. Nrr ) rr/get_current_taskr@ BaseExceptionrK set_exception set_resultrXrY) r-rfrgrirjr^r current_taskrcerrrr]s4    zAsyncToSync.main_wrapN)F)r;r<r=r>r@__annotations__r r\rAr.rBrarr]rrrrr?ks    &I$ r?c @seZdZUdZiZded<eZe ddZ e dZ ded<e dZd ed<eZd ed < ddedefdededdd fddZddZddZddZeddZd S)r/a Utility class which turns a synchronous callable into an awaitable that runs in a threadpool. It also sets a threadlocal inside the thread so calls to AsyncToSync can escape it. If thread_sensitive is passed, the code will run in the same thread as any outer code. This is needed for underlying Python code that is not threadsafe (for example, code which handles SQLite database connections). If the outermost program is async (i.e. SyncToAsync is outermost), then this will be a dedicated single sub-thread that all sync code runs in, one after the other. If the outermost program is sync (i.e. AsyncToSync is outermost), this will just be the main thread. This is achieved by idling with a CurrentThreadExecutor while AsyncToSync is blocking its sync parent, rather than just blocking. If executor is passed in, that will be used instead of the loop's default executor. In order to pass in an executor, thread_sensitive must be set to False, otherwise a TypeError will be raised. z,Dict[threading.Thread, asyncio.Task[object]]r@r rUr0zcontextvars.ContextVar[str]deadlock_contextzcontextvars.ContextVar[bool]z5weakref.WeakKeyDictionary[object, ThreadPoolExecutor]r2TNr.thread_sensitiver9rrcCst|rt|stt|d|rtd||_t||||_t||r.|dur.td||_ z|j |_ WdSt yBYdSw)NrBz4sync_to_async can only be applied to sync functions.z6executor must not be set when thread_sensitive is True) rGr)rH TypeErrorrr'r_thread_sensitiver _executorrLrM)r-rrr9rrrr.ns&   zSyncToAsync.__init__c svt}|jr\ttjdrtjj}nL|jr7|jdr7|j}||j vr,|j |}n3t dd}||j |<n(|tj vrBtj |}n|j rO|j drOt d|j}|j r[|j dn|j}t}tj|jg|Ri|}|j}|f}i}z3||tj|j||t|g|Ri|} tj| ddIdH} Wt||j r|j d| St||j r|j dww)NrTr rUFz9Single thread executor already being used, would deadlockT)timeout)rrNrrr?r\rTr0r r2rrArrOsingle_thread_executorrrrXrYr'r(rrunrun_in_executorthread_handlerrr"r^wait_forr) r-rfrgrmr9r0rchildrfutureretrrrrBsj             zSyncToAsync.__call__cCrr)r'r(rBrrrrrrrrzSyncToAsync.__get__c Os||j_t|j_t}tj ||krd}n||j|<d}z0|drBz|dt yA||i|YW|r@|j|=SSw||i|W|rP|j|=SS|rW|j|=w)zE Wraps the sync application with exception handling. FTr ) rPrFrQrRrErZr[r?r@r r) r-rm source_taskr^rrfrgr[ parent_setrrrrs,      zSyncToAsync.thread_handlercCs ztWStyYdSw)zi Implementation of asyncio.current_task() that returns None if there is no task. N)rrrOrrrrrs   zSyncToAsync.get_current_taskTN)r;r<r=r>r@rrZlocalrPrrrX ContextVarr0rweakrefWeakKeyDictionaryr2rrboolrr.rBrr staticmethodrrrrrr/=s:        C!r/Trr9r.cCdSr rrrr9rrr sync_to_asyncrcCrr rrrrrr rcs$|dur fddSt|dS)Ncst|dS)Nrr9r/)fr9rrrs zsync_to_async..rrrrrrrs)NTNr)!rasyncio.coroutinesrXr'rrQr"rZrIrconcurrent.futuresrrtypingrrrrrcurrent_thread_executorr rr rrrrr)r*r?r/ async_to_syncrrrrrsj  )SB