/opt/alt/python311/lib64/python3.11/asyncio/__pycache__
Edit: /opt/alt/python311/lib64/python3.11/asyncio/__pycache__/runners.cpython-311.opt-1.pyc (10247B)
/g d Z ddlZddlZddlZddlZddlZddlZddlmZ ddlm Z ddlm
Z
ddlm Z G d d ej Z
G d
d Zdd d
Zd ZdS ))Runnerrun N )
coroutines)events)
exceptions)tasksc e Zd ZdZdZdZdS )_Statecreated initializedclosedN)__name__
__module__ __qualname__CREATED INITIALIZEDCLOSED 6/opt/alt/python311/lib64/python3.11/asyncio/runners.pyr r s G K
FFFr r c P e Zd ZdZddddZd Zd Zd Zd Zdd d
Z d Z
d Z dS )
r a5 A context manager that controls event loop life cycle.
The context manager always creates a new event loop,
allows to run async functions inside it,
and properly finalizes the loop at the context manager exit.
If debug is True, the event loop will be run in debug mode.
If loop_factory is passed, it is used for new event loop creation.
asyncio.run(main(), debug=True)
is a shortcut for
with asyncio.Runner(debug=True) as runner:
runner.run(main())
The run() method can be called multiple times within the runner's context.
This can be useful for interactive console (e.g. IPython),
unittest runners, console tools, -- everywhere when async code
is called from existing sync framework and where the preferred single
asyncio.run() call doesn't work.
N)debug loop_factoryc | t j | _ || _ || _ d | _ d | _ d| _ d| _ d S )Nr F) r r _state_debug
_loop_factory_loop_context_interrupt_count_set_event_loop)selfr r s r __init__zRunner.__init__1 s> n )
! $ r c . | | S N)
_lazy_initr# s r __enter__zRunner.__enter__: s r c . | d S r& )close)r# exc_typeexc_valexc_tbs r __exit__zRunner.__exit__> s
r c | j t j urdS | j }t | | | | | | j rt j
d | d| _ t j | _ dS # | j rt j
d | d| _ t j | _ w xY w)z Shutdown and close event loop.N)
r r r r _cancel_all_tasksrun_until_completeshutdown_asyncgensshutdown_default_executorr" r set_event_loopr+ r )r# loops r r+ z Runner.closeA s ;f 0 0 0 F
(:D d # # # # #D$;$;$=$= > > > # #D$B$B$D$D E E E#
,%d+++ JJLLL DJ -DKKK #
,%d+++ JJLLL DJ -DK ' ' ' 's
A$C A D
c 8 | | j S )zReturn embedded event loop.)r' r r( s r get_loopzRunner.get_loopQ s zr contextc t j | s"t d | t j t
d | || j }| j
|| }t j t j
u rxt j t j t j u rNt% j | j | } t j t j | n# t $ r d}Y nw xY wd}d| _ | j | |Jt j t j |u r+t j t j t j S S S # t. j $ r< | j dk r/t3 |dd }| | dk rt5 w xY w# |Jt j t j |u r+t j t j t j w w w xY w)z/Run a coroutine inside the embedded event loop.z"a coroutine was expected, got {!r}Nz7Runner.run() cannot be called from a running event loopr9 ) main_taskr uncancel)r iscoroutine
ValueErrorformatr _get_running_loop RuntimeErrorr' r r create_task threadingcurrent_thread main_threadsignal getsignalSIGINTdefault_int_handler functoolspartial
_on_sigintr! r2 r CancelledErrorgetattrKeyboardInterrupt)r# coror: tasksigint_handlerr= s r r z
Runner.runV s5 %d++ P A H H N NOO O # % % 1 IK K
K
?mGz%%dG%<< $ & &)*?*A*A A A //63MMM & .t$ O O ON
&
fm^<<<<
&
&
& "&
& "N ! I:0066 *$V]33~EE
fmV-GHHHH +E ( $q(("4T::'HHJJ!OO+--- *$V]33~EE
fmV-GHHHH +Es, > D D-,D-:F! !A G,,G/ /AH>c | j t j u rt d | j t j u rd S | j @t
j | _ | j s t
j
| j d| _ n| | _ | j | j | j t j | _ t j | _ d S )NzRunner is closedT)r r r rB r r r new_event_loopr r" r5 r set_debug contextvars copy_contextr r( s r r' zRunner._lazy_init s ;&- ' ' 122 2 ;&, , , F % .00DJ'
, %dj111'+$ ++--DJ ; " J - - -#022
( r c | xj dz
c_ | j dk rE| s1| | j d d S t )Nr c d S r& r r r r
z#Runner._on_sigint.. s D r )r! donecancelr call_soon_threadsaferP )r# signumframer< s r rM zRunner._on_sigint sn " A % %inn.>.> % J + +LL 9 9 9 F !!!r ) r r r __doc__r$ r) r/ r+ r8 r r' rM r r r r r s 6 !%4 % % % % % ( ( (
$( +I +I +I +I +IZ) ) )&" " " " "r r r c t j t d t | 5 }| | cddd S # 1 swxY w Y dS )a Execute the coroutine and return the result.
This function runs the passed coroutine, taking care of
managing the asyncio event loop and finalizing asynchronous
generators.
This function cannot be called when another asyncio event loop is
running in the same thread.
If debug is True, the event loop will be run in debug mode.
This function always creates a new event loop and closes it at the end.
It should be used as a main entry point for asyncio programs, and should
ideally only be called once.
Example:
async def main():
await asyncio.sleep(1)
print('hello')
asyncio.run(main())
Nz8asyncio.run() cannot be called from a running event looprb )r rA rB r r )mainr runners r r r s 0 !!- FH H H
e zz$ s AA Ac b t j | }|sd S |D ]}| | t j |ddi |D ]V}| r| +| d| |d Wd S )Nreturn_exceptionsTz1unhandled exception during asyncio.run() shutdown)message exceptionrR )r all_tasksr] r2 gather cancelledri call_exception_handler)r6 to_cancelrR s r r1 r1 s %%I
EL) Lt L LMMM >> >> ' ' 'N !^^ - - ) )
r )__all__rW enumrK rD rG sys r r r r Enumr r r r1 r r r rt s&
TY H" H" H" H" H" H" H" H"V B r