U ڲgS@sUddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z ddl mZmZmZmZmZmZmZmZmZmZmZmZddlmZddlmZejdkrddl mZn ddl mZerdd l!m"Z"ed ed efd Z#ed Z$edZ%ej&ddddZ'e(edrHej)Z)ej*Z*ee#ge#fe+d<nej)Z)e#e#dddZ*GdddZ,Gdddee$e%fZ-Gdddee$e%fZ.edde/eeee$eeee%ffee$ee%ffgee$e%ffdddZ0eddeee$eeee%ffee$ee%ffe/ee$e%fd d!dZ0d,ddeeee$eeee%ffee$ee%ffe/eeeee$eeee%ffee$ee%ffgee$e%ffee$e%ffd d"dZ0ed#dd$e/ed%eee$e%fgee$eeee%fffd&d'd(Z1ed#dd$ee$e%fe/ed%ee$eeee%ffd)d*d(Z1d-d#dd$eee$e%fe/ed%eeee$e%fgee$eeee%fffee$eeee%fffd)d+d(Z1dS).N)FutureThreadPoolExecutor) TYPE_CHECKINGAny AwaitableCallable CoroutineDictGenericListOptionalTypeVarUnionoverload)CurrentThreadExecutor)Local) ) ParamSpec) OptExcInfo_F.)bound_P_R)contextreturnc CsR|D]H}||}z||kr*||Wqtk rJ||YqXqdSN)getset LookupError)rZcvarZcvaluer!0/tmp/pip-unpacked-wheel-hay1n6u8/asgiref/sync.py_restore_context,s  r#markcoroutinefunction)funcrcCstjj|_|Sr)asyncioZ coroutinesZ _is_coroutine)r%r!r!r"r$Cs c@s(eZdZdZddZddZddZdS) ThreadSensitiveContextaYAsync 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. 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)tokenselfr!r!r"__init__\szThreadSensitiveContext.__init__cs6ztjWn"tk r0tj||_YnX|Sr) SyncToAsyncthread_sensitive_contextrr rr(r)r!r!r" __aenter___s z!ThreadSensitiveContext.__aenter__cs6|js dStj|d}|r$|tj|jdSr)r(r,context_to_thread_executorpopshutdownr-reset)r*excvaluetbexecutorr!r!r" __aexit__gs z ThreadSensitiveContext.__aexit__N)__name__ __module__ __qualname____doc__r+r.r7r!r!r!r"r'Hsr'c@seZdZUdZeZded<iZded<dee e e e e e ffe e ee ffeddd Ze je je d d d Zd dZe e e e e fdddZdddeeje je jddddZdS) 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. r executorsz6Dict[asyncio.AbstractEventLoop, CurrentThreadExecutor]loop_thread_executorsF awaitableforce_new_loopcCst|r t|s.tt|d|s.tjddd||_z|jj|_Wntk rVYnX||_d|_ zt |_ Wnt k rYnXdS)N__call__z4async_to_sync was passed a non-async-marked callable) stacklevel) callableiscoroutinefunctiongetattrwarningswarnr@__self__AttributeErrorrAmain_event_loopr&get_running_loop RuntimeError)r*r@rAr!r!r"r+s(zAsyncToSync.__init__argskwargsrc Oszd}|js>|js>ttjdd}|r>|tkr>ttjdd|_z t}Wnt k r^YnX| rpt dt }t|j dd}t }||j _tg} ttjdd} d} z|j|t| | f||} |jr|j s$t} ||j| <tdd } | |j| | }|r|||n"|j|jj| |rF||W5| dk r\|j| =t| d||j _X|S) NTmain_event_loop_pidrLznYou cannot use AsyncToSync in the same thread as an async event loop - just await the async function directly.current task_contextrr max_workers)rArLrGr, threadlocalosgetpidr&rMrNZ is_runningrr=rrS contextvars copy_contextr>r# main_wrapsysexc_infoZnew_event_looprZsubmit_run_event_loopZrun_until_futureresultZcall_soon_threadsafeZ create_task)r*rPrQ__traceback_hide__rRZ event_loop call_resultZ old_executorZcurrent_executorrrTloopr@Z loop_executorZ loop_futurer!r!r"rBs|           zAsyncToSync.__call__cst|z||W5zt|D] }|q*fdd}||D]0}|rbqT|dk rT| d||dqTt |dr|| W5|t|jXXdS)zP Runs the given event loop (designed to be called in a thread). cstjddiIdHdS)NZreturn_exceptionsT)r&gatherr!Ztasksr!r"rdsz+AsyncToSync._run_event_loop..gatherNz(unhandled exception during loop shutdown)message exceptiontaskshutdown_asyncgens) r&Zset_event_loopcloserLZ all_taskscancelZrun_until_completeZ cancelledrgZcall_exception_handlerhasattrri)r*rccororhrdr!rer"r_s.       zAsyncToSync._run_event_loopparentobjtypercCst|j|}t||jSz* Include self for methods ) functoolspartialrBupdate_wrapperr@r*rorpr%r!r!r"__get__$szAsyncToSync.__get__z Future[_R]rz!Optional[List[asyncio.Task[Any]]]N)rbr^rTrrPrQrc sd}|dk rt|dt}|dk r:|dk r:||zzT|dr|z |dWqtk rx|j||IdH} YqXn|j||IdH} Wn,tk r} z| | W5d} ~ XYn X| | W5|dk r|dk r||t|d<XdS)zs Wraps the awaitable with something that puts the result into the result/exception future. TNrr) r#r& current_taskappendremoverZr[ BaseExceptionr@Z set_exceptionZ set_result) r*rbr^rTrrPrQrarwr`er!r!r"r\+s&    zAsyncToSync.main_wrap)F)r8r9r:r;rr=__annotations__r>rrrrrrrboolr+rPrQrBr_rvr rZContextr\r!r!r!r"r<qs.   \$ r<c@seZdZUdZeZeddZe dZ de d<e dZ de d<eZde d <deeefeed d d ddZejejedddZeeeeeeeeffdddZddZd 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. rrUr-z.contextvars.ContextVar[ThreadSensitiveContext]deadlock_contextzcontextvars.ContextVar[bool]zEweakref.WeakKeyDictionary[ThreadSensitiveContext, ThreadPoolExecutor]r/TNrr%thread_sensitiver6rcCst|r t|s tt|d|r(td||_t||||_t||r\|dk r\td||_ z |j |_ Wnt k rYnXdS)NrBz4sync_to_async can only be applied to sync functions.z6executor must not be set when thread_sensitive is True) rErFrG TypeErrorr%rrrt_thread_sensitiver$ _executorrJrK)r*r%rr6r!r!r"r+s$   zSyncToAsync.__init__rOc sd}t}|jrttjdd}|r*|}q|jdrl|j}||jkrV|j|}qt dd}||j|<q|tj krtj |}q|j drt dq|j }|j dn|j}t}tj|jf||} |j} g} ||t|j|t| | | } zzt| IdH} Wntjk rd}z@| d}|z|IdHd}Wntjk rdYnXWntk r~YnX| r|r| | IdH} YnXW5t||j dX| S)NTrSrrUFz9Single thread executor already being used, would deadlockr) r&rMrrGr<r=r-rr/rr>rrNsingle_thread_executorrrrZr[rrrsr%runZrun_in_executorthread_handlerr]r^r#ZshieldZCancelledErrorrk IndexErrordone)r*rPrQrarccurrent_thread_executorr6r-rchildr%rTZ exec_cororetZ cancel_parentrhr!r!r"rBst             zSyncToAsync.__call__rncCst|j|}t||jSrq)rrrsrBrtr%rur!r!r"rvszSyncToAsync.__get__cOsdd}||j_t|j_||j_|drVz |dWq`tk rR|||YSXn |||SdS)zE Wraps the sync application with exception handling. TrN)rWrLrXrYrRrTrz)r*rcr^rTr%rPrQrar!r!r"rs  zSyncToAsync.thread_handler)TN)r8r9r:r; threadinglocalrWrrrZZ ContextVarr-r|rweakrefWeakKeyDictionaryr/rrrr}r r+rPrQrBrrrvrr!r!r!r"r,Vs0       Q r,FrA)rArcCsdSrr!rr!r!r" async_to_sync sr)r@rArcCsdSrr!r?r!r!r"rs cs |dkrfddSt|dS)Ncs t|dS)Nrr<frr!r"5szasync_to_sync..rrr?r!rr"r$s  Trr6r)rr6rcCsdSrr!rr!r!r" sync_to_async?srrcCsdSrr!r%rr6r!r!r"rHscs$|dkrfddSt|dS)Ncst|dS)Nrr,rr6rr!r"r\szsync_to_async..rrrr!rr"rRs )N)N)2r&Zasyncio.coroutinesrZrrinspectrXr]rrHrconcurrent.futuresrrtypingrrrrrr r r r r rrrrrr version_inforZtyping_extensionsZ _typeshedrrrrr~r#rlrFr$r|r'r<r,r}rrr!r!r!r"s8      )f8*   *   &  &