RPf=ddlmZddlZddlZddlmZmZmZddlm Z m Z m Z m Z ddl mZmZddlmZddlmZddlmZmZmZmZmZmZmZmZd d lmZd d lm Z m!Z!m"Z"d d l#m$Z$d d l%m&Z&m'Z'd dl(m)Z)d dl*m+Z+ejXdk\r ddlm-Z-m.Z.nddl/m-Z-m.Z.edZ0eddZ1e-dZ2 d!dZ3 d"dZ4Gddee1eZ5Gdde+Z6GddZ7e d# d$dZ8d%d Z9y)&) annotationsN) AwaitableCallable Generator)FIRST_COMPLETEDFutureThreadPoolExecutorwait)AbstractContextManagercontextmanager) isawaitable) TracebackType)AnyAsyncContextManagerContextManagerGenericIterableTypeVarcastoverload) _eventloop)get_async_backendget_cancelled_exc_class threadlocals)Event) CancelScopecreate_task_group) AsyncBackend) TaskStatus) ) TypeVarTupleUnpackT_RetvalT_coT) covariantPosArgsTc tj}tj}|j |||S#t$r t ddwxYw)z Call a coroutine function from a worker thread. :param func: a coroutine function :param args: positional arguments for the callable :return: the return value of the coroutine function 9This function can only be run from an AnyIO worker threadNtoken)rcurrent_async_backend current_tokenAttributeError RuntimeErrorrun_async_from_threadfuncargs async_backendr,s K/var/www/fastapitest/venv/lib/python3.12/site-packages/anyio/from_thread.pyrunr7&s[$:: **  . .tT . GG  G   6A c tj}tj}|j |||S#t$r t ddwxYw)z Call a function in the event loop thread from a worker thread. :param func: a callable :param args: positional arguments for the callable :return: the return value of the callable r*Nr+)rr-r.r/r0run_sync_from_threadr2s r6run_syncr;<s[$:: **  - -dD - FF  G  r8cjeZdZUded<ded<ded<dZded <dd Zdd Zdd Z dd Zy)_BlockingAsyncContextManagerz Future[T_co] _enter_futurezFuture[bool | None] _exit_futurer _exit_event)NNNzMtuple[type[BaseException] | None, BaseException | None, TracebackType | None]_exit_exc_infoc ||_||_yN) _async_cm_portal)selfasync_cmportals r6__init__z%_BlockingAsyncContextManager.__init__Zs! cK t|_|jjd{}|jj | |jjd{|jj|jd{}|S7o#t $r!}|jj|d}~wwxYw7`77#|jj|jd{7}|ccYSxYwwrC) rr@rD __aenter__r> set_result BaseException set_exceptionr __aexit__rA)rFvalueexcresults r6 run_async_cmz)_BlockingAsyncContextManager.run_async_cm^s 1$wD ..3355E    ) )% 0  ""'') ) ) 44>>33T5H5HIIFM%6     , ,S 1   * J34>>33T5H5HIIIFMsD ,B"B B"D C.C/C3&D CD  B"" C +CC  D CD 'D:C=; DD ct|_|jj|j|_|jj SrC)rr>rEstart_task_soonrTr?rSrFs r6 __enter__z&_BlockingAsyncContextManager.__enter__us>#X LL889J9JK!!((**rJc|||f|_|jj|jj|j j SrC)rArEcallr@setr?rS)rF&_BlockingAsyncContextManager__exc_type'_BlockingAsyncContextManager__exc_value'_BlockingAsyncContextManager__tracebacks r6__exit__z%_BlockingAsyncContextManager.__exit__zsF )+{B $**../  ''))rJN)rGAsyncContextManager[T_co]rHBlockingPortal)return bool | None)rbr&)r\type[BaseException] | Noner]BaseException | Noner^TracebackType | Nonerbrc) __name__ __module__ __qualname____annotations__rArIrTrXr_rJr6r=r=Rsb%% .+ *.**** *  *rJr=ceZdZddZdddZy)_BlockingPortalTaskStatusc||_yrC)_future)rFfutures r6rIz"_BlockingPortalTaskStatus.__init__s  rJNc:|jj|yrC)rorM)rFrQs r6startedz!_BlockingPortalTaskStatus.starteds &rJ)rprrC)rQobjectrbNone)rgrhrirIrrrkrJr6rmrms 'rJrmczeZdZdZddZddZddZ ddZddZddZ dddZ dd Z dd Z e dd Ze dd Z dd Ze dd ddZe dd d dZdd d!dZdd d"dZ d#dZy)$razLAn object that lets external threads run code in an asynchronous event loop.c2tjSrC)rcreate_blocking_portal)clss r6__new__zBlockingPortal.__new__s "99;;rJctj|_t|_t |_t|_yrC) threading get_ident_event_loop_thread_idr _stop_eventr _task_groupr_cancelled_exc_classrWs r6rIzBlockingPortal.__init__s31:1D1D1F" 7,.$;$=!rJcVK|jjd{|S7wrC)rrLrWs r6rLzBlockingPortal.__aenter__s())+++  ,s )')cK|jd{|jj|||d{S7)7wrC)stoprrP)rFexc_typeexc_valexc_tbs r6rPzBlockingPortal.__aexit__s> iik%%//'6JJJ JsAA$AAAAc|j td|jtjk(r tdy)NzThis portal is not runningz7This method cannot be called from the event loop thread)r}r0r{r|rWs r6_check_runningzBlockingPortal._check_runningsF  % % -;< <  % %)<)<)> >I  ?rJcTK|jjd{y7w)z#Sleep until :meth:`stop` is called.N)r~r rWs r6sleep_until_stoppedz"BlockingPortal.sleep_until_stoppeds##%%%s (&(cKd|_|jj|r%|jjj yyw)a. Signal the portal to shut down. This marks the portal as no longer accepting new calls and exits from :meth:`sleep_until_stopped`. :param cancel_remaining: ``True`` to cancel all the remaining tasks, ``False`` to let them finish before returning N)r}r~r[r cancel_scopecancel)rFcancel_remainings r6rzBlockingPortal.stopsB&*"      ) ) 0 0 2 sA A c\ Kd fd } ||i|}t|rPt5 |jr jn|j ||d{}dddn|}|js|j  d y d y78#1swY4xYw#j $r%|j|jYd yt$r>}|js|j|t|tsYd}~d yd}~wwxYw#d wxYww)Nc|jr?jdtjfvrj j yyyrC) cancelledr}r{r|rZr)fscoperFs r6callbackz+BlockingPortal._call_func..callbacksG{{}!;!;##%D" %,,' "}rJ)rFuture[T_Retval]rbrt) r rrradd_done_callbackrMrset_running_or_notify_cancelrNrO isinstance Exception) rFr3r4kwargsrprretval_or_awaitableretvalrRrs ` @r6 _call_funczBlockingPortal._call_funcs) ( "&"7"7 ./ ]7e'') 00:#66F 77-##%!!&)E&E#7 77(( 2 MMO  / / 1E ##%$$S)c9-. E EsD,B)8B"B#B' B)2!D%D,D,BB&"B))/D"D%D,D"$2DD%D,D""D%%D))D,ct)a% Spawn a new task using the given callable. Implementors must ensure that the future is resolved when the task finishes. :param func: a callable :param args: positional arguments to be passed to the callable :param kwargs: keyword arguments to be passed to the callable :param name: name of the task (will be coerced to a string if not ``None``) :param future: a future that will resolve to the return value of the callable, or the exception raised during its execution )NotImplementedError)rFr3r4rnamerps r6_spawn_task_from_threadz&BlockingPortal._spawn_task_from_threads *"!rJcyrCrkrFr3r4s r6rZzBlockingPortal.calls rJcyrCrkrs r6rZzBlockingPortal.call s rJc`tt|j|g|jS)a3 Call the given function in the event loop thread. If the callable returns a coroutine object, it is awaited on. :param func: any callable :raises RuntimeError: if the portal is not running or if this method is called from within the event loop thread )rr%rVrSrs r6rZzBlockingPortal.calls-H2d224?$?FFHIIrJN)rcyrCrkrFr3rr4s r6rVzBlockingPortal.start_task_soon" rJcyrCrkrs r6rVzBlockingPortal.start_task_soon+rrJcd|jt}|j||i|||S)a Start a task in the portal's task group. The task will be run inside a cancel scope which can be cancelled by cancelling the returned future. :param func: the target function :param args: positional arguments passed to ``func`` :param name: name of the task (will be coerced to a string if not ``None``) :return: a future that resolves with the return value of the callable if the task completes successfully, or with the exception raised in the task :raises RuntimeError: if the portal is not running or if this method is called from within the event loop thread :rtype: concurrent.futures.Future[T_Retval] .. versionadded:: 3.0 )rrr)rFr3rr4rs r6rVzBlockingPortal.start_task_soon4s20 $h $$T4T1=rJcdfd }|jtt}t}|j||j ||d|i|||j fS)a Start a task in the portal's task group and wait until it signals for readiness. This method works the same way as :meth:`.abc.TaskGroup.start`. :param func: the target function :param args: positional arguments passed to ``func`` :param name: name of the task (will be coerced to a string if not ``None``) :return: a tuple of (future, task_status_value) where the ``task_status_value`` is the value passed to ``task_status.started()`` from within the target function :rtype: tuple[concurrent.futures.Future[T_Retval], Any] .. versionadded:: 3.0 cjsn|jrjy|jr j |jyt d}j |yy)Nz1Task exited without calling task_status.started())donerr exceptionrOr0)rprRtask_status_futures r6 task_donez,BlockingPortal.start_task..task_donehsl%**,##%&--/%%'&44V5E5E5GH&KC'44S9-rJ task_status)rprrbrt)rrrmrrrS)rFr3rr4rrrrs @r6 start_taskzBlockingPortal.start_taskQso. : %+X/0BC H I& $$T4-1MtUVW$++---rJct||S)a Wrap an async context manager as a synchronous context manager via this portal. Spawns a task that will call both ``__aenter__()`` and ``__aexit__()``, stopping in the middle until the synchronous context manager exits. :param cm: an asynchronous context manager :return: a synchronous context manager .. versionadded:: 2.1 )r=)rFcms r6wrap_async_context_managerz)BlockingPortal.wrap_async_context_manager|s,B55rJ)rbrarbrt)rrdrrerrfrbrc)F)rboolrbrt) r3V<> K,K&K% K  K&3 (J(&( ( ! (  (T"J"&" "  " ! " ". ?        : CS   JJJ J  J"   ?           4         J    B ).0).). ). & ).V6+6 6rJrac#Kdfd }ttd5}|jtj|||} t t tt|gtjr5j}d} | |j|j||jdddy#t$r"j|jwxYw#t$rd}wxYw#t$rYbwxYw# |j|j|w#t$rYwwxYwxYw#1swYyxYww) a| Start a new event loop in a new thread and run a blocking portal in its main task. The parameters are the same as for :func:`~anyio.run`. :param backend: name of the backend :param backend_options: backend options :return: a context manager that yields a blocking portal .. versionchanged:: 3.0 Usage as a context manager is now required. cKt4d{}jr)j||jd{dddd{y7N77 #1d{7swYyxYwwrC)rarrMr)portal_rps r6 run_portalz)start_blocking_portal..run_portalsp!# 4 4w224!!'*11333 4 4 44 4 4 4 4sVA<A!A<5A' A# A' A<A%A<#A'%A<'A9-A0 .A95A<r)backendbackend_options) return_whenFTNr)rr submitrr7r rrrrNrrrSrZrr0)rrrexecutor run_futurerHcancel_remaining_tasksrps @r6start_blocking_portalrsJ$4 &,XF A (__ NN + %   Xf% F';<+  ;;=]]_F%* "  KK -CD ?  MMO      ! )-&  $KK -CD#9sE$E(C ,"EC8D1E E +C55E8 DD DEDEED65E6 E ?EE EEE Ecx tj}|j y#t$r tddwxYw)aa Check if the cancel scope of the host task's running the current worker thread has been cancelled. If the host task's current cancel scope has indeed been cancelled, the backend-specific cancellation exception will be raised. :raises RuntimeError: if the current thread was not spawned by :func:`.to_thread.run_sync` r*N)rr-r/r0check_cancelled)r5s r6rrsD&2&H&H !!#  G  s#9rr)asyncioN)rstrrzdict[str, Any] | Nonerbz$Generator[BlockingPortal, Any, None]r): __future__rsysr{collections.abcrrrconcurrent.futuresrrr r contextlibr r inspectr typesrtypingrrrrrrrr_corer_core._eventlooprrr_core._synchronizationr _core._tasksrrabcr abc._tasksr version_infor#r$typing_extensionsr%r&r(r7r;r=rmrarrrkrJr6rs$" ::PP=   VV)8"w++6 : v&  #H ;HDTH H,G 0G9IG G,0*74=2H0*f' '~6~6BGK7 7/D7)77t$rJ