← back to Atmos Game

assets/gen/.venv/lib/python3.12/site-packages/anyio/__pycache__/to_interpreter.cpython-312.pyc

79 lines

�

c�bj���p�UddlmZdZddlZddlZddlZddlmZddlm	Z	ddl
mZmZm
Z
ddlmZmZdd	lmZdd
lmZddlmZej.dk\r	dd
l
mZmZndd
lmZmZej.dk\rddlmZmZ						d+d�ZGd�d�Zn]ej.dk\rDddl Z ddl!Z!dZ"de#d<dZ$de#d<dZ%de#d<e%e"fZ&de#d<e$e"fZ'de#d<e(ddd�Z)Gd�d�Zn
Gd�d�Zd Z*de#d!<d"Z+e
d#�Z,ed$�Z-eeed%�Z.eed&�Z/d,d'�Z0dd(�							d-d)�Z1d.d*�Z2y)/�)�annotations)�run_sync�#current_default_interpreter_limiterN)�deque)�Callable)�Any�Final�TypeVar�)�current_time�	to_thread)�BrokenWorkerInterpreter)�CapacityLimiter)�RunVar)��)�TypeVarTuple�Unpack)r�)�ExecutionFailed�createc�J�	||�}|dfS#t$r}|dfcYd}~Sd}~wwxYw)NFT)�
BaseException)�func�args�retval�excs    �k/Users/macstudio3/Projects/atmos-game/assets/gen/.venv/lib/python3.12/site-packages/anyio/to_interpreter.py�_interp_callrs8��	!��4�[�F��5�=� ���	���9���	�s��	"��"�"c�@�eZdZUdZded<dd�Zdd�Z						d	d�Zy)
�_Workerr�float�	last_usedc�"�t�|_y�N)r�_interpreter��selfs r�__init__z_Worker.__init__)s�� &��D��c�8�|jj�yr%)r&�closer's r�destroyz_Worker.destroy,s�����#�#�%r*c��	|jjt||�\}}|r|�|S#t$r}t	|j
�|�d}~wwxYwr%)r&�callrrr�excinfo)r(rr�res�is_exceptionrs      rr/z_Worker.call/s[��

D�$(�$5�$5�$:�$:�<��t�$T�!��\���	��J��
#�
D�-�c�k�k�:��C��
D�s�$,�	A�A�AN��return�None�rzCallable[..., T_Retval]r�tuple[Any, ...]r4�T_Retval��__name__�
__module__�__qualname__r#�__annotations__r)r-r/�r*rr!r!&s7���	�5��	)�	&�
	�)�
	�"�
	��	
	r*r!)r�
�r	�UNBOUND�
FMT_UNPICKLED�FMT_PICKLED�QUEUE_PICKLE_ARGS�QUEUE_UNPICKLE_ARGSa_
import _interpqueues
from _interpreters import NotShareableError
from pickle import loads, dumps, HIGHEST_PROTOCOL

QUEUE_PICKLE_ARGS = (1, 2)
QUEUE_UNPICKLE_ARGS = (0, 2)

item = _interpqueues.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:
    _interpqueues.put(queue_id, (retval, is_exception), *QUEUE_UNPICKLE_ARGS)
except NotShareableError:
    retval = dumps(retval, HIGHEST_PROTOCOL)
    _interpqueues.put(queue_id, (retval, is_exception), *QUEUE_PICKLE_ARGS)
    z<string>�execc�@�eZdZUdZded<dd�Zdd�Z						d	d�Zy)
r!rr"r#c���tj�|_tjdgt���|_tj|jd|j
i�y)Nr�queue_id)�
_interpretersr�_interpreter_id�
_interpqueuesrE�	_queue_id�set___main___attrsr's rr)z_Worker.__init__gsM��#0�#7�#7�#9�D� �*�1�1�!�J�6I�J�D�N��,�,��$�$�z�4�>�>�&B�
r*c��tj|j�tj|j�yr%)rLr-rMrJrKr's rr-z_Worker.destroyns(���!�!�$�.�.�1��!�!�$�"6�"6�7r*c��ddl}|j||f|j�}tj|j
|gt���tj|jt�}|rt|��tj|j
�}|dd\\}}}|tk(r|j|�}|r|�|S)Nrr@)�pickle�dumps�HIGHEST_PROTOCOLrL�putrMrDrJrFrK�	_run_funcr�getrC�loads)	r(rrrQ�item�exc_infor1r2�fmts	         rr/z_Worker.callrs���

��<�<��t��f�.E�.E�F�D����d�n�n�d�G�5F�G�$�)�)�$�*>�*>�	�J�H��-�h�7�7��#�#�D�N�N�3�C�'*�2�A�w�$��S�,���k�!��l�l�3�'����	��Jr*Nr3r6r9r>r*rr!r!ds7���	�5��	�	8�	�)�	�"�	��		r*c�@�eZdZUdZded<dd�Z						d	d�Zdd�Zy)
r!rr"r#c��td��)Nz,subinterpreters require at least Python 3.13)�RuntimeErrorr's rr)z_Worker.__init__�s���M�N�Nr*c��t�r%)�NotImplementedError)r(rrs   rr/z_Worker.call�s
��
&�%r*c��yr%r>r's rr-z_Worker.destroy�s��r*Nr3r6)r:r;r<r#r=r)r/r-r>r*rr!r!�s8���	�5��	O�	&�)�	&�"�	&��		&�	r*��DEFAULT_CPU_COUNT�r8�PosArgsT�_available_workers�_default_interpreter_limiterc�R�|D]}|j��|j�yr%)r-�clear)�workers�workers  r�
_stop_workersrk�s!����������M�M�Or*��limiterc��K�|�
t�}	tj�}|4�d{���	|j�}ddd��d{���	tjj|||���d{���t�}|rT||dj z
t"krn:tj|j%�j&|���d{���|r�Tt�|_|j)|�S#t$r=t	�}tj|�t
jt|�Y��wxYw7��#t$rt�}Y��wxYw7��#1�d{���7swY��(xYw7��7��#t�}|rU||dj z
t"krn;tj|j%�j&|���d{���7|r�Ut�_|j)|�wxYw�w)a�
    Call the given function with the given arguments in a subinterpreter.

    .. warning:: On Python 3.13, the :mod:`concurrent.interpreters` module was not yet
        available, so the code path for that Python version relies on an undocumented,
        private API. As such, it is recommended to not rely on this function for anything
        mission-critical on Python 3.13.

    :param func: a callable
    :param args: the positional arguments for the callable
    :param limiter: capacity limiter to use to limit the total number of subinterpreters
        running (if omitted, the default limiter is used)
    :return: the result of the call
    :raises BrokenWorkerInterpreter: if there's an internal error in a subinterpreter

    Nrlr)r�
_idle_workersrV�LookupErrorr�set�atexit�registerrk�pop�
IndexErrorr!r
rr/rr#�MAX_WORKER_IDLE_TIME�popleftr-�append)rrmr�idle_workersrj�nows      rrr�s�����*��5�7��5�$�(�(�*���w�	�!�%�%�'�F��w�$��'�'��K�K����	
�
��n����\�!�_�.�.�.�2F�F���$�$�\�%9�%9�%;�%C�%C�W�U�U�U�	�(�>������F�#��9�5��w�����,�'����
�|�4�5��
���	��Y�F�	����w�w�w��
��
V���n����\�!�_�.�.�.�2F�F���$�$�\�%9�%9�%;�%C�%C�W�U�U�U�	�(�>������F�#�s��
H�C<�H�E�H�E%�E�H�E"�H�&F�7E;�8F�;AH�E>�H�!H�<AE�>H�E�H�E�E%�E�E%�"H�%E8�+E.�,E8�3H�;F�>H�AH�G�H�"!H�Hc���	tj�S#t$r?tt	j
�xst�}tj|�|cYSwxYw)z�
    Return the capacity limiter used by default to limit the number of concurrently
    running subinterpreters.

    Defaults to the number of CPU cores.

    :return: a capacity limiter object

    )rfrVrpr�os�	cpu_countrbrqrls rrr�sN���+�/�/�1�1����!�"�,�,�.�"E�4E�F��$�(�(��1����s��AA�A)rzCallable[..., Any]rr7r4ztuple[Any, bool])rizdeque[_Worker]r4r5)rz&Callable[[Unpack[PosArgsT]], T_Retval]rzUnpack[PosArgsT]rmzCapacityLimiter | Noner4r8)r4r)3�
__future__r�__all__rrr|�sys�collectionsr�collections.abcr�typingrr	r
�rr
�_core._exceptionsr�_core._synchronizationr�lowlevelr�version_inforr�typing_extensions�concurrent.interpretersrrrr!rLrJrAr=rBrCrDrE�compilerUrbrvr8rdrorfrkrrr>r*r�<module>r�s���"���
�	�
��$�&�&�%�6�3�����w��+�+�6����w��?�!� �!�(7�!�	�!���.	���� ����G�U���M�5���K��� +�W�5��u�5�"/��!9���9��	�0	��5�I�:#�#�L��"��5�����:����
�#��&��u�W�~�&�';�<�
�6�v�o�6�7U�V���'+�6$�
0�6$��6$�$�6$��	6$�rr*