яПН !A?hяПНяПНяПНяПНяПНdZdZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddlmZddlm Z ddlmZddlmZdd lmZdd lmZddlmZejdяПНяПНjZd-dяПНZd-d яПНZdяПНZGdяПНdejяПНяПНZeZ ddlZejxZZn#e$rYnwxYwdddяПНdяПНZejj Z ejj!Z!ejj"Z"de"dяПНdяПНZ#dяПНZ$dяПНZ%dяПНZ&dяПНZ'ddяПНdяПНZ(ej)dяПНяПНяПНZ*d-dяПНZ+ddяПНdяПНZ,ddяПНdяПНZ-ej)d яПНяПНяПНZ.ee._Gd!яПНd"ej/яПНяПНZ0d#d$яПНd%яПНZ1d&яПНZ2d'яПНZ3e j4яПНяПНZ5iZ6d(яПНZ7d)яПНZ8d*яПНZ9d+яПНZ:e7Z;e:Z dd,lm7Z7m:Z:m8Z8m9Z9m5Z5m6Z6e7Z?e:Z@e8ZAe9ZBdS#e$rYdSwxYw).z0Support for tasks, coroutines and the scheduler.)яПНTaskяПНcreate_taskяПНFIRST_COMPLETEDяПНFIRST_EXCEPTIONяПН ALL_COMPLETEDяПНwaitяПНwait_forяПНas_completedяПНsleepяПНgatherяПНshieldяПН ensure_futureяПНrun_coroutine_threadsafeяПНcurrent_taskяПН all_tasksяПН_register_taskяПН_unregister_taskяПН_enter_taskяПН_leave_taskяПНN)яПНGenericAliasяПН)яПН base_tasks)яПН coroutines)яПНevents)яПН exceptions)яПНfutures)яПН _is_coroutinecяПНTяПН|яПНtjяПНяПН}tj|яПНяПНS)z!Return a currently executed task.)rяПНget_running_loopяПН_current_tasksяПНgetяПНяПНloops яПН:/opt/alt/python-internal/lib64/python3.11/asyncio/tasks.pyrr#s&яПНяПНяПН|яПНяПН&яПН(яПН(яПНяПНяПНяПНdяПН#яПН#яПН#яПНcяПНяПНяПНяПНяПНtjяПНяПНяПНd} ttяПНяПН}n#t$r|dz }|dkrяПНYnwxYwяПН3яПНfdяПН|DяПНяПНS)z'Return a set of all tasks for the loop.NrTriяПНcяПНhяПНяПНh|].}tj|яПНяПНяПНuяПН|яПНяПНяПНяПН,|яПНяПН/SяПН)rяПН _get_loopяПНdone)яПН.0яПНtr#s яПНr$яПН zall_tasks..=sEяПНяПНяПН>яПН>яПН>яПН!яПНяПН яПНяПН#яПН#яПНtяПН+яПН+яПНAяПНFяПНFяПНHяПНHяПН+яПН яПН+яПН+яПН+r%)rrяПНlistяПН _all_tasksяПНRuntimeError)r#яПНiяПНtaskss` r$rr*sяПНяПНяПНяПНяПН|яПНяПН&яПН(яПН(яПНяПН яПНAяПНяПН яПНяПНяПН$яПН$яПНEяПН яПНяПНяПН яПН яПН яПН яПНяПНFяПНAяПНяПНDяПНyяПНyяПНяПНяПНyяПН яПНяПНяПНяПНяПН>яПН>яПН>яПН>яПНuяПН>яПН>яПН>яПН>sяПН0яПНA яПНA cяПНяПН|яПНB |j}||яПНяПНdS#t$r tjdtdяПНяПНяПНYdSwxYwdS)Nz~Task.set_name() was added in Python 3.8, the method support will be mandatory for third-party task implementations since 3.13.яПНяПНяПН stacklevel)яПНset_nameяПНAttributeErrorяПНwarningsяПНwarnяПНDeprecationWarning)яПНtaskяПНnamer7s r$яПН_set_task_namer>AsяПНяПНяПНяПНяПН яПНяПН}яПНHяПН яПНHяПНTяПНNяПНNяПНNяПНNяПНNяПНяПН яПН 8яПН 8яПН 8яПНяПНMяПН9яПН)яПНQяПН 8яПН 8яПН 8яПН 8яПН 8яПН 8яПН 8яПН 8яПНяПНяПНяПНяПНsяПНяПН&AяПНAcяПНяПНяПНeZdZdZdZddddяПНяПНfdяПН ZяПНfdяПНZeeяПНяПНZ dяПНZ dяПНZd яПНZd яПНZ dяПНZdяПНZdd яПНdяПНZdddяПНdяПНZddяПНZdяПНZdяПНZdяПНfdяПН ZdяПНZяПНxZS)rz A coroutine wrapped in a Future.TN)r#r=яПНcontextcяПНяПНяПНtяПНяПНяПН|яПНяПНяПН|jr|jd=tj|яПНяПНsd|_t d|яПНяПНяПНяПНяПН|яПНdtяПНяПНяПНяПН|_nt|яПНяПН|_d|_ d|_d|_||_ |яПНtjяПНяПН|_n||_|jяПН|j|jяПНяПНяПНt)|яПНяПНdS)Nr"яПНяПНяПНяПНяПНFza coroutine was expected, got zTask-rяПНr@)яПНsuperяПН__init__яПН_source_tracebackrяПНiscoroutineяПН_log_destroy_pendingяПН TypeErrorяПН_task_name_counterяПН_nameяПНstrяПН_num_cancels_requestedяПН_must_cancelяПН_fut_waiterяПН_coroяПНcontextvarsяПНcopy_contextяПН_contextяПН_loopяПН call_soonяПН_Task__stepr)яПНselfяПНcoror#r=r@яПН __class__s яПНr$rEz Task.__init__jsяПНяПНяПН яПНяПНяПНяПНяПНdяПНяПН#яПН#яПН#яПНяПН!яПН +яПНяПН&яПНrяПН*яПНяПН%яПНdяПН+яПН+яПН GяПН).яПНDяПН%яПНяПНEяПНTяПНEяПНEяПНFяПНFяПНFяПНяПН<яПН7яПН!3яПН!5яПН!5яПН7яПН7яПНDяПНJяПНJяПНяПНTяПНяПНяПНDяПНJяПН&'яПНяПН#яПН!яПНяПНяПНяПНяПНяПНяПНяПН яПНяПН?яПН'яПН4яПН6яПН6яПНDяПНMяПНMяПН#яПНDяПНMяПНяПН яПНяПНяПНTяПН[яПН$яПН-яПНяПН@яПН@яПН@яПНяПНtяПНяПНяПНяПНяПНr%cяПНяПНяПНяПН|jtjkr7|jr0|ddяПН}|jr |j|d<|jяПН|яПНяПНtяПНяПНяПНяПНяПНdS)Nz%Task was destroyed but it is pending!)r<яПНmessageяПНsource_traceback) яПН_staterяПН_PENDINGrHrFrTяПНcall_exception_handlerrDяПН__del__)rWr@rYs яПНr$r`zTask.__del__яПНsyяПНяПНяПНяПН;яПН'яПН*яПН*яПН*яПНtяПН/HяПН*яПНяПНBяПНяПНяПНGяПНяПН%яПН EяПН.2яПН.DяПНяПН*яПН+яПНяПНJяПН-яПН-яПНgяПН6яПН6яПН6яПН яПНяПНяПНяПНяПНяПНяПНяПНяПНr%cяПН*яПНtj|яПНяПНSяПНN)rяПН _task_reprяПНrWs r$яПН__repr__z Task.__repr__яПНsяПНяПНяПН$яПНTяПН*яПН*яПН*r%cяПНяПН|jSrb)rPrds r$яПНget_coroz Task.get_coroяПНяПН яПНяПНяПНzяПНr%cяПНяПН|jSrb)rKrds r$яПНget_namez Task.get_nameяПНrhr%cяПН.яПНt|яПНяПН|_dSrb)rLrK)rWяПНvalues r$r7z Task.set_nameяПНsяПНяПНяПНяПНZяПНZяПНяПН яПН яПН r%cяПН яПНtdяПНяПНяПН)Nz*Task does not support set_result operationяПНr0)rWяПНresults r$яПН set_resultzTask.set_resultяПНsяПНяПНяПНGяПНHяПНHяПНHr%cяПН яПНtdяПНяПНяПН)Nz-Task does not support set_exception operationrn)rWяПН exceptions r$яПН set_exceptionzTask.set_exceptionяПНsяПНяПНяПНJяПНKяПНKяПНKr%)яПНlimitcяПН,яПНtj||яПНяПНS)aяПНReturn the list of stack frames for this task's coroutine. If the coroutine is not done, this returns the stack where it is suspended. If the coroutine has completed successfully or was cancelled, this returns an empty list. If the coroutine was terminated by an exception, this returns the list of traceback frames. The frames are always ordered from oldest to newest. The optional limit gives the maximum number of frames to return; by default all available frames are returned. Its meaning differs depending on whether a stack or a traceback is returned: the newest frames of a stack are returned, but the oldest frames of a traceback are returned. (This matches the behavior of the traceback module.) For reasons beyond our control, only one stack frame is returned for a suspended coroutine. )rяПН_task_get_stack)rWrts r$яПН get_stackzTask.get_stackяПНsяПНяПН*яПН)яПН$яПНяПН6яПН6яПН6r%)rtяПНfilecяПН.яПНtj|||яПНяПНS)anPrint the stack or traceback for this task's coroutine. This produces output similar to that of the traceback module, for the frames retrieved by get_stack(). The limit argument is passed to get_stack(). The file argument is an I/O stream to which the output is written; by default output is written to sys.stderr. )rяПН_task_print_stack)rWrtrxs r$яПНprint_stackzTask.print_stackяПНsяПНяПНяПН+яПНDяПН%яПНяПН>яПН>яПН>r%cяПНяПНяПНd|_|яПНяПНяПНrdS|xjdz c_|jяПН|jяПН|яПНяПНяПНrdSd|_||_dS)aяПНRequest that this task cancel itself. This arranges for a CancelledError to be thrown into the wrapped coroutine on the next cycle through the event loop. The coroutine then has a chance to clean up or even deny the request using try/except/finally. Unlike Future.cancel, this does not guarantee that the task will be cancelled: the exception might be caught and acted upon, delaying cancellation of the task or preventing cancellation completely. The task may also return a value or raise a different exception. Immediately after this method is called, Task.cancelled() will not return True (unless the task was already cancelled). A task will be marked as cancelled when the wrapped coroutine terminates with a CancelledError exception (even if cancel() was not called). This also increases the task's count of cancellation requests. FrNяПНяПНmsgT)яПН_log_tracebackr*rMrOяПНcancelrNяПН_cancel_message)rWr~s r$rяПНzTask.cancelяПНsxяПНяПН,$яПНяПНяПНяПН9яПН9яПН;яПН;яПН яПНяПН5яПНяПН#яПН#яПНqяПН(яПН#яПН#яПНяПНяПН'яПНяПНяПН&яПН&яПН3яПН&яПН/яПН/яПН яПНяПНtяПН яПНяПНяПН"яПНяПНяПНяПНtr%cяПНяПН|jS)zяПНReturn the count of the task's cancellation requests. This count is incremented when .cancel() is called and may be decremented using .uncancel(). яПНrMrds r$яПН cancellingzTask.cancellingяПНs яПНяПНяПН*яПН*r%cяПНFяПН|jdkr|xjdzc_|jS)zяПНDecrement the task's count of cancellation requests. This should be called by the party that called `cancel()` on the task beforehand. Returns the remaining number of cancellation requests. rrrяПНrds r$яПНuncancelz Task.uncancelяПНs/яПНяПНяПН&яПНяПН*яПН*яПНяПН'яПН'яПН1яПН,яПН'яПН'яПНяПН*яПН*r%cяПНяПНяПН|яПНяПНяПНrtjd|яПНd|яПНяПНяПНяПНяПН|jr5t |tjяПНяПНs|яПНяПНяПН}d|_|j}d|_t|j |яПНяПН |яПН|яПНdяПНяПН}n|яПН|яПНяПН}t|ddяПНяПН}|яПНяПН8tj|яПНяПН|j ur?t!d|яПНd|яПНdяПНяПНяПН}|j яПН|j||jяПНяПНяПНяПНnяПН|rяПН||ur;t!d |яПНяПНяПНяПН}|j яПН|j||jяПНяПНяПНяПНnnd|_|яПН|j|jяПНяПНяПН||_|jr'|jяПН|jяПН яПНяПНrd|_яПНnt!d|яПНd|яПНяПНяПНяПН}|j яПН|j||jяПНяПНяПНяПНnяПН|яПН(|j яПН|j|jяПНяПНяПНяПНnяПНt3j|яПНяПНr>t!d |яПНd|яПНяПНяПНяПН}|j яПН|j||jяПНяПНяПНяПНnUt!d|яПНяПНяПНяПН}|j яПН|j||jяПНяПНяПНяПНn#t6$rf}|jr/d|_t9яПНяПНяПН|jяПН яПНяПНn&t9яПНяПНяПН|jяПНяПНYd}~nяПНd}~wtj$r1}||_t9яПНяПНяПНяПНяПНYd}~nqd}~wt@tBf$r'}t9яПНяПНяПН"|яПНяПНяПНd}~wtF$r+}t9яПНяПНяПН"|яПНяПНYd}~nd}~wwxYwtI|j |яПНяПНd}dS#tI|j |яПНяПНd}wxYw)Nz_step(): already done: z, FяПН_asyncio_future_blockingzTask z got Future z attached to a different looprCzTask cannot await on itself: r}z-yield was used instead of yield from in task z with z;yield was used instead of yield from for generator in task zTask got bad yield: )%r*rяПНInvalidStateErrorrNяПН isinstanceяПНCancelledErrorяПН_make_cancelled_errorrPrOrrTяПНsendяПНthrowяПНgetattrrr)r0rUrVrSrяПНяПНadd_done_callbackяПН _Task__wakeuprяПНrяПНяПНinspectяПНisgeneratorяПН StopIterationrDrprlяПН_cancelled_excяПНKeyboardInterruptяПН SystemExitrsяПН BaseExceptionr)rWяПНexcrXroяПНblockingяПНnew_excrYs яПНr$яПН__stepzTask.__stepsяПНяПНяПНяПНяПН9яПН9яПН;яПН;яПН =яПНяПН.яПН;яПН$яПН;яПН;яПНCяПН;яПН;яПН=яПН=яПН =яПНяПНяПН &яПНяПНcяПН:яПН#<яПН=яПН=яПН 3яПНяПН0яПН0яПН2яПН2яПНяПН %яПНDяПНяПНяПНzяПНяПНяПНяПНяПНяПНDяПНJяПНяПН%яПН%яПН%яПНH яПНяПН{яПНяПНяПНяПН4яПНяПНяПНяПНяПНяПНяПНяПНCяПНяПНяПНяПН$яПНvяПН'AяПН4яПНHяПНHяПНHяПНяПН#яПНяПН$яПНVяПН,яПН,яПНDяПНJяПН>яПН>яПН*яПНCяПНяПНCяПНCяПН!яПНCяПНCяПНCяПНDяПНDяПНGяПНяПНJяПН(яПН(яПНяПНяПНWяПНdяПНmяПН)яПНEяПНEяПНEяПНEяПНяПНEяПНяПНяПН~яПН~яПН".яПНDяПНDяПНDяПНDяПН#FяПН#FяПНяПНяПН яПН,яПН,яПН яПНKяПНяПН$яПН-яПН-яПНIяПНIяПНIяПНIяПН;@яПНяПН7яПНяПН0яПН0яПН яПНMяПН4яПН=яПН1яПНBяПНBяПНBяПН+1яПНяПН(яПНяПН,яПН:яПН#яПН/яПН6яПН6яПН(,яПН(<яПН 7яПН >яПН >яПН:яПН49яПНяПН 1яПНяПН*яПН<яПН#'яПН<яПН<яПН17яПН<яПН<яПН=яПН=яПНGяПНяПНJяПН(яПН(яПНяПНяПНWяПНdяПНmяПН)яПНEяПНEяПНEяПНEяПНяПНяПНяПН яПН$яПН$яПНTяПН[яПН$яПН-яПН$яПНHяПНHяПНHяПНHяПНяПН$яПНVяПН,яПН,яПН AяПН&яПНBяПН)-яПНBяПНBяПН7=яПНBяПНBяПНCяПНCяПНяПНяПН яПН$яПН$яПНяПНKяПНяПН$яПН-яПН%яПНAяПНAяПНAяПНAяПН'яПН'HяПНfяПН'HяПН'HяПНIяПНIяПНяПНяПН яПН$яПН$яПНяПНKяПНяПН$яПН-яПН%яПНAяПНAяПНAяПНAяПНяПН{яПН .яПН .яПН .яПНяПН яПН .яПН$)яПНяПН!яПНяПНяПНяПНяПНяПН4яПН#7яПНяПН8яПН8яПН8яПН8яПНяПНяПНяПН"яПН"яПН3яПН9яПН-яПН-яПН-яПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПН(яПН яПН яПН яПН"%яПНDяПНяПНяПНGяПНGяПНNяПНNяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПН!яПН:яПН.яПН яПН яПН яПНяПНGяПНGяПН!яПН!яПН#яПН&яПН&яПН&яПНяПНяПНяПНяПНяПНяПН 'яПН 'яПН 'яПНяПНGяПНGяПН!яПН!яПН#яПН&яПН&яПН&яПН&яПН&яПН&яПН&яПН&яПНяПНяПНяПНяПН 'яПНяПНяПНяПНd яПНяПН яПНDяПН)яПН)яПН)яПНяПНDяПНDяПНDяПНяПН яПНяПН яПНDяПН)яПН)яПН)яПНяПНDяПНKяПНKяПНKяПНKsbяПН-KяПН=HO3яПН OяПН AL+яПН&O3яПН+OяПН='M)яПН$O3яПН)OяПН="NяПН OяПН,!OяПН O3яПНOяПНO3яПН3PcяПНяПН |яПНяПНяПН|яПНяПНяПНn,#t$r}|яПН|яПНяПНYd}~nd}~wwxYwd}dSrb)rorVrяПН)rWяПНfuturerяПНs r$яПН__wakeupz Task.__wakeup[srяПНяПН яПНяПНMяПНMяПНOяПНOяПНOяПН яПНKяПНKяПНMяПНMяПНMяПНMяПНяПНяПН яПН яПН яПНяПНKяПНKяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПН яПНяПНяПНяПНяПНяПНяПНsяПН+яПН AяПНAяПНArb)яПН__name__яПН __module__яПН__qualname__яПН__doc__rHrEr`яПНclassmethodrяПН__class_getitem__rergrjr7rprsrwr{rяПНrяПНrяПНrVrяПНяПН __classcell__яПНrYs@r$rrNsяПНяПНяПНяПНяПНяПНяПНяПН+яПН*яПН. яПНяПН%)яПНяПНdяПНяПНяПНяПНяПНяПНяПНяПН6 яПН яПН яПН яПН яПН$яПНяПНLяПН1яПН1яПНяПН+яПН+яПН+яПНяПНяПНяПНяПНяПНяПН яПН яПН яПНIяПНIяПНIяПНLяПНLяПНLяПН"&яПН7яПН7яПН7яПН7яПН7яПН.$(яПНdяПН ?яПН ?яПН ?яПН ?яПН ?яПН(яПН(яПН(яПН(яПНT+яПН+яПН+яПН +яПН +яПН +яПНUяПНUяПНUяПНUяПНUяПНUяПНnяПНяПНяПНяПНяПНяПНr%r)r=r@cяПНяПНtjяПНяПН}|яПН|яПН|яПНяПН}n|яПН||яПНяПНяПН}t||яПНяПН|S)z]Schedule the execution of a coroutine object in a spawn task. Return a Task object. NrC)rrrr>)rXr=r@r#r<s r$rrxsYяПНяПН яПН"яПН$яПН$яПНDяПНяПНяПНяПНяПНяПНяПН%яПН%яПНяПНяПНяПНяПНяПНяПНgяПНяПН6яПН6яПНяПНяПН4яПНяПНяПНяПНяПНяПНKr%)яПНtimeoutяПНreturn_whencяПНяПНяПНKяПНtj|яПНяПНstj|яПНяПНr$t dt|яПНяПНjяПНяПНяПНяПНяПН|stdяПНяПНяПН|tttfvrtd|яПНяПНяПНяПНяПНt|яПНяПН}tdяПН|DяПНяПНяПНяПНrt dяПНяПНяПНtjяПНяПН}t||||яПНяПНяПНd{VяПНяПНS)a}Wait for the Futures or Tasks given by fs to complete. The fs iterable must not be empty. Coroutines will be wrapped in Tasks. Returns two sets of Future: (done, pending). Usage: done, pending = await asyncio.wait(fs) Note: This does not raise TimeoutError! Futures that aren't done when the timeout occurs are returned in the second set. zexpect a list of futures, not zSet of Tasks/Futures is empty.zInvalid return_when value: c3яПН>KяПН|]}tj|яПНяПНVяПНяПНdSrb)rrG)r+яПНfs r$яПН zwait..яПНs-яПНяПНяПНяПН 1яПН 1яПНяПН:яПН!яПН!яПН$яПН$яПН 1яПН 1яПН 1яПН 1яПН 1яПН 1r%z6Passing coroutines is forbidden, use tasks explicitly.N)rяПНisfuturerrGrIяПНtyperяПНяПН ValueErrorrrrяПНsetяПНanyrrяПН_wait)яПНfsrяПНrяПНr#s r$rrяПНsяПНяПНяПНяПНяПН яПНяПНяПНяПНяПНNяПНzяПН5яПНbяПН9яПН9яПНNяПНяПНLяПНяПНbяПНяПНяПН9JяПНLяПНLяПНMяПНMяПНMяПН яПН;яПНяПН9яПН:яПН:яПН:яПНяПН?яПНOяПН]яПНKяПНKяПНKяПНяПНDяПН{яПНDяПНDяПНEяПНEяПНEяПН яПНRяПНяПНяПНBяПН яПН 1яПН 1яПНbяПН 1яПН 1яПН 1яПН1яПН1яПНRяПНяПНPяПНQяПНQяПНQяПНяПН"яПН$яПН$яПНDяПНяПНrяПН7яПНKяПНяПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6r%cяПН\яПН|яПНяПНяПНs|яПНdяПНяПНdSdSrb)r*rp)яПНwaiterяПНargss r$яПН_release_waiterrяПНяПНs6яПНяПНяПН;яПН;яПН=яПН=яПН яПНяПНяПНяПН$яПНяПНяПНяПНяПНяПН яПН r%cяПНяПНKяПНtjяПНяПН}|яПН|яПНd{VяПНяПНS|dkrяПНt||яПНяПНяПН}|яПНяПНяПНr|яПНяПНяПНSt||яПНяПНяПНяПНd{VяПНяПН |яПНяПНяПНS#tj$r}t jяПНяПН|яПНd}~wwxYw|яПН яПНяПН}|яПН |t|яПНяПН}tj t|яПНяПН}t||яПНяПНяПН}|яПН|яПНяПН |яПНd{VяПНяПНn~#tj$rl|яПНяПНяПНr*|яПНяПНяПНcY|яПНяПНяПНS|яПН|яПНяПНt||яПНяПНяПНяПНd{VяПНяПНяПНwxYw|яПНяПНяПНr(|яПНяПНяПН|яПНяПНяПНS|яПН|яПНяПНt||яПНяПНяПНяПНd{VяПНяПН |яПНяПНяПН|яПНяПНяПНS#tj$r}t jяПНяПН|яПНd}~wwxYw#|яПНяПНяПНwxYw)aяПНWait for the single Future or coroutine to complete, with timeout. Coroutine will be wrapped in Task. Returns result of the Future or coroutine. When a timeout occurs, it cancels the task and raises TimeoutError. To avoid the task cancellation, wrap it in shield(). If the wait is cancelled, the task is also cancelled. This function is a coroutine. Nrr")rrr r*roяПН_cancel_and_waitrrяПНяПНTimeoutErrorяПН create_futureяПН call_laterrяПНяПН functoolsяПНpartialrяПНrяПНяПНremove_done_callback)яПНfutrяПНr#rяПНrяПНяПНtimeout_handleяПНcbs r$rrяПНsяПНяПНяПНяПНяПНяПН"яПН$яПН$яПНDяПНяПНяПНяПНyяПНyяПНyяПНyяПНyяПНyяПНяПНяПН!яПН|яПН|яПНяПНCяПНdяПН+яПН+яПН+яПНяПНяПН8яПН8яПН:яПН:яПН яПНяПН:яПН:яПН<яПН<яПНяПНяПНsяПНяПН.яПН.яПН.яПН.яПН.яПН.яПН.яПН.яПН.яПН.яПН 5яПНяПН:яПН:яПН<яПН<яПНяПНяПНяПН(яПН 5яПН 5яПН 5яПНяПН)яПН+яПН+яПНяПН4яПНяПНяПНяПНяПН 5яПНяПНяПНяПНяПН яПН яПН !яПН !яПНFяПНяПН_яПН_яПНWяПНoяПНvяПНFяПНFяПНNяПН яПН яПН?яПНFяПН 3яПН 3яПНBяПН яПНяПН$яПН 'яПН 'яПН 'яПНCяПНяПНяПНяПН"яПНяПНяПНяПН яПН яПНяПНLяПНLяПНLяПНLяПНLяПНLяПНLяПНLяПНяПНяПН(яПН яПН яПН яПНяПНxяПНxяПНzяПНzяПН яПНяПНzяПНzяПН|яПН|яПН#яПН#яПН2 яПНяПНяПНяПНяПНяПНяПН/яПН(яПН(яПНяПН,яПН,яПН,яПН'яПНsяПНяПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПНяПН яПНяПНяПНяПНяПН8яПН8яПН:яПН:яПН 9яПНяПН:яПН:яПН<яПН<яПН яПНяПНяПНяПНяПНяПНяПН яПН$яПН$яПНRяПН(яПН(яПН(яПН#яПН3яПНTяПН2яПН2яПН2яПН2яПН2яПН2яПН2яПН2яПН2яПН2яПН 9яПНяПНzяПНzяПН|яПН|яПН яПНяПНяПНяПНяПНяПНяПНяПНяПН,яПН 9яПН 9яПН 9яПН яПН-яПН/яПН/яПНSяПН8яПНяПНяПНяПНяПН 9яПНяПНяПНяПНяПН яПНяПНяПНяПНяПНяПНяПНяПНяПНsfяПН7BяПНB3яПНB.яПН.B3яПН(D1яПН0I+яПН17F,яПН(I+яПН>.F,яПН,*I+яПН+,I+яПНIяПНI(яПНI#яПН#I(яПН(I+яПН+JcяПНяПН~яПНяПНяПН яПН KяПН|яПНяПНяПНяПН dяПН |яПН|яПН|tяПН яПНяПНяПН t|яПНяПНяПНяПНяПНяПН яПН fdяПН}|D]}|яПН|яПНяПНяПН яПН яПНd{VяПНяПНяПН яПНяПН яПНяПНяПН|D]}|яПН|яПНяПНяПНn5#яПН яПНяПН яПНяПНяПН|D]}|яПН|яПНяПНяПНwxYwtяПНяПНtяПНяПН}}|D]A}|яПНяПНяПНr|яПН |яПНяПНяПН,|яПН |яПНяПНяПНB||fS)zVInternal helper for wait(). The fs argument must be a collection of Futures. NcяПН(яПНяПНяПНdzяПНяПНdks>яПНtks3яПНtkri|яПНяПНяПНsW|яПНяПНяПНяПНEяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНsяПНяПНdяПНяПНdSdSdSdSdS)Nrr)rrяПН cancelledrrrяПНr*rp)rяПНяПНcounterrяПНrяПНrяПНs яПНяПНяПНяПНr$яПН_on_completionz_wait.._on_completionsяПНяПНяПНяПНяПН1яПНяПНяПНяПНqяПНLяПНLяПНяПН?яПН*яПН*яПНяПН?яПН*яПН*яПНAяПНKяПНKяПНMяПНMяПН*яПН01яПНяПНяПН яПН яПН0IяПНяПН)яПНяПН%яПН%яПН'яПН'яПН'яПНяПН;яПН;яПН=яПН=яПН (яПНяПН!яПН!яПН$яПН'яПН'яПН'яПН'яПН'яПН +яПН*яПН*яПН*яПН0IяПН0IяПН (яПН (r%) rяПНrяПНrяПНяПНlenrяПНrяПНrяПНrяПНr*яПНadd)rяПНrяПНrяПНr#rяПНrяПНr*яПНpendingrяПНrяПНrяПНs ` @@@r$rяПНrяПНяПНsяПНяПНяПНяПНяПНяПНяПНяПНяПНяПН яПН яПН !яПН !яПНFяПНяПНNяПНяПНяПНяПНяПНяПНяПН/яПН6яПНJяПНJяПНяПНяПН"яПНgяПНgяПНGяПН (яПН (яПН (яПН (яПН (яПН (яПН (яПН (яПНяПН,яПН,яПНяПН яПНяПНяПНNяПН+яПН+яПН+яПН+яПН3яПНяПНяПНяПНяПНяПНяПНяПНяПНяПН%яПНяПН!яПН!яПН#яПН#яПН#яПНяПН 3яПН 3яПНAяПН яПН"яПН"яПН>яПН2яПН2яПН2яПН2яПН 3яПНяПНяПН%яПНяПН!яПН!яПН#яПН#яПН#яПНяПН 3яПН 3яПНAяПН яПН"яПН"яПН>яПН2яПН2яПН2яПН2яПН 3яПНяПНяПНяПНяПНEяПНEяПН3яПН5яПН5яПН'яПНDяПН яПНяПНяПНяПНяПН6яПН6яПН8яПН8яПН яПНяПНHяПНHяПНQяПНKяПНKяПНKяПНKяПНяПНKяПНKяПНяПНNяПНNяПНNяПНNяПНяПНяПН=яПНsяПН-B&яПН&2CcяПНяПН(KяПН|яПНяПНяПН}tjt|яПНяПН}|яПН|яПНяПН |яПНяПНяПН|яПНd{VяПНяПН|яПН|яПНяПНdS#|яПН|яПНяПНwxYw)z.Qs&яПНяПНяПН9яПН9яПН9яПНAяПНMяПН!яПН$яПН'яПН'яПН'яПН9яПН9яПН9r%NcяПНяПНяПНяПНD],}|яПНяПНяПНяПНяПНяПНdяПНяПНяПН-яПНяПНяПНяПНdSrb)rяПНяПН put_nowaitяПНclear)rяПНrяПНr*яПНtodos яПНяПНяПНr$яПН_on_timeoutz!as_completed.._on_timeoutTsLяПНяПНяПНяПН "яПН "яПНAяПН яПН"яПН"яПН>яПН2яПН2яПН2яПНяПНOяПНOяПНDяПН!яПН!яПН!яПН!яПНяПН яПН яПНяПНяПНяПНяПНr%cяПНяПНяПНяПНsdSяПНяПН|яПНяПНяПНяПН|яПНяПНяПНsяПНяПНяПНяПНяПНяПНdSdSdSrb)яПНremoverяПНrяПН)rяПНr*rяПНrяПНs яПНяПНяПНr$rяПНz$as_completed.._on_completionZsfяПНяПНяПНяПН яПНяПНFяПНяПНяПНяПНAяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПН $яПНяПН2яПНяПН!яПН!яПН#яПН#яПН#яПН#яПН#яПН $яПН $яПН2яПН2r%cяПНяПНяПНKяПНяПНяПНяПНяПНяПНd{VяПНяПН}|яПНtjяПН|яПНяПНяПНSrb)r!rrяПНro)rяПНr*s яПНr$яПН _wait_for_onez#as_completed.._wait_for_onebsBяПНяПНяПНяПНяПНяПН(яПН(яПН*яПН*яПНяПНяПНяПНяПНяПНяПНяПНяПН9яПНяПН)яПН)яПНяПНxяПНxяПНzяПНzяПНr%)rrяПНrrGrIrяПНrяПНяПНqueuesrяПНrяПН_get_event_looprяПНrяПНrяПНяПНrangerяПН)rяПНrяПНrяПНrяПНrяПНrяПНяПН_rяПНr*r#rяПНrяПНs @@@@@r$r r 8sяПНяПНяПНяПНяПНяПНяПНяПНяПНяПН$яПНяПНяПНяПНяПНSяПНzяПН5яПНbяПН9яПН9яПНSяПНяПНQяПНdяПН2яПНhяПНhяПН>OяПНQяПНQяПНRяПНRяПНRяПНяПНяПНяПНяПНяПНяПНяПН5яПН7яПН7яПНDяПНяПН!яПН#яПН#яПНDяПН9яПН9яПН9яПН9яПНяПНRяПНяПНяПН9яПН9яПН9яПНDяПНяПНNяПНяПНяПНяПНяПНяПНяПНяПН$яПН$яПН$яПН$яПН$яПН$яПН$яПНяПНяПНяПНяПНяПНяПН,яПН,яПНяПН яПНяПНяПНNяПН+яПН+яПН+яПН+яПНяПН?яПНяПН#яПНяПНяПНяПНяПН+яПН>яПН>яПНяПН яПН3яПНtяПН9яПН9яПН яПН яПНяПНяПНяПНяПНmяПНoяПНoяПНяПНяПНяПНяПНяПНr%c#яПНKяПНdVяПНdS)zяПНSkip one event loop run cycle. This is a private helper for 'asyncio.sleep()', used when the 'delay' is set to 0. It uses a bare 'yield' expression (which Task.__step knows how to handle) instead of creating a Future object. Nr(r(r%r$яПН__sleep0rяПНqsяПНяПНяПНяПН яПНEяПНEяПНEяПНEяПНEr%cяПНяПН>KяПН|dkrtяПНяПНяПНd{VяПНяПН|StjяПНяПН}|яПНяПНяПН}|яПН|t j||яПНяПН} |яПНd{VяПНяПН |яПНяПНяПНS#|яПНяПНяПНwxYw)z9Coroutine that completes after a given time (in seconds).rN)rяПНrrrяПНrяПНrяПН_set_result_unless_cancelledrяПН)яПНdelayror#rяПНяПНhs r$r r }sяПНяПНяПНяПНяПНяПНяПНzяПНzяПНяПНjяПНjяПНяПНяПНяПНяПНяПНяПНяПНяПН яПНяПН"яПН$яПН$яПНDяПН яПН яПН яПН !яПН !яПНFяПНяПНяПНяПНяПНяПН<яПНяПНяПН (яПН (яПНAяПНяПНяПН|яПН|яПН|яПН|яПН|яПН|яПНяПН яПНяПНяПН яПН яПН яПН яПНяПНяПНяПНяПН яПН яПН яПН яПНяПНяПНsяПН)BяПНBr"cяПН$яПНt||яПНяПНяПНS)zmWrap a coroutine or an awaitable in a future. If the argument is a Future, it is returned directly. r")яПН_ensure_future)яПНcoro_or_futurer#s r$r r яПНsяПНяПН яПН.яПНtяПН4яПН4яПН4яПН4r%cяПНяПНtj|яПНяПНr)|яПН%|tj|яПНяПНurtdяПНяПНяПН|Sd}t j|яПНяПНs5t j|яПНяПНrt|яПНяПН}d}ntdяПНяПНяПН|яПНtjdяПНяПНяПН} |яПН|яПНяПНS#t$r|s|яПНяПНяПНяПНwxYw)NzRThe future belongs to a different loop than the one specified as the loop argumentFTz:An asyncio.Future, a coroutine or an awaitable is requiredяПНr5)rrяПНr)rяПНrrGrяПНяПНisawaitableяПН_wrap_awaitablerIrrяПНrr0яПНclose)rяПНr#яПНcalled_wrap_awaitables r$rяПНrяПНяПНsяПНяПНяПНяПНяПН'яПН'яПНяПНяПНяПНяПНGяПН,=яПНnяПН,MяПН,MяПН MяПН MяПНяПНEяПНFяПНFяПН FяПНяПНяПН!яПНяПНяПН!яПН.яПН1яПН1яПН+яПНяПНяПН~яПН.яПН.яПН +яПН,яПН^яПН<яПН<яПНNяПН$(яПН!яПН!яПНяПН*яПН+яПН+яПН +яПНяПН|яПНяПН%яПНяПН3яПН3яПН3яПНяПНяПНяПНяПНяПНяПН/яПН/яПН/яПНяПНяПНяПНяПНяПН$яПН #яПНяПН яПН яПН"яПН"яПН"яПН яПНяПНяПНяПНsяПН!B6яПН6"Cc#яПН:KяПН|яПНяПНяПНEd{VяПНяПНS)zяПНHelper for asyncio.ensure_future(). Wraps awaitable (an object with __await__) into a coroutine that will later be wrapped in a Task by ensure_future(). N)яПН __await__)яПН awaitables r$rяПНrяПНяПНs,яПНяПНяПНяПН!яПН*яПН*яПН,яПН,яПН,яПН,яПН,яПН,яПН,яПН,яПН-r%cяПН*яПНяПНeZdZdZяПНfdяПНZddяПНZяПНxZS)яПН_GatheringFuturezяПНHelper for gather(). This overrides cancel() to cancel all the children and act more like Task.cancel(), which doesn't immediately mark itself as cancelled. cяПНhяПНяПНtяПНяПНяПН|яПНяПНяПН||_d|_dS)Nr"F)rDrEяПН _childrenяПН_cancel_requested)rWяПНchildrenr#rYs яПНr$rEz_GatheringFuture.__init__яПНs3яПНяПНяПН яПНяПНяПНяПНяПНdяПНяПН#яПН#яПН#яПН!яПНяПНяПН!&яПНяПНяПНяПНr%NcяПНяПН|яПНяПНяПНrdSd}|jD]}|яПН|яПНяПНяПНrd}яПН|rd|_|S)NFr}T)r*rяПНrяПНrяПН)rWr~яПНretяПНchilds r$rяПНz_GatheringFuture.cancelяПНs`яПНяПНяПН9яПН9яПН;яПН;яПН яПНяПН5яПНяПНяПНяПН^яПН яПН яПНEяПНяПН|яПН|яПНяПН|яПН$яПН$яПН яПНяПНяПНяПНяПН *яПН&*яПНDяПН"яПНяПН r%rb)rяПНrяПНrяПНrяПНrErяПНrяПНrяПНs@r$rяПНrяПНяПНsVяПНяПНяПНяПНяПНяПНяПНяПНяПН'яПН'яПН'яПН'яПН'яПНяПНяПНяПНяПНяПНяПНяПНr%rяПНF)яПНreturn_exceptionscяПНяПНяПНяПНяПНяПН яПН яПН|s>tjяПНяПН}|яПНяПНяПНяПН яПН яПНgяПНяПНяПН SяПНяПНяПН яПН яПНfdяПН}i}gяПНdяПН dяПНd}dяПН |D]u}||vrRt ||яПНяПНяПН}|яПНtj|яПНяПН}||urd|_яПН dz яПН |||<|яПН|яПНяПНn||}яПНяПН |яПНяПНяПНvtяПН|яПНяПНяПНяПН яПН S)aяПНReturn a future aggregating results from the given coroutines/futures. Coroutines will be wrapped in a future and scheduled in the event loop. They will not necessarily be scheduled in the same order as passed in. All futures must share the same event loop. If all the tasks are done successfully, the returned future's result is the list of results (in the order of the original sequence, not necessarily the order of results arrival). If *return_exceptions* is True, exceptions in the tasks are treated the same as successful results, and gathered in the result list; otherwise, the first raised exception will be immediately propagated to the returned future. Cancellation: if the outer Future is cancelled, all children (that have not completed yet) are also cancelled. If any child is cancelled, this is treated as if it raised CancelledError -- the outer Future is *not* cancelled in this case. (This is to prevent the cancellation of one child to cause other children to be cancelled.) If *return_exceptions* is False, cancelling gather() after it has been marked done won't cancel any submitted awaitables. For instance, gather can be marked done after propagating an exception to the caller, therefore, calling ``gather.cancel()`` after catching an exception (raised by one of the awaitables) from gather won't cancel any other awaitables. cяПНяПНяПНяПНdz яПНяПНяПНяПНяПНяПНяПНr*|яПНяПНяПНs|яПНяПНяПНdSяПНsl|яПНяПНяПНr+|яПНяПНяПН}яПНяПН|яПНяПНdS|яПНяПНяПН}|яПНяПНяПН|яПНяПНdSяПНяПНkrяПНg}яПНD]x}|яПНяПНяПНr#tj|jяПНdn|jяПНяПН}n*|яПНяПНяПН}|яПН|яПНяПНяПН}|яПН |яПНяПНяПНyяПНj r+|яПНяПНяПН}яПНяПН|яПНяПНdSяПНяПН|яПНяПНdSdS)NrяПН)r*rяПНrrrяПНrsrrяПНrяПНroяПНappendrяПНrp) rяПНrяПНяПНresultsяПНresrяПНяПН nfinishedяПНnfutsяПНouterrяПНs яПНяПНяПНяПНяПНr$яПН_done_callbackzgather.._done_callbackяПНsяПНяПНяПНяПНяПНQяПНяПН яПНяПН=яПНEяПНJяПНJяПНLяПНLяПН=яПНяПН=яПН=яПН?яПН?яПН яПНяПН яПН яПНяПНяПНяПНяПНFяПН яПН яПНяПН}яПН}яПНяПНяПН яПНяПН/яПН/яПН1яПН1яПНяПНяПН#яПН#яПНCяПН(яПН(яПН(яПНяПНяПНяПНmяПНmяПНoяПНoяПНяПНяПН?яПНяПН'яПН'яПНяПН,яПН,яПН,яПНяПНFяПНяПНяПНяПНяПНяПНGяПНяПН $яПН $яПНяПНяПН=яПН=яПН?яПН?яПН +яПН%яПН3яПН!яПН1яПН9яПНяПНяПНяПН+яПН-яПН-яПНCяПНCяПНяПН-яПН-яПН/яПН/яПНCяПНяПН{яПН!яПНjяПНjяПНlяПНlяПНяПНяПНяПНяПНsяПН#яПН#яПН#яПН#яПНяПН&яПН *яПНяПН/яПН/яПН1яПН1яПНяПНяПН#яПН#яПНCяПН(яПН(яПН(яПН(яПН(яПНяПН яПН яПНяПН)яПН)яПН)яПН)яПН)яПН;яПНr%rNr"Fr)rrяПНrяПНrprяПНrr)rHrяПНrяПНrяПН)rяПНяПНcoros_or_futuresr#rяПН arg_to_futяПНargrяПНrяПНrrrs` @@@@r$rrяПНsKяПНяПНяПНяПНяПНяПНяПН<яПНяПНяПН%яПН'яПН'яПНяПНяПН"яПН"яПН$яПН$яПНяПН яПНяПНяПНяПНяПНяПНяПНяПНяПН5*яПН5*яПН5*яПН5*яПН5*яПН5*яПН5*яПН5*яПН5*яПНnяПНJяПНяПНHяПН яПНEяПНяПНIяПНяПНDяПНяПНEяПНяПНяПНяПНяПНяПНjяПН яПН яПН яПНяПН4яПН0яПН0яПН0яПНCяПНяПН|яПНяПН(яПНяПН-яПН-яПНяПНяПН#яПН~яПН~яПН ,1яПНяПН(яПНяПНQяПНJяПНEяПН!яПНJяПНsяПНOяПНяПН!яПН!яПН.яПН1яПН1яПН1яПН1яПНяПНSяПН/яПНCяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНXяПНDяПН1яПН1яПН1яПНEяПНяПНLr%cяПНяПНяПНяПНяПНt|яПНяПНяПНяПНяПНяПНяПНrяПНStjяПНяПНяПН}|яПНяПНяПНяПНяПНfdяПНяПНяПНяПНfdяПН}яПНяПНяПНяПНяПНяПНяПН|яПНяПНяПНS)aяПНWait for a future, shielding it from cancellation. The statement task = asyncio.create_task(something()) res = await shield(task) is exactly equivalent to the statement res = await something() *except* that if the coroutine containing it is cancelled, the task running in something() is not cancelled. From the POV of something(), the cancellation did not happen. But its caller is still cancelled, so the yield-from expression still raises CancelledError. Note: If something() is cancelled by other means this will still cancel shield(). If you want to completely ignore cancellation (not recommended) you can combine shield() with a try/except clause, as follows: task = asyncio.create_task(something()) try: res = await shield(task) except CancelledError: res = None Save a reference to tasks passed to this function, to avoid a task disappearing mid-execution. The event loop only keeps weak references to tasks. A task that isn't referenced elsewhere may get garbage collected at any time, even before it's done. cяПНяПНяПНяПНяПНяПНяПНr*|яПНяПНяПНs|яПНяПНяПНdS|яПНяПНяПНrяПНяПНяПНяПНdS|яПНяПНяПН}|яПНяПНяПН|яПНяПНdSяПНяПН|яПНяПНяПНяПНяПНdSrb)rяПНrrrяПНrsrpro)яПНinnerrяПНrs яПНr$яПН_inner_done_callbackz$shield.._inner_done_callback{sяПНяПНяПНяПНяПН?яПН?яПНяПНяПН яПНяПН?яПН?яПН$яПН$яПН "яПНяПНяПНяПН!яПН!яПН!яПНяПНFяПНяПН?яПН?яПНяПНяПН 1яПНяПНLяПНLяПНNяПНNяПНNяПНNяПНNяПНяПН/яПН/яПН#яПН#яПНCяПНяПНяПНяПН#яПН#яПНCяПН(яПН(яПН(яПН(яПН(яПНяПН яПН яПНяПНяПНяПНяПНяПН0яПН0яПН0яПН0яПН0r%cяПН^яПНяПНяПНяПНяПНяПНsяПНяПНяПНяПНяПНdSdSrb)r*rяПН)rr r s яПНяПНr$яПН_outer_done_callbackz$shield.._outer_done_callbackяПНs8яПНяПНяПНяПНzяПНzяПН|яПН|яПН =яПНяПН&яПН&яПН';яПН<яПН<яПН<яПН<яПН<яПН =яПН =r%)rяПНr*rr)rяПНrяПН)rr#rr r rs @@@r$rrSsяПНяПНяПНяПНяПНяПНB яПН3яПНяПНяПНEяПНяПНzяПНzяПН|яПН|яПНяПНяПНяПНяПНяПНUяПН#яПН#яПНDяПНяПНяПНяПН яПН яПНEяПН1яПН1яПН1яПН1яПН1яПН"=яПН=яПН=яПН=яПН=яПН=яПН яПНяПНяПН0яПН1яПН1яПН1яПН яПНяПНяПН0яПН1яПН1яПН1яПНяПНLr%cяПНяПНяПНяПНяПНяПНtjяПНяПНяПНstdяПНяПНяПНtjяПНяПНяПНяПНяПНяПНяПНfdяПН}яПНяПН|яПНяПНяПНS)zsSubmit a coroutine object to a given event loop. Return a concurrent.futures.Future to access the result. zA coroutine object is requiredcяПНяПНяПНяПН tjtяПНяПНяПНяПНяПНяПНяПНяПНdS#ttf$rяПНt $r/}яПНяПНяПНяПНrяПНяПН|яПНяПНяПНd}~wwxYw)Nr")rяПН _chain_futurer rяПНrяПНrяПНяПНset_running_or_notify_cancelrs)rяПНrXrяПНr#s яПНяПНяПНr$яПНcallbackz*run_coroutine_threadsafe..callbackяПНsяПНяПНяПНяПН яПНяПН!яПН-яПНяПН4яПН"@яПН"@яПН"@яПН&яПНIяПНIяПНIяПНIяПНIяПНяПНяПН-яПН.яПН яПН яПН яПНяПНяПН яПН яПН яПНяПН2яПН2яПН4яПН4яПН *яПНяПН$яПН$яПНSяПН)яПН)яПН)яПНяПНяПНяПНяПНяПН яПНяПНяПНsяПН$)яПНA3яПН*A.яПН.A3)rrGrIяПН concurrentrяПНFutureяПНcall_soon_threadsafe)rXr#rrяПНs`` @r$rrяПНs{яПНяПНяПНяПНяПН яПН!яПН$яПН'яПН'яПН:яПНяПН8яПН9яПН9яПН9яПН яПН яПН &яПН &яПН (яПН (яПНFяПНяПНяПНяПНяПНяПНяПНяПН яПНяПНяПНhяПН'яПН'яПН'яПНяПНMr%cяПН.яПНtj|яПНяПНdS)z3Register a new task in asyncio as executed by loop.N)r/rяПНяПНr<s r$rrяПНsяПНяПНяПНNяПН4яПНяПНяПНяПНяПНr%cяПНrяПНtj|яПНяПН}|яПНtd|яПНd|яПНdяПНяПНяПНяПН|t|<dS)NzCannot enter into task z while another task z is being executed.яПНr r!r0яПНr#r<rs r$rrяПНsfяПНяПН!яПН%яПНdяПН+яПН+яПНLяПНяПНяПНяПНGяПНTяПНGяПНGяПН#/яПНGяПНGяПНGяПНHяПНHяПН HяПНяПНNяПН4яПНяПНяПНr%cяПНrяПНtj|яПНяПН}||urtd|яПНd|яПНdяПНяПНяПНяПНt|=dS)Nz Leaving task z! does not match the current task яПН.rrs r$rrяПНsiяПНяПН!яПН%яПНdяПН+яПН+яПНLяПНяПН4яПНяПНяПНяПНAяПН4яПНAяПНAяПН/;яПНAяПНAяПНAяПНBяПНBяПН BяПНяПНtяПНяПНяПНr%cяПН.яПНtj|яПНяПНdS)zUnregister a task.N)r/яПНdiscardrs r$rrяПНsяПНяПНяПНяПНtяПНяПНяПНяПНяПНr%)rrrrr/r rb)CrяПНяПН__all__яПНconcurrent.futuresrrQrяПНrяПНяПН itertoolsяПНtypesr9яПНweakrefrrяПНrrrrrrяПНcountяПН__next__rJrrr>яПН _PyFuturerяПН_PyTaskяПН_asyncioяПН_CTaskяПНImportErrorrrrrrrяПНrrяПНrяПНr яПН coroutinerяПНr r rяПНrяПНrrяПНrrrяПНWeakSetr/r rrrrяПН_py_register_taskяПН_py_unregister_taskяПН_py_enter_taskяПН_py_leave_taskяПН_c_register_taskяПН_c_unregister_taskяПН _c_enter_taskяПН _c_leave_taskr(r%r$яПНr4syяПНяПН6яПН6яПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПНяПН%яПН%яПН%яПН%яПН%яПН%яПН %яПНYяПН_яПНQяПН'яПН'яПН0яПНяПН$яПН$яПН$яПН$яПН>яПН>яПН>яПН>яПН. яПН яПН яПН[яПН[яПН[яПН[яПН[яПН7яПНяПН[яПН[яПН[яПН|яПНяПН"яПНяПНOяПНOяПНOяПН яПНMяПН!яПНDяПН6яПН6яПНяПН яПН яПН яПН яПНяПНDяПН яПНяПНяПНяПН#яПНDяПН яПН яПН яПН яПН яПН$яПН$яПН4яПНяПНяПН$яПН4яПНяПНяПН"яПН0яПН яПН#яПН яПН7яПН7яПН7яПН7яПН7яПН@ яПН яПН яПН D яПНD яПНD яПНN)яПН)яПН)яПНX %яПН %яПН %яПН"!%яПН6яПН6яПН6яПН6яПН6яПНrяПНяПН яПН яПНяПНяПН яПНяПНяПНяПНяПН"+/яПН5яПН5яПН5яПН5яПН5яПН,0яПНяПНяПНяПНяПНяПН2яПНяПН.яПН.яПНяПНяПН.яПН!.яПНяПНяПНяПНяПНяПНяПНяПНwяПН~яПНяПНяПНяПН:16яПНxяПНxяПНxяПНxяПНxяПНv?яПН?яПН?яПНDяПНяПНяПН0яПНWяПН_яПН яПН яПН яПНяПНяПНяПНяПНяПН яПН яПН яПНяПНяПНяПНяПНяПНяПН #яПНяПН&яПНяПНяПНяПНяПНяПН яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН6яПН&яПНяПН)яПНяПНяПНMяПНяПНMяПНMяПНMяПНяПН яПН яПН яПН яПНяПНDяПНDяПН яПНяПНяПНs$яПНBяПНBяПНBяПНE8яПН8FяПНF