3 gVO @sRddlZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z ddl m Z mZmZmZmZddlmZddlmZddlmZejdkrddlZndZd d Ze ed d dZGdddZGdddZGdddZeZ eddeedeede fgefdddZ!edede feededddZ!d ddZ!dS)!N)FutureThreadPoolExecutor)AnyCallableDictOptionaloverload)get_running_loop)CurrentThreadExecutor)Localc Cs^xX|D]P}y&|j|j|kr.|j|j|Wqtk rT|j|j|YqXqWdS)N)getset LookupError)contextZcvarrJ/var/www/tester-filtro-web/env/lib/python3.6/site-packages/asgiref/sync.py_restore_contexts  r)funcreturncCsPtjdkrtj|Sxtj|r(|j}qWxt|tj r@|j }q,Wtj|SdS)Nr )r r) sys version_infoasyncioiscoroutinefunctioninspectismethod__func__ isinstance functoolspartialr)rrrr_iscoroutinefunction_or_partial!s     r#c@s>eZdZdZddZer*ddZddZnddZd dZd S) ThreadSensitiveContextaAsync 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. In Python 3.6, usage of this context manager has no effect. 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|_dS)N)token)selfrrr__init__FszThreadSensitiveContext.__init__c s6ytjjWn"tk r0tjj||_YnX|S)N) SyncToAsyncthread_sensitive_contextrrrr%)r&rrr __aenter__Ks z!ThreadSensitiveContext.__aenter__cs6|js dStjj|d}|r$|jtjj|jdS)N)r%r(context_to_thread_executorpopshutdownr)reset)r&excvaluetbexecutorrrr __aexit__Ss z ThreadSensitiveContext.__aexit__cs|S)Nr)r&rrrr*^scsdS)Nr)r&r/r0r1rrrr3asN)__name__ __module__ __qualname____doc__r' contextvarsr*r3rrrrr$0s r$c@sJeZdZUdZiZdeZdddZddZdd Z d d Z d d Z 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]FcCst| st| rtjd||_y|jj|_Wntk rFYnX|rTd|_nXy t|_WnJt k rt t j dd}|r|t jkrt t j dd|_nd|_YnXdS)Nz4async_to_sync was passed a non-async-marked callablemain_event_loop_pidmain_event_loop)callabler#warningswarn awaitable__self__AttributeErrorr;r RuntimeErrorgetattrr( threadlocalosgetpid)r&r?Zforce_new_loopr:rrrr'ys$   zAsyncToSync.__init__c OsJy t}Wntk rYnX|jr0tdtdk rDtjg}nd}t}tj}t|j drl|j j }nd}t }||j _ z|j ||||t j|} |jo|jjstj} tdd} | j|j| | } |r|j| | jn"|jj|jj| |r|j|Wdt|j dr|j ` |r*||j _ tdk r@t|dX|jS)NznYou cannot use AsyncToSync in the same thread as an async event loop - just await the async function directly.currentr ) max_workersr)r rB is_runningr8 copy_contextr threadingcurrent_threadhasattr executorsrGr main_wraprexc_infor;rnew_event_looprsubmit_run_event_loopZrun_until_futureresultcall_soon_threadsafe create_taskr) r&argskwargsZ event_loopr call_result source_threadZold_current_executorZcurrent_executorr?loopZ loop_executorZ loop_futurerrr__call__sN          zAsyncToSync.__call__cstj|z|j|Wdztjd kr2tj|n tjj|xD] }|jqDWfdd}|j|x8D]0}|jrqr|j dk rr|j d|j |dqrWt |d r|j|j Wd|j tj|jXXdS) zP Runs the given event loop (designed to be called in a thread). Nr rrcstjddiIdHdS)Nreturn_exceptionsT)rgatherr)tasksrrr^sz+AsyncToSync._run_event_loop..gatherz(unhandled exception during loop shutdown)message exceptiontaskshutdown_asyncgens)r rr)rset_event_looprun_until_completerr all_tasksTaskcancel cancelledracall_exception_handlerrMrccloser;)r&r[cororbr^r)r_rrSs.           zAsyncToSync._run_event_loopcCstj|j|}tj||jS)z* Include self for methods )r!r"r\update_wrapperr?)r&parentobjtyperrrr__get__szAsyncToSync.__get__c s|dk rt|dtj}||j|<zyT|drhy |dWqztk rd|j||IdH}YqzXn|j||IdH}Wn,tk r} z|j| WYdd} ~ Xn X|j|Wd|j|=|dk rtj |d<XdS)zs Wraps the awaitable with something that puts the result into the result/exception future. Nrr ) rr(get_current_task launch_map BaseExceptionr? set_exception set_resultr8rJ) r&rWrXrYrZrPr current_taskrTerrrrOs"   zAsyncToSync.main_wrapN)F) r4r5r6r7rrr rNr'r\rSrprOrrrrr9es  I'r9c@seZdZUdZdejkr8eZeje e ejddiZ d e j Ze ddZejdkrlejdZd nd Zd ejdkrejd Zd nd Zd ejZd dedefeedd dddZddZddZddZ e!ddZ"d 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 ASGI_THREADS)rHz,Dict[threading.Thread, asyncio.Task[object]]r r rr)zcontextvars.ContextVar[str]Ndeadlock_contextzcontextvars.ContextVar[bool]z5weakref.WeakKeyDictionary[object, ThreadPoolExecutor]T.r)rthread_sensitiver2rc Cs|t| st|rtd||_tj||||_tjj |_ |rP|dk rPtd||_ y |j |_ Wnt k rvYnXdS)Nz4sync_to_async can only be applied to sync functions.z6executor must not be set when thread_sensitive is True) r<r# TypeErrorrr!rm_thread_sensitiver coroutines _is_coroutine _executorr@rA)r&rryr2rrrr'ns    zSyncToAsync.__init__c sTt}|jrttjdr"tjj}q|jrj|jjdrj|jj}||jkrT|j|}qt dd}||j|<q|j r|j jdrt dq|j }|j r|j j dn|j}tdk rtj}tj|jf||}|j}|f}i}n|j}zD|j|tj|j||jtj|f||} tj| ddIdH} Wdtdk r:t||j rN|j j dX| S)NrGr )rHFz9Single thread executor already being used, would deadlockT)timeout)r r{rMr9rNrGr)rr+rrxrBsingle_thread_executorrr~r8rJr!r"rrunrun_in_executorthread_handlerrqrrPrwait_forr) r&rWrXr[r2r)rchildrfutureretrrrr\sT         zSyncToAsync.__call__cCstj|j|S)z* Include self for methods )r!r"r\)r&rnrorrrrpszSyncToAsync.__get__c Os||j_tj|j_tj}tjj ||kr2d}n||j|<d}z@|drty |dWq~t k rp|||SXn |||SWd|r|j|=XdS)zE Wraps the sync application with exception handling. FTr N) rDr;rErFr:rKrLr9rrrrs) r&r[Z source_taskrPrrWrXrLZ parent_setrrrrs    zSyncToAsync.thread_handlerc Cs:y ttdrtjStjjSWntk r4dSXdS)zs Cross-version implementation of asyncio.current_task() Returns None if there is no task. rvN)rMrrvrgrBrrrrrqs  zSyncToAsync.get_current_task)r r)r r)TN)#r4r5r6r7rEenvironr r[set_default_executorrintrrrKlocalrDrrrr8Z ContextVarr)rxweakrefWeakKeyDictionaryr+rrboolrr'r\rpr staticmethodrqrrrrr(0s.       D!r(Tr.)rryr2rcCsdS)Nr)rryr2rrr sync_to_asyncsrcCsdS)Nr)rryr2rrrr scs$|dkrfddSt|dS)Ncst|dS)N)ryr2)r()f)r2ryrrszsync_to_async..)ryr2)r()rryr2r)r2ryrrs )r r)NTN)TN)NTN)"Zasyncio.coroutinesrr!rrErrKr=rconcurrent.futuresrrtypingrrrrrZ compatibilityr Zcurrent_thread_executorr rr rr8rrr#r$r9r(Z async_to_syncrrrrrsF      5LQ "