#ijYJUddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z ddl mZmZmZmZmZmZmZmZmZmZmZmZddlmZddlmZej<dk\rddl mZnddl mZerdd l!m"Z"ed ed ef Z#ed Z$edZ%dejLddfdZ'e(edr$ejRZ)ejTZ*ee#ge#fe+d<nejRZ)de#de#fdZ*GddZ,GddZ-Gddee$e%fZ.Gddee$e%fZ/eddde0deeee$eeee%ffee$ee%ffgee$e%fffd Z1eddd!eee$eeee%ffee$ee%ffde0dee$e%ffd"Z1 d,ddd!eeee$eeee%ffee$ee%ffde0deeeee$eeee%ffee$ee%ffgee$e%ffee$e%fffd#Z1ed$ddd%d&e0d'ed(deejLdeee$e%fgee$eeee%ffffd)Z2ed$ddd%dee$e%fd&e0d'ed(deejLdee$eeee%fff d*Z2 d,d$ddd%deee$e%fd&e0d'ed(deejLdeeee$e%fgee$eeee%fffee$eeee%ffff d+Z2y)-N)FutureThreadPoolExecutor) TYPE_CHECKINGAny AwaitableCallable CoroutineDictGenericListOptionalTypeVarUnionoverload)CurrentThreadExecutor)Local) ) ParamSpec) OptExcInfo_F.)bound_P_Rcontextreturnc|D]8}|j|} |j|k7r|j|:y#t$r|j|YXwxYwN)getset LookupError)rcvarcvalues F/var/www/html/office/venv/lib/python3.12/site-packages/asgiref/sync.py_restore_contextr&,s^T" xxzV#    HHV  s$?AAmarkcoroutinefunctionfunccDtjj|_|Sr)asyncio coroutines _is_coroutine)r(s r%r'r'Cs$//== c"eZdZdZdZdZdZy)AsyncSingleThreadContextaContext manager to run async code inside the same thread. Normally, AsyncToSync functions run either inside a separate ThreadPoolExecutor or the main event loop if it exists. This context manager ensures that all AsyncToSync functions execute within the same thread. This context manager is re-entrant, so only the outer-most call to AsyncSingleThreadContext will set the context. Usage: >>> import asyncio >>> with AsyncSingleThreadContext(): ... async_to_sync(asyncio.sleep(1))() cd|_yrtokenselfs r%__init__z!AsyncSingleThreadContext.__init__Y  r-c tjj|S#t$r(tjj ||_Y|SwxYwr) AsyncToSyncasync_single_thread_contextr r"r!r2r3s r% __enter__z"AsyncSingleThreadContext.__enter__\sQ K  3 3 7 7 9  K$@@DDTJDJ  Ks"-AAc|jsytjj|d}|r|j tj j |jyr)r2r8context_to_thread_executorpopshutdownr9resetr4excvaluetbexecutors r%__exit__z!AsyncSingleThreadContext.__exit__dsKzz 99==dDI     //55djjAr-N)__name__ __module__ __qualname____doc__r5r:rEr-r%r/r/Hs Br-r/c"eZdZdZdZdZdZy)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)() cd|_yrr1r3s r%r5zThreadSensitiveContext.__init__r6r-cK tjj|S#t$r(tjj ||_Y|SwxYwwr) SyncToAsyncthread_sensitive_contextr r"r!r2r3s r% __aenter__z!ThreadSensitiveContext.__aenter__sT H  0 0 4 4 6  H$==AA$GDJ  Hs%A$A-AAAAcK|jsytjj|d}|r|j tj j |jywr)r2rOr<r=r>rPr?r@s r% __aexit__z ThreadSensitiveContext.__aexit__sOzz 99==dDI     ,,224::>sA*A,N)rFrGrHrIr5rQrSrJr-r%rLrLos&?r-rLceZdZUdZeZded<iZded<ejdZ ded<e jZ ded < dd eeeeeeeffeeeeffd efd Zd ej.dej0defdZdededeeeffdZdddddddeej8d eeeeefeefddf dZy)r8a 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_executorsr9z0contextvars.ContextVar[AsyncSingleThreadContext]zGweakref.WeakKeyDictionary[AsyncSingleThreadContext, ThreadPoolExecutor]r< awaitableforce_new_loopc\t|r!t|s-tt|d|stjdd||_ |j j |_||_d|_ tj|_ y#t$rY4wxYw#t$rYywxYw)N__call__z4async_to_sync was passed a non-async-marked callable) stacklevel) callableiscoroutinefunctiongetattrwarningswarnrW__self__AttributeErrorrXmain_event_loopr*get_running_loop RuntimeError)r4rWrXs r%r5zAsyncToSync.__init__s "#I.' :y(QR MMFST #  NN33DM-# #*#;#;#=D        s$ B6B BB B+*B+argskwargsrc d}js`jsTttjdd}|r7|t j k(r ttjdd_ tjtd#t$rYnwxYwt}tjdd}t|j_ tjg}ttjdd} j!|t#j$||j&|i|d fd } jV jj)jj*d} j-|n#t$rd} YnwxYwd} | sd} j.j1drTj.j1} | j2vrj2| } n(t5d } | j2| <n t5d } | j7tj8| } j-| | j;t=|d |j_ |j;S#t=|d |j_ wxYw) NTmain_event_loop_pidrdznYou cannot use AsyncToSync in the same thread as an async event loop - just await the async function directly.current task_contextcKtj}j|< d{j|=y7#j|=wxYwwr)r*rerV)looprWcurrent_executorr4s r% new_loop_wrapz+AsyncToSync.__call__..new_loop_wrapsS//13C**409#OO2248$2248s+$AAAAAAAAFr max_workersr)rN)rXrdr_rO threadlocalosgetpidr*rerfrrUrrk contextvars copy_context main_wrapsysexc_inforWcall_soon_threadsafe create_taskrun_until_futurer9r r<rsubmitrunresultr&)r4rgrh__traceback_hide__rj call_result old_executorrrlrprunning_in_main_event_loop loop_executorsingle_thread_context loop_futurerWros` @@r%rZzAsyncToSync.__call__s!""4+?+?#*'')>#  #':biik'I'.++->($    $ $ &:    %+H t~~y$? 0>!1++-.{66M ? 2  // I 9##/ C((==,,88) 26.$55kB $716.7.3*- $ 3377=,0,L,L,P,P,R),0O0OO(,(G(G1) );q(I *771 %71$EM+227;; P  11+>""$ WQZ (%1DNN "!!## WQZ (%1DNN "sD3B BBA J&0F J& F-*J&,F--C J&&!Kparentobjtypectj|j|}tj||jSz* Include self for methods ) functoolspartialrZupdate_wrapperrWr4rrr(s r%__get__zAsyncToSync.__get__Gs1  7''dnn==r-rz Future[_R]rzrrlz!Optional[List[asyncio.Task[Any]]]rNcKd}|t|dtj}|||j| |dr |d|d{}|j ||||j|tj|d<y#t$r|d{7}YTwxYw7\#t$r} |j | Yd} ~ hd} ~ wwxYw#|||j|tj|d<wxYww)zs Wraps the awaitable with something that puts the result into the result/exception future. TNrr) r&r* current_taskappend BaseException set_result set_exceptionremovervrw) r4rrzrlrrWrrres r%rxzAsyncToSync.main_wrapNs"   WQZ (++-  # (@    - 4{-"1+% )  " "6 *'L,D##L1$113GAJ%-#,__F-) )  % %a ( ( ) 'L,D##L1$113GAJs|c>C>HRV4D>'4!'4'4: '4 k))* '4 3R<0)B-?@ '4 '4r-r8c eZdZUdZej ZedZe jdZ de d<e jdZ de d<ejZde d < dd eeefd ed eddee j,dd f dZdej0dej2defdZdededeeeeeefffdZdZy )rOa 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. rrqrPz.contextvars.ContextVar[ThreadSensitiveContext]deadlock_contextzcontextvars.ContextVar[bool]zEweakref.WeakKeyDictionary[ThreadSensitiveContext, ThreadPoolExecutor]r<Nr(thread_sensitiverDrrrcLt|r!t|stt|d|r tdt j ||||_||_||_t||r | td||_ |j|_ y#t$rYywxYw)NrZz4sync_to_async can only be applied to sync functions.z6executor must not be set when thread_sensitive is True) r]r^r_ TypeErrorrrr(r_thread_sensitiver' _executorrbrc)r4r(rrDrs r%r5zSyncToAsync.__init__s"4("74T#BCRS S  t,  !1d#  4TU U!  MMDM   sB B#"B#rgrhc Kd}tj}|jrttj dd}|r|}n|j jdrT|j j}||jvr|j|}ntd}||j|<n|tjvrtj|}nZ|jjdr td|j}|jjdn |j}|j t#j$n |j }t'j(|j*g|i|} |j,} g} |j/|t'j(|j0|t3j4| | | } tj6| d{} |j tA||jjd| S78#tj8$rd} | d}|j; |d{7d}n#tj8$rYnwxYwn#t<$rYnwxYw| j?r|r| j;| d{7} YwxYw#|j tA||jjdwxYww)NTrkrrqFz9Single thread executor already being used, would deadlockr)!r*rerr_r8rUrPr r<rrVrrfsingle_thread_executorr!rrrvrwrrr(rrun_in_executorthread_handlerryrzshieldCancelledErrorcancel IndexErrordoner&)r4rgrhrrncurrent_thread_executorrDrPrchildr(rl exec_cororet cancel_parenttasks r%rZzSyncToAsync.__call__s!'')  ! !&-k.C.CYPT&U #&2..2248,0+H+H+L+L+N(+t/N/NN#>>?WXH 2a@HPXD334LM:::&<  9:N 8N{7M7M84 "!!# g"&3715 r2v/0  +--.   8OBGGOryyOROb99$'9 "iS" -- .9)r-rOFrXrXcyrrJrs r% async_to_syncr4r-rWcyrrJrWrXs r%rr?sr-c,|fdSt|S)Nct|S)Nrr8)frXs r%zasync_to_sync..\s ) r-rrrs `r%rrKs*    % r-TrrDrrrDrcyrrJrs r% sync_to_asyncrfsr-cyrrJr(rrDrs r%rrprr-c8|fdSt|S)Nc"t|S)NrrO)rrrDrs r%rzsync_to_async..s -  r-rrrs ```r%rr{s/ |   )  r-r)3r*asyncio.coroutinesrvrinspectrtryrr`rconcurrent.futuresrrtypingrrrrr r r r r rrrrrrr version_infortyping_extensions _typeshedrrrrrr&hasattrr^r'rr/rLr8rOrrrrJr-r%rs 9    ;w +$ T#s(+,t_ T] k11 d " 7+,!55070M0M8RD"H-M!55B2 $B$BN&?&?R]4'"b&/]4@y)'"b&/y)x ! 8B #sB,// 0(2y};L2M MNO RV  ! YsC|,,-Yr]"# %  b"f " ! R3R<00 1 R2& ' )   xIc3l334hr9R=?P6QQ RSR  RV 6 "/3-1 +,k)) *  xB (2yc2/F+F"GGH   "/3-1  2r6 +,  k)) *  b)CbL))*  (,"/3-1  8BF# $+,  k)) *    hr2v "iS" .E*E!F FG R3R<( ()+ r-