o pf=@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,dkrddlm-Z-m.Z.nddl/m-Z-m.Z.edZ0edddZ1e-dZ2d2ddZ3d3dd Z4Gd!d"d"ee1eZ5Gd#d$d$e+Z6Gd%d&d&Z7e d4d5d-d.Z8d6d0d1Z9dS)7) 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) covariantPosArgsTfunc1Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]]argsUnpack[PosArgsT]returncG:ztj}tj}Wn tytddw|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_backendr0r8J/home/ertert/spirit/venv/lib/python3.10/site-packages/anyio/from_thread.pyrun&   r:&Callable[[Unpack[PosArgsT]], T_Retval]cGr-)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<r;r>c@sZeZdZUded<ded<ded<dZded <d ddZd!ddZd"ddZd#ddZdS)$_BlockingAsyncContextManagerz Future[T_co] _enter_futurezFuture[bool | None] _exit_futurer _exit_event)NNNzMtuple[type[BaseException] | None, BaseException | None, TracebackType | None]_exit_exc_infoasync_cmAsyncContextManager[T_co]portalBlockingPortalcCs||_||_dSN) _async_cm_portal)selfrDrFr8r8r9__init__Zs z%_BlockingAsyncContextManager.__init__r, bool | Nonec szt|_|jIdH}Wnty"}z|j|d}~ww|j|z|jIdHW|jj |j IdH}|S|jj |j IdH}|YSrH) rrBrI __aenter__ BaseExceptionr@ set_exception set_resultr __aexit__rC)rKvalueexcresultr8r8r9 run_async_cm^s   z)_BlockingAsyncContextManager.run_async_cmr%cCs"t|_|j|j|_|jSrH)rr@rJstart_task_soonrVrArUrKr8r8r9 __enter__us z&_BlockingAsyncContextManager.__enter__&_BlockingAsyncContextManager__exc_typetype[BaseException] | None'_BlockingAsyncContextManager__exc_valueBaseException | None'_BlockingAsyncContextManager__tracebackTracebackType | NonecCs&|||f|_|j|jj|jSrH)rCrJcallrBsetrArU)rKrZr\r^r8r8r9__exit__zs  z%_BlockingAsyncContextManager.__exit__N)rDrErFrG)r,rM)r,r%)rZr[r\r]r^r_r,rM) __name__ __module__ __qualname____annotations__rCrLrVrYrbr8r8r8r9r?Rs    r?c@s"eZdZd ddZd dd d ZdS)_BlockingPortalTaskStatusfuturercCs ||_dSrH)_future)rKrhr8r8r9rL z"_BlockingPortalTaskStatus.__init__NrSobjectr,NonecCs|j|dSrH)rirQ)rKrSr8r8r9startedsz!_BlockingPortalTaskStatus.started)rhrrH)rSrkr,rl)rcrdrerLrmr8r8r8r9rgs rgc@seZdZdZdAddZdBddZdAdd ZdCddZdBddZdBddZ dDdEddZ dFd$d%Z dGd(d)Z e dHd-d.Ze dId0d.ZdJd1d.Ze d2d3dKd4d5Ze d2d3dLd6d5Zd2d3dMd7d5Zd2d3dNd:d;ZdOd?d@Zd2S)PrGzLAn object that lets external threads run code in an asynchronous event loop.r,cCs tSrH)rcreate_blocking_portal)clsr8r8r9__new__rjzBlockingPortal.__new__rlcCs&t|_t|_t|_t|_dSrH) threading get_ident_event_loop_thread_idr _stop_eventr _task_groupr_cancelled_exc_classrXr8r8r9rLs  zBlockingPortal.__init__cs|jIdH|SrH)rurNrXr8r8r9rNszBlockingPortal.__aenter__exc_typer[exc_valr]exc_tbr_rMcs&|IdH|j|||IdHSrH)stoprurR)rKrwrxryr8r8r9rRszBlockingPortal.__aexit__cCs,|jdur td|jtkrtddS)NzThis portal is not runningz7This method cannot be called from the event loop thread)rsr4rqrrrXr8r8r9_check_runnings zBlockingPortal._check_runningcs|jIdHdS)z#Sleep until :meth:`stop` is called.N)rtr rXr8r8r9sleep_until_stoppedsz"BlockingPortal.sleep_until_stoppedFcancel_remainingboolcs*d|_|j|r|jjdSdS)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)rsrtraru cancel_scopecancel)rKr}r8r8r9rzs  zBlockingPortal.stopr(.callback)rrr,rl) r rrradd_done_callbackrvset_running_or_notify_cancelrOrP isinstance ExceptionrQ) rKr(r*rrhrretval_or_awaitableretvalrTr8rr9 _call_funcsD         zBlockingPortal._call_funcnamerkcCst)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)rKr(r*rrrhr8r8r9_spawn_task_from_threadsz&BlockingPortal._spawn_task_from_threadr)r+r$cGdSrHr8rKr(r*r8r8r9r`szBlockingPortal.callr<cGrrHr8rr8r8r9r` scGstt|j|g|RS)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)rcGrrHr8rKr(rr*r8r8r9rW"zBlockingPortal.start_task_sooncGrrHr8rr8r8r9rW+rcGs$|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)rKr(rr*rr8r8r9rW4s"Callable[..., Awaitable[T_Retval]]tuple[Future[T_Retval], Any]csVd fdd }|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 rhrr,rlcsPs&|rdS|r|dStd}|dSdS)Nz1Task exited without calling task_status.started())donerr exceptionrPr4)rhrTtask_status_futurer8r9 task_donehs z,BlockingPortal.start_task..task_done task_statusN)rhrr,rl)r{rrgrrrU)rKr(rr*rrrr8rr9 start_taskQs   zBlockingPortal.start_taskcmrEContextManager[T_co]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?)rKrr8r8r9wrap_async_context_manager|s z)BlockingPortal.wrap_async_context_manager)r,rGr,rl)rwr[rxr]ryr_r,rM)F)r}r~r,rl) r(rr*rrrrhrr,rl) r(rr*rrrrrkrhrr,rlr(r)r*r+r,r$r(r<r*r+r,r$)r(rr*r+r,r$)r(r)r*r+rrkr,r)r(r<r*r+rrkr,r)r(rr*r+rrkr,r)r(rr*rkrrkr,r)rrEr,r)rcrdre__doc__rprLrNrRr{r|rzrrrr`rWrrr8r8r8r9rGs6        *    !+rGasynciobackendstrbackend_optionsdict[str, Any] | None$Generator[BlockingPortal, Any, None]c#s$d fdd }ttdy}|jtj|||d}ztttt|gtdWnt y9 | w r| }d}z$z|VWn t yTd }wWz | |j|WntyhYnwz | |j|Wwty{Yww| Wd d S1swYd 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. r,rlc sxt4IdH'}r$||IdHWdIdHdSWdIdHdS1IdHs5wYdSrH)rGrrQr|)portal_rhr8r9 run_portals .z)start_blocking_portal..run_portalr)rr) return_whenFTNr)rrsubmitrr:r rrrrOrrrUr`rzr4)rrrexecutor run_futurerFcancel_remaining_tasksr8rr9start_blocking_portalsT       "rrlcCs0ztj}Wn tytddw|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   rrr)rN)rrrrr,rr): __future__rsysrqcollections.abcrrrconcurrent.futuresrrrr contextlibr r inspectr typesr typingrrrrrrrr_corer_core._eventlooprrr_core._synchronizationr _core._tasksrrabcr abc._tasksr version_infor"r#typing_extensionsr$r%r'r:r>r?rgrGrrr8r8r8r9s@   (        3: