U
|
Z ±dÑ6 ã @ s d dl Z d dlZd dlZd dlZd dlmZ d dlZd dlZd dl Z d dl
|
m Z d dl Z ddl mZ ddlmZmZmZmZmZ ddlmZ e ¡ ZedZd Ze Zd
|
d Z ej d d d dG dd dZ ed ddddZ ddddZ ddddZ!ddddZ"dS )é N)Úcount)Úcurrent_async_library_cvaré )ÚCapacityLimiter)Úenable_ki_protectionÚdisable_ki_protectionÚRunVarÚ TrioTokenÚstart_thread_soon©Úcoroutine_or_errorÚlimiteré( c C s8 z t ¡ } W n& tk
|
r2 tt} t | ¡ Y nX | S )zÚGet the default `~trio.CapacityLimiter` used by
|
`trio.to_thread.run_sync`.
|
|
The most common reason to call this would be if you want to modify its
|
:attr:`~trio.CapacityLimiter.total_tokens` attribute.
|
|
)Ú_limiter_localÚgetÚ LookupErrorr Ú DEFAULT_LIMITÚset)r © r úDd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\trio/_threads.pyÚ current_default_thread_limiter$ s r TF)ÚfrozenÚeqÚhashc @ s e Zd Ze ¡ ZdS )ÚThreadPlaceholderN)Ú__name__Ú
|
__module__Ú __qualname__ÚattrÚibÚnamer r r r r 8 s r )Ú cancellabler c
|
sî t j ¡ I dH tdkr&t t j ¡ gdtt }t|fddt j ¡ fdd}t
|
¡ }t |j|¡}fdd} ¡I dH zt|| W n ¡ Y nX fd d
|
} t j | ¡I dH S ) u Convert a blocking operation into an async operation using a thread.
|
|
These two lines are equivalent::
|
|
sync_fn(*args)
|
await trio.to_thread.run_sync(sync_fn, *args)
|
|
except that if ``sync_fn`` takes a long time, then the first line will
|
block the Trio loop while it runs, while the second line allows other Trio
|
tasks to continue working while ``sync_fn`` runs. This is accomplished by
|
pushing the call to ``sync_fn(*args)`` off into a worker thread.
|
|
From inside the worker thread, you can get back into Trio using the
|
functions in `trio.from_thread`.
|
|
Args:
|
sync_fn: An arbitrary synchronous callable.
|
*args: Positional arguments to pass to sync_fn. If you need keyword
|
arguments, use :func:`functools.partial`.
|
cancellable (bool): Whether to allow cancellation of this operation. See
|
discussion below.
|
limiter (None, or CapacityLimiter-like object):
|
An object used to limit the number of simultaneous threads. Most
|
commonly this will be a `~trio.CapacityLimiter`, but it could be
|
anything providing compatible
|
:meth:`~trio.CapacityLimiter.acquire_on_behalf_of` and
|
:meth:`~trio.CapacityLimiter.release_on_behalf_of` methods. This
|
function will call ``acquire_on_behalf_of`` before starting the
|
thread, and ``release_on_behalf_of`` after the thread has finished.
|
|
If None (the default), uses the default `~trio.CapacityLimiter`, as
|
returned by :func:`current_default_thread_limiter`.
|
|
**Cancellation handling**: Cancellation is a tricky issue here, because
|
neither Python nor the operating systems it runs on provide any general
|
mechanism for cancelling an arbitrary synchronous function running in a
|
thread. This function will always check for cancellation on entry, before
|
starting the thread. But once the thread is running, there are two ways it
|
can handle being cancelled:
|
|
* If ``cancellable=False``, the function ignores the cancellation and
|
keeps going, just like if we had called ``sync_fn`` synchronously. This
|
is the default behavior.
|
|
* If ``cancellable=True``, then this function immediately raises
|
`~trio.Cancelled`. In this case **the thread keeps running in
|
background** â we just abandon it to do whatever it's going to do, and
|
silently discard any return value or errors that it raises. Only use
|
this if you know that the operation is safe and side-effect free. (For
|
example: :func:`trio.socket.getaddrinfo` uses a thread with
|
``cancellable=True``, because it doesn't really affect anything if a
|
stray hostname lookup keeps running in the background.)
|
|
The ``limiter`` is only released after the thread has *actually*
|
finished â which in the case of cancellation may be some time after this
|
function has returned. If :func:`trio.run` finishes before the thread
|
does, then the limiter release method will never be called at all.
|
|
.. warning::
|
|
You should not use this function to call long-running CPU-bound
|
functions! In addition to the usual GIL-related reasons why using
|
threads for CPU-bound work is not very effective in Python, there is an
|
additional problem: on CPython, `CPU-bound threads tend to "starve out"
|
IO-bound threads <https://bugs.python.org/issue7946>`__, so using
|
threads for CPU-bound work is likely to adversely affect the main
|
thread running Trio. If you need to do this, you're better off using a
|
worker process, or perhaps PyPy (which still has a GIL, but may do a
|
better job of fairly allocating CPU time between threads).
|
|
Returns:
|
Whatever ``sync_fn(*args)`` returns.
|
|
Raises:
|
Exception: Whatever ``sync_fn(*args)`` raises.
|
|
Nztrio.to_thread.run_sync-c s< fdd}t |¡ d d k r8tj d ¡ d S )Nc s z ¡ W ¢S ¡ X d S ©N)Úrelease_on_behalf_ofÚunwrapr )r Ú placeholderÚresultr r Ú do_release_then_return_result s z`to_thread_run_sync.<locals>.report_back_in_trio_thread_fn.<locals>.do_release_then_return_resultr )ÚoutcomeÚcaptureÚtrioÚlowlevelZ
|
reschedule)r& r' )r r% Ú task_register©r& r Ú report_back_in_trio_thread_fn s
|
|
z9to_thread_run_sync.<locals>.report_back_in_trio_thread_fnc sT t d ¡ t_z8 } t | ¡rB| ¡ td t d¡| W ¢S t`X d S ©NzBTrio expected a sync function, but {!r} appears to be asynchronousr )
|
r r Ú TOKEN_LOCALÚtokenÚinspectÚ iscoroutineÚcloseÚ TypeErrorÚformatÚgetattr©Úret)ÚargsÚcurrent_trio_tokenÚsync_fnr r Ú worker_fn« s
|
|
|
ÿÿz%to_thread_run_sync.<locals>.worker_fnc s, z | ¡ W n tjk
|
r& Y nX d S r" )Ú run_sync_soonr* ÚRunFinishedErrorr- )r; r. r r Údeliver_worker_fn_resultÀ s z4to_thread_run_sync.<locals>.deliver_worker_fn_resultc s$ rd d< t jjjS t jjjS d S )Nr )r* r+ ZAbortZ SUCCEEDEDZFAILED)Ú_)r! r, r r ÚabortÐ s
|
z!to_thread_run_sync.<locals>.abort)r* r+ Zcheckpoint_if_cancelledÚboolr Ú current_taskÚnextÚ_thread_counterr r; Ú contextvarsÚ copy_contextÚ functoolsÚpartialÚrunZacquire_on_behalf_ofr
|
r# Zwait_task_rescheduled)
|
r< r! r r: r r= ÚcontextZcontextvars_aware_worker_fnr@ rB r )r: r! r; r r% r. r< r, r Úto_thread_run_sync= s* O
|
|
rM )Ú
|
trio_tokenc G s |rt |tstd|sBz
|
tj}W n tk
|
r@ tdY nX ztj ¡ W n tk
|
rd Y n
|
X tdt
|
¡ }| |j | |||¡ | ¡ ¡ S )zÉHelper function for from_thread.run and from_thread.run_sync.
|
|
Since this internally uses TrioToken.run_sync_soon, all warnings about
|
raised exceptions canceling all tasks should be noted.
|
z0Passed kwarg trio_token is not of type TrioTokenz=this thread wasn't created by Trio, pass kwarg trio_token=...z2this is a blocking function; call it from a thread)Ú
|
isinstancer Ú RuntimeErrorr0 r1 ÚAttributeErrorr* r+ rD Ú stdlib_queueÚ SimpleQueuer> rK r r$ )ÚcbÚfnrL rN r: Úqr r r Ú_run_fn_as_system_taskÚ s"
|
ÿ
|
rW c G s6 dd }t ¡ }| tjd¡ t|| f|||dS )aþ Run the given async function in the parent Trio thread, blocking until it
|
is complete.
|
|
Returns:
|
Whatever ``afn(*args)`` returns.
|
|
Returns or raises whatever the given function returns or raises. It
|
can also raise exceptions of its own:
|
|
Raises:
|
RunFinishedError: if the corresponding call to :func:`trio.run` has
|
already completed, or if the run has started its final cleanup phase
|
and can no longer spawn new system tasks.
|
Cancelled: if the corresponding call to :func:`trio.run` completes
|
while ``afn(*args)`` is running, then ``afn`` is likely to raise
|
:exc:`trio.Cancelled`, and this will propagate out into
|
RuntimeError: if you try calling this from inside the Trio thread,
|
which would otherwise cause a deadlock.
|
AttributeError: if no ``trio_token`` was provided, and we can't infer
|
one from context.
|
TypeError: if ``afn`` is not an asynchronous function.
|
|
**Locating a Trio Token**: There are two ways to specify which
|
`trio.run` loop to reenter:
|
|
- Spawn this thread from `trio.to_thread.run_sync`. Trio will
|
automatically capture the relevant Trio token and use it when you
|
want to re-enter Trio.
|
- Pass a keyword argument, ``trio_token`` specifying a specific
|
`trio.run` loop to re-enter. This is useful in case you have a
|
"foreign" thread, spawned using some other framework, and still want
|
to enter Trio.
|
c
|
sn t fddfdd}t ¡ }ztjj| |d W n* tk
|
rh t t
|
d¡¡¡ Y nX d S )Nc s t f } | I d H S r" r )Úcoro)Úafnr: r r Úunprotected_afn s z:from_thread_run.<locals>.callback.<locals>.unprotected_afnc s t ¡I d H ¡ d S r" )Ú
|
put_nowaitr( Zacapturer )rV rZ r r Úawait_in_trio_thread_task" s zDfrom_thread_run.<locals>.callback.<locals>.await_in_trio_thread_task)r rL zsystem nursery is closed) r rG rH r* r+ Zspawn_system_taskrP r[ r( ÚErrorr? )rV rY r: r\ rL r )rY r: rV rZ r Úcallback s ÿ
|
ÿz!from_thread_run.<locals>.callbackr* ©rL rN )rG rH rK r r rW )rY rN r: r^ rL r r r Úfrom_thread_runù s #þýûr` c G s( dd }t ¡ }t|| f|||dS )a¦ Run the given sync function in the parent Trio thread, blocking until it
|
is complete.
|
|
Returns:
|
Whatever ``fn(*args)`` returns.
|
|
Returns or raises whatever the given function returns or raises. It
|
can also raise exceptions of its own:
|
|
Raises:
|
RunFinishedError: if the corresponding call to `trio.run` has
|
already completed.
|
RuntimeError: if you try calling this from inside the Trio thread,
|
which would otherwise cause a deadlock.
|
AttributeError: if no ``trio_token`` was provided, and we can't infer
|
one from context.
|
TypeError: if ``fn`` is an async function.
|
|
**Locating a Trio Token**: There are two ways to specify which
|
`trio.run` loop to reenter:
|
|
- Spawn this thread from `trio.to_thread.run_sync`. Trio will
|
automatically capture the relevant Trio token and use it when you
|
want to re-enter Trio.
|
- Pass a keyword argument, ``trio_token`` specifying a specific
|
`trio.run` loop to re-enter. This is useful in case you have a
|
"foreign" thread, spawned using some other framework, and still want
|
to enter Trio.
|
c s4 t d¡ t fdd}t |¡}| |¡ d S )Nr* c s4 } t | ¡r0| ¡ td td¡| S r/ )r2 r3 r4 r5 r6 r7 r8 ©r: rU r r Úunprotected_fn\ s
|
|
ÿÿz>from_thread_run_sync.<locals>.callback.<locals>.unprotected_fn)r r r r( r) r[ )rV rU r: rb Úresr ra r r^ Y s
|
|
|
z&from_thread_run_sync.<locals>.callbackr_ )rG rH rW )rU rN r: r^ rL r r r Úfrom_thread_run_sync: s þýûrd )#rG Ú threadingÚqueuerR rI Ú itertoolsr r r2 r( Zsniffior r* Z_syncr Z_corer r r r r
|
Z_utilr Úlocalr0 r r rF r Úsr rM rW r` rd r r r r Ú<module> s2 A
|
