File: //usr/local/lib/python3.10/dist-packages/anyio/__pycache__/to_interpreter.cpython-310.pyc
o
���g� � @ s\ U d dl mZ d dlZd dlZd dlZd dlZd dlmZ d dlm Z d dl
m Z d dl m
Z
mZmZ ddlmZmZ dd lmZ dd
lmZ dd lmZ ejd kr[d d
l mZmZ nd d
l mZmZ dZ de d< d Z de d< dZ de d< dZ!de d< dZ"ed�Z#ed�Z$eed d�Z%ee d�Z&G dd� d�Z'd.d d!�Z(dd"�d/d)d*�Z)d0d,d-�Z*dS )1� )� annotationsN)�deque)�Callable)�dedent)�Any�Final�TypeVar� )� current_time� to_thread)�BrokenWorkerIntepreter)�CapacityLimiter)�RunVar)� � )� TypeVarTuple�Unpack� r �UNBOUND�
FMT_UNPICKLED� FMT_PICKLED� �DEFAULT_CPU_COUNT� �T_Retval�PosArgsT�Worker�_available_workers� _default_interpreter_limiterc @ sn e Zd ZU eed�dd�ZdZded< dZded < d
ed < d
ed < d dd�Z d dd�Z
d!dd�Z d"d d �Z d S )#r a�
import _interpqueues as queues
import _interpreters as interpreters
from pickle import loads, dumps, HIGHEST_PROTOCOL
item = queues.get(queue_id)[0]
try:
func, args = loads(item)
retval = func(*args)
except BaseException as exc:
is_exception = True
retval = exc
else:
is_exception = False
try:
queues.put(queue_id, (retval, is_exception), FMT_UNPICKLED, UNBOUND)
except interpreters.NotShareableError:
retval = dumps(retval, HIGHEST_PROTOCOL)
queues.put(queue_id, (retval, is_exception), FMT_PICKLED, UNBOUND)
z<string>�execr �float� last_usedF�bool� _initialized�int�_interpreter_id� _queue_id�return�Nonec C sN dd l }dd l}|�� | _|�dtt�| _d| _|�| j| jt ttd�� d S )Nr r T)�queue_idr r r )
�
_interpqueues�
_interpreters�creater% r r r& r# �set___main___attrsr ��self�queues� interpreters� r2 �?/usr/local/lib/python3.10/dist-packages/anyio/to_interpreter.py�
initializeF s
��zWorker.initializec C s6 dd l }dd l}| jr|�| j� |�| j� d S d S )Nr )r* r+ r# �destroyr% r& r. r2 r2 r3 r5 W s �zWorker.destroy�func�Callable[..., T_Retval]�args�
tuple[Any]�tuple[Any, bool]c
C s� dd l }dd l}| js| �� t�||ftj�}|�| j|t t
� |� | j | j
� }r/t|��|�| j�d d� \\}}} | t krFt�|�}||fS )Nr r )r* r+ r# r4 �pickle�dumps�HIGHEST_PROTOCOL�putr& r r r r% � _run_funcr �get�loads)
r/ r6 r8 r0 r1 �payload�exc_info�res� is_exception�fmtr2 r2 r3 �_call_ s
z Worker._call�limiterr
r c � s, �t j| j|||d�I d H \}}|r|�|S )N�rH )r �run_syncrG )r/ r6 r8 rH �resultrE r2 r2 r3 �callx s ��z Worker.callN)r' r( )r6 r7 r8 r9 r' r: )r6 r7 r8 r9 rH r
r' r )
�__name__�
__module__� __qualname__�compiler r? r! �__annotations__r# r4 r5 rG rL r2 r2 r2 r3 r % s
�
�workers�
deque[Worker]r' r( c C s | D ]}|� � q| �� d S )N)r5 �clear)rR �workerr2 r2 r3 �
_stop_workers� s
rV rI r6 �&Callable[[Unpack[PosArgsT]], T_Retval]r8 �Unpack[PosArgsT]rH �CapacityLimiter | Nonec
� sr �t jdkr
td��|du rt� }zt�� }W n ty. t� }t�|� t �
t |� Y nw |4 I dH � z|� � }W n t
yH t� }Y nw W d �I dH n 1 I dH sYw Y z2|�| ||�I dH W t� }|r�||d j tkrxntj|�� j|d�I dH |snt� |_|�|� S t� }|r�||d j tkr�ntj|�� j|d�I dH |s�t� |_|�|� w )aF
Call the given function with the given arguments in a subinterpreter.
If the ``cancellable`` option is enabled and the task waiting for its completion is
cancelled, the call will still run its course but its return value (or any raised
exception) will be ignored.
.. warning:: This feature is **experimental**. The upstream interpreter API has not
yet been finalized or thoroughly tested, so don't rely on this for anything
mission critical.
:param func: a callable
:param args: positional arguments for the callable
:param limiter: capacity limiter to use to limit the total amount of subinterpreters
running (if omitted, the default limiter is used)
:return: the result of the call
:raises BrokenWorkerIntepreter: if there's an internal error in a subinterpreter
)r �
z,subinterpreters require at least Python 3.13Nr rI )�sys� version_info� RuntimeError�#current_default_interpreter_limiter�
_idle_workersr@ � LookupErrorr �set�atexit�registerrV �pop�
IndexErrorr rL r
r! �MAX_WORKER_IDLE_TIMEr rJ �popleftr5 �append)r6 rH r8 � idle_workersrU �nowr2 r2 r3 rJ � sL �
�
��(�� �� rJ r
c C s< zt �� W S ty tt�� pt�} t �| � | Y S w )z�
Return the capacity limiter that is used by default to limit the number of
concurrently running subinterpreters.
Defaults to the number of CPU cores.
:return: a capacity limiter object
)r r@ r` r
�os� cpu_countr ra rI r2 r2 r3 r^ � s
�r^ )rR rS r' r( )r6 rW r8 rX rH rY r' r )r' r
)+�
__future__r rb rk r; r[ � collectionsr �collections.abcr �textwrapr �typingr r r � r
r �_core._exceptionsr �_core._synchronizationr
�lowlevelr r\ r r �typing_extensionsr rQ r r r rf r r r_ r r rV rJ r^ r2 r2 r2 r3 �<module> s>
�
e
�: