U f=@sddlmZddlZddlZddlmZmZmZddlm 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+ej,dkr ddlm-Z-m.Z.nddl/m-Z-m.Z.edZ0edddZ1e-dZ2ddddddZ3ddddddZ4Gdd d ee1eZ5Gd!d"d"e+Z6Gd#d$d$Z7ed0d&d'd(d)d*d+Z8d,d-d.d/Z9dS)1) 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) covariantPosArgsT1Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]]Unpack[PosArgsT]funcargsreturncGs@ztj}tj}Wntk r.tddYnX|j|||dS)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_threadr+r, async_backendr0r8T/var/www/html/apigroqsegura/apigroq/lib/python3.8/site-packages/anyio/from_thread.pyrun&s  r:&Callable[[Unpack[PosArgsT]], T_Retval]cGs@ztj}tj}Wntk r.tddYnX|j|||dS)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/)rr1r2r3r4run_sync_from_threadr6r8r8r9run_sync<s  r=c@sreZdZUded<ded<ded<dZded <d d d d dZddddZddddZdddddddZdS)_BlockingAsyncContextManagerz Future[T_co] _enter_futurezFuture[bool | None] _exit_futurer _exit_event)NNNzMtuple[type[BaseException] | None, BaseException | None, TracebackType | None]_exit_exc_infoAsyncContextManager[T_co]BlockingPortal)async_cmportalcCs||_||_dSN) _async_cm_portal)selfrErFr8r8r9__init__Zsz%_BlockingAsyncContextManager.__init__ bool | Noner-c szt|_|jIdH}Wn0tk rL}z|j|W5d}~XYnX|j|dz|j IdHW5|jj|j IdH}|SXrG) rrArH __aenter__ BaseExceptionr? set_exception set_result __aexit__rBr )rJvalueexcresultr8r8r9 run_async_cm^s  z)_BlockingAsyncContextManager.run_async_cmr%cCs"t|_|j|j|_|jSrG)rr?rIstart_task_soonrVr@rUrJr8r8r9 __enter__usz&_BlockingAsyncContextManager.__enter__type[BaseException] | NoneBaseException | NoneTracebackType | None)&_BlockingAsyncContextManager__exc_type'_BlockingAsyncContextManager__exc_value'_BlockingAsyncContextManager__tracebackr-cCs&|||f|_|j|jj|jSrG)rBrIcallrAsetr@rU)rJr]r^r_r8r8r9__exit__zs z%_BlockingAsyncContextManager.__exit__N) __name__ __module__ __qualname____annotations__rBrKrVrYrbr8r8r8r9r>Rs  r>c@s,eZdZddddZd dddd d ZdS) _BlockingPortalTaskStatusrfuturecCs ||_dSrG)_future)rJrir8r8r9rKsz"_BlockingPortalTaskStatus.__init__NobjectNone)rSr-cCs|j|dSrG)rjrQ)rJrSr8r8r9startedsz!_BlockingPortalTaskStatus.started)N)rcrdrerKrmr8r8r8r9rgsrgc@sheZdZdZddddZddddZdddd Zd d d d dddZddddZddddZ d>dddddZ dddddddd Z dddd!ddd"d#d$Z e d%d&d'd(d)d*Ze d+d&d'd(d,d*Zdd&d'd(d-d*Ze d.d/d%d&d!dd0d1d2Ze d.d/d+d&d!dd0d3d2Zd.d/dd&d!dd0d4d2Zd.d/d5d!d!d6d0d7d8Zd9d:d;d.callback) r rrradd_done_callbackrvset_running_or_notify_cancelrOrP isinstance ExceptionrQ) rJr+r,rrirZretval_or_awaitableZretvalrTr8rr9 _call_funcs*      zBlockingPortal._call_funcrk)r+r,rnamerir-cCstdS)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 N)NotImplementedError)rJr+r,rrrir8r8r9_spawn_task_from_threadsz&BlockingPortal._spawn_task_from_threadr(r)r$r*cGsdSrGr8rJr+r,r8r8r9r`szBlockingPortal.callr;cGsdSrGr8rr8r8r9r` scGstt|j|f|S)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$rWrUrr8r8r9r`sN)r)r+r,rr-cGsdSrGr8rJr+rr,r8r8r9rW"szBlockingPortal.start_task_sooncGsdSrGr8rr8r8r9rW+scGs$|t}|||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 )r{rr)rJr+rr,rr8r8r9rW4sz"Callable[..., Awaitable[T_Retval]]ztuple[Future[T_Retval], Any]cs\dddfdd }|tt}t}|||||d|i|||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 rrl)rir-csHsD|rn*|r2|ntd}|dS)Nz1Task exited without calling task_status.started())donerr exceptionrPr4)rirTZtask_status_futurer8r9 task_donehs z,BlockingPortal.start_task..task_done task_status)r{rrgrrrU)rJr+rr,rrrr8rr9 start_taskQs  zBlockingPortal.start_taskrCzContextManager[T_co])cmr-cCs t||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>)rJrr8r8r9wrap_async_context_manager|sz)BlockingPortal.wrap_async_context_manager)F)rcrdre__doc__rprKrNrRr{r|rzrrrr`rWrrr8r8r8r9rDs4 * !+rDasynciostrzdict[str, Any] | Nonez$Generator[BlockingPortal, Any, None])backendbackend_optionsr-c#sddfdd }ttd}|jtj|||d}ztttt|gtdWn&t k rz | YnX r }d}z*z |VWnt k rd }YnXW5z| |j|Wntk rYnXX| W5QRXd S) 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. rlrMc sDt4IdH&}r0||IdHW5QIdHRXdSrG)rDrrQr|)Zportal_rhr8r9 run_portals z)start_blocking_portal..run_portalr)rr) return_whenFTN)rrsubmitrr:r rrrrOrrrUr`rzr4)rrrexecutorZ run_futurerFZcancel_remaining_tasksr8rhr9start_blocking_portals>    rrlrMcCs6z tj}Wntk r(tddYnX|dS)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)rr1r3r4check_cancelled)r7r8r8r9rs  r)rN): __future__rsysrqcollections.abcrrrconcurrent.futuresrrrr contextlibr r inspectr typesr typingrrrrrrrr_corer_core._eventlooprrr_core._synchronizationr _core._tasksrrabcrZ abc._tasksr version_infor"r#typing_extensionsr$r%r'r:r=r>rgrDrrr8r8r8r9s@   (      3: