U
|
Z ±dì ã @ s d dl mZ d dlZd dlZddlmZ ddlmZ ddlm Z ej
|
dd G d
|
d d Z ej
|
d d dd G dd dedZ dS )é )ÚdequeNé )Ú_core)ÚNoPublicConstructoré )ÚWakeupSocketpairT)Úslotsc @ sp e Zd ZejedZejedZeje dZ
|
ejddZ eje j dZdd Zdd Zdd Zdd
|
d d Zd S )Ú
|
EntryQueue)ÚfactoryF)Údefaultc sº t ¡ s tjjjdks tdd fdd}z8| jsZjsZj ¡ I d H q6t
|
¡ I d H q6W nH t j k
|
r´ j d_ W 5 Q R X | jr¦tjr°tY nX d S )NÚ_threadc S s| | \}}z || W nb t k
|
rv } zDdd }zt ||¡ W n& tk
|
rd t ¡ j ||¡ Y nX W 5 d }~X Y nX dS )Nc Ó s | d S ©N© )Úexcr r úNd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\trio/_core/_entry_queue.pyÚkill_everything8 s z8EntryQueue.task.<locals>.run_cb.<locals>.kill_everythingT)Ú BaseExceptionr Zspawn_system_taskÚ RuntimeErrorZ current_taskZparent_nurseryZ
|
start_soon)ÚjobÚsync_fnÚargsr r r r r Úrun_cb. s *z EntryQueue.task.<locals>.run_cbc sF t tjD ]} j ¡ qtjD ]}j|= | q,d S r )ÚrangeÚlenÚqueueÚpopleftÚlistÚidempotent_queue)Ú_r ©r Úselfr r Úrun_all_boundedI s
|
z(EntryQueue.task.<locals>.run_all_boundedT) r Zcurrently_ki_protectedÚAssertionErrorÚlockÚ __class__Ú
|
__module__r r ÚwakeupZ
|
wait_wokenÚ
|
checkpointZ CancelledÚdone)r r! r r r Útask# s
|
zEntryQueue.taskc C s | j ¡ d S r )r& Úclose©r r r r r* k s zEntryQueue.closec C s t | jt | j S r )r r r r+ r r r Úsizen s zEntryQueue.size©Ú
|
idempotentc G sT | j D | jrt d¡|r,d | j||f< n| j ||f¡ | j ¡ W 5 Q R X d S )Nzrun() has exited) r# r( r ZRunFinishedErrorr r Úappendr& Z wakeup_thread_and_signal_safe©r r r. r r r r Ú run_sync_soonq s
|
zEntryQueue.run_sync_soonN)Ú__name__r% Ú __qualname__ÚattrÚibr r Údictr r r& r( Ú threadingÚRLockr# r) r* r, r1 r r r r r s Hr F)ÚeqÚhashr c @ s& e Zd ZdZe ¡ ZddddZdS )Ú TrioTokena An opaque object representing a single call to :func:`trio.run`.
|
|
It has no public constructor; instead, see :func:`current_trio_token`.
|
|
This object has two uses:
|
|
1. It lets you re-enter the Trio run loop from external threads or signal
|
handlers. This is the low-level primitive that :func:`trio.to_thread`
|
and `trio.from_thread` use to communicate with worker threads, that
|
`trio.open_signal_receiver` uses to receive notifications about
|
signals, and so forth.
|
|
2. Each call to :func:`trio.run` has exactly one associated
|
:class:`TrioToken` object, so you can use it to identify a particular
|
call.
|
|
Fr- c G s | j j|f|d|i dS )a¹ Schedule a call to ``sync_fn(*args)`` to occur in the context of a
|
Trio task.
|
|
This is safe to call from the main thread, from other threads, and
|
from signal handlers. This is the fundamental primitive used to
|
re-enter the Trio run loop from outside of it.
|
|
The call will happen "soon", but there's no guarantee about exactly
|
when, and no mechanism provided for finding out when it's happened.
|
If you need this, you'll have to build your own.
|
|
The call is effectively run as part of a system task (see
|
:func:`~trio.lowlevel.spawn_system_task`). In particular this means
|
that:
|
|
* :exc:`KeyboardInterrupt` protection is *enabled* by default; if
|
you want ``sync_fn`` to be interruptible by control-C, then you
|
need to use :func:`~trio.lowlevel.disable_ki_protection`
|
explicitly.
|
|
* If ``sync_fn`` raises an exception, then it's converted into a
|
:exc:`~trio.TrioInternalError` and *all* tasks are cancelled. You
|
should be careful that ``sync_fn`` doesn't crash.
|
|
All calls with ``idempotent=False`` are processed in strict
|
first-in first-out order.
|
|
If ``idempotent=True``, then ``sync_fn`` and ``args`` must be
|
hashable, and Trio will make a best-effort attempt to discard any
|
call submission which is equal to an already-pending call. Trio
|
will process these in first-in first-out order.
|
|
Any ordering guarantees apply separately to ``idempotent=False``
|
and ``idempotent=True`` calls; there's no rule for how calls in the
|
different categories are ordered with respect to each other.
|
|
:raises trio.RunFinishedError:
|
if the associated call to :func:`trio.run`
|
has already exited. (Any call that *doesn't* raise this error
|
is guaranteed to be fully processed before :func:`trio.run`
|
exits.)
|
|
r. N)Ú_reentry_queuer1 r0 r r r r1 s ,zTrioToken.run_sync_soonN)r2 r% r3 Ú__doc__r4 r5 r< r1 r r r r r; s r; )Ú metaclass) Ú collectionsr r7 r4 Ú r Z_utilr Z_wakeup_socketpairr Úsr r; r r r r Ú<module> s
|
u
|
