← back to Atmos Game
assets/gen/.venv/lib/python3.12/site-packages/anyio/_core/__pycache__/_tasks.cpython-312.pyc
207 lines
�
c�bjF3 � � � d dl mZ d dlZd dlZd dlmZmZ d dlmZ d dl m
Z
m Z d dl m
Z
d dlmZ d dlmZmZmZ d d
lmZmZ d d lmZmZ d d
lmZm Z m Z ej< dk\ rd dlm Z nd dl m Z ej< dk\ r d dlm!Z!m"Z" nd dl m!Z!m"Z" e d� Z# e dd�� Z$ e dde!�� Z% e"d� Z& G d� dee' � Z( e(� Z) G d� d � Z*e d# d$d �� Z+d#d%d �Z,d&d �Z-d'd �Z.e G d!� d"ee$e%f � � Z/y)(� )� annotationsN)� Coroutine� Generator)�contextmanager)�Enum�auto)� iscoroutine)�
TracebackType)�Any�Generic�final� )� TaskGroup�
TaskStatus� )�get_async_backend�get_cancelled_exc_class)�
TaskCancelled�
TaskFailed�TaskNotFinished)� �
)�TypeVar)r � )�Never� TypeVarTuple�T�T_coT)� covariant�
T_startval)r �default�PosArgsTc � � e Zd Zddd�Zy)�_IgnoredTaskStatusNc � � y �N� ��self�values �i/Users/macstudio3/Projects/atmos-game/assets/gen/.venv/lib/python3.12/site-packages/anyio/_core/_tasks.py�startedz_IgnoredTaskStatus.started& s � � � r& )r* �object�return�None)�__name__�
__module__� __qualname__r, r' r- r+ r$ r$ % s � �
r- r$ c � � e Zd ZdZdZej dd� dd�Zddd�Ze dd�� Z
e
j dd �� Z
e dd
�� Z e dd �� Z
e dd �� Zej dd
�� Zdd�Z dd�Zy)� CancelScopea`
Wraps a unit of work that can be made separately cancellable.
:param deadline: The time (clock value) when this scope is cancelled automatically
:param shield: ``True`` to shield the cancel scope from external cancellation
:raises NoEventLoopError: if no supported asynchronous event loop is running in the
current thread
)� __weakref__F��deadline�shieldc �8 � t � j ||�� S )N)r9 r8 )r �create_cancel_scope)�clsr8 r9 s r+ �__new__zCancelScope.__new__9 s � � !�"�6�6�f�x�6�X�Xr- Nc � � t �)z~
Cancel this scope immediately.
:param reason: a message describing the reason for the cancellation
��NotImplementedError)r) �reasons r+ �cancelzCancelScope.cancel> s
� � "�!r- c � � t �)z�
The time (clock value) when this scope is cancelled automatically.
Will be ``float('inf')`` if no timeout has been set.
r? �r) s r+ r8 zCancelScope.deadlineG �
� � "�!r- c � � t �r& r? r( s r+ r8 zCancelScope.deadlineQ � � �!�!r- c � � t �)z+``True`` if :meth:`cancel` has been called.r? rD s r+ �
cancel_calledzCancelScope.cancel_calledU s
� � "�!r- c � � t �)a
``True`` if this scope suppressed a cancellation exception it itself raised.
This is typically used to check if any work was interrupted, or to see if the
scope was cancelled due to its deadline being reached. The value will, however,
only be ``True`` if the cancellation was triggered by the scope itself (and not
an outer scope).
r? rD s r+ �cancelled_caughtz CancelScope.cancelled_caughtZ s
� � "�!r- c � � t �)z�
``True`` if this scope is shielded from external cancellation.
While a scope is shielded, it will not receive cancellations from outside.
r? rD s r+ r9 zCancelScope.shieldg rE r- c � � t �r& r? r( s r+ r9 zCancelScope.shieldq rG r- c � � t �r& r? rD s r+ � __enter__zCancelScope.__enter__u s � �!�!r- c � � t �r& r? )r) �exc_type�exc_val�exc_tbs r+ �__exit__zCancelScope.__exit__x s
� � "�!r- )r8 �floatr9 �boolr/ r5 r& )rA z
str | Noner/ r0 �r/ rU )r* rU r/ r0 )r/ rV )r* rV r/ r0 )r/ r5 )rQ ztype[BaseException] | NonerR �BaseException | NonerS zTracebackType | Noner/ rV )r1 r2 r3 �__doc__� __slots__�math�infr= rB �propertyr8 �setterrI rK r9 rO rT r' r- r+ r5 r5 - s� � �� !�I� #'�(�(�5�Y� �Y�48�Y� �Y�
"� �"� �"� �_�_�"� �"� �"� �"� �
"� �
"� �"� �"� �]�]�"� �"�"�"�,�"� &�"� %� "�
� "r- r5 c # �" K � t � j }| �
|� | z nt j }t � j ||�� 5 }|�� ddd� j
r |� |j k\ rt �yy# 1 sw Y �1xY w�w)a,
Create a context manager which raises a :class:`TimeoutError` if does not finish in
time.
:param delay: maximum allowed time (in seconds) before raising the exception, or
``None`` to disable the timeout
:param shield: ``True`` to shield the cancel scope from external cancellation
:return: a context manager that yields a cancel scope
:rtype: :class:`~typing.ContextManager`\[:class:`~anyio.CancelScope`\]
:raises NoEventLoopError: if no supported asynchronous event loop is running in the
current thread
Nr7 )r � current_timer[ r\ r; rK r8 � TimeoutError)�delayr9 r` r8 � cancel_scopes r+ �
fail_afterrd � s� � �� �" %�&�3�3�L�+0�+<� ���&�$�(�(�H� � � 0� 0��&�
1�
� ���
�
�$�$� � �<�;P�;P�)P��� *Q�$�
�
�s �A B�B�0B�B �Bc � � | �t � j � | z nt j }t � j ||�� S )a�
Create a cancel scope with a deadline that expires after the given delay.
:param delay: maximum allowed time (in seconds) before exiting the context block, or
``None`` to disable the timeout
:param shield: ``True`` to shield the cancel scope from external cancellation
:return: a cancel scope
:raises NoEventLoopError: if no supported asynchronous event loop is running in the
current thread
r7 )r r` r[ r\ r; )rb r9 r8 s r+ �
move_on_afterrf � sD � � 9>�8I� � � )� )� +�e� 3�t�x�x�
� � � 2� 2�H�V� 2� T�Tr- c �2 � t � j � S )a�
Return the nearest deadline among all the cancel scopes effective for the current
task.
:return: a clock value from the event loop's internal clock (or ``float('inf')`` if
there is no deadline in effect, or ``float('-inf')`` if the current scope has
been cancelled)
:rtype: float
:raises NoEventLoopError: if no supported asynchronous event loop is running in the
current thread
)r �current_effective_deadliner' r- r+ rh rh � s � � � � 9� 9� ;�;r- c �2 � t � j � S )z�
Create a task group.
:return: a task group
:raises NoEventLoopError: if no supported asynchronous event loop is running in the
current thread
)r �create_task_groupr' r- r+ rj rj � s � � � � 0� 0� 2�2r- c �� � e Zd ZU dZ G d� de� ZdZded< ded< dd �Zdd
�Z dd �Z
e dd �� Z e dd
�� Z
e dd�� Ze dd�� Ze d d�� Ze d d�� Zdd�Zd d�Zdd�Zy) �
TaskHandlea\
Returned from the task-spawning methods of :class:`TaskGroup`. Can be awaited on to
get the return value of the task (or the raised exception). If the task was
terminated by a :exc:`BaseException`, :exc:`TaskFailed` will be raised (or its
subclass :exc:`TaskCancelled` if the task was cancelled).
.. versionadded:: 4.14.0
c �V � e Zd ZdZ e� Z e� Z e� Z e� Z e� Z y)�TaskHandle.Statusa�
The status of a task handle.
.. attribute:: PENDING
The task has not finished yet.
.. attribute:: FINISHED
The task has finished with a return value.
.. attribute:: CANCELLING
The task has been cancelled but has not finished yet.
.. attribute:: CANCELLED
The task was cancelled and has finished since.
.. attribute:: FAILED
The task raised an exception.
N)
r1 r2 r3 rY r �PENDING�FINISHED�
CANCELLING� CANCELLED�FAILEDr' r- r+ �Statusrn � s, � � �( �&���6���V�
��F� ���r- rt )r6 �_coro�_name�
_cancel_scope�_finished_event�
_return_value� _start_value�
_exceptionr ry r rz c �� � ddl m} || _ t � | _ |� | _ d | _ |�t |� | _ y t |� r|j | _ y t |� | _ y )Nr )�Event) �_synchronizationr} ru r5 rw rx r{ �strrv r r3 )r) �coro�namer} s r+ �__init__zTaskHandle.__init__� sX � �+���
� (�]��� $�w�� �04��� � � �T��D�J�
��
� �*�*�D�J� �T��D�Jr- c � �: K � d}| j 5 | j � d { ��� }|| _ | j
j
� ~ d d d � y 7 �1# t $ r
}|| _ � d }~ww xY w# | j
j
� ~ w xY w# 1 sw Y y xY w�w)NT)rw ru ry �
BaseExceptionr{ rx �set)r) �__tracebackhide__�retval�excs r+ � _run_corozTaskHandle._run_coro s� � �� � ��
�
�
�
� #�z�z�)��
&,��"��$�$�(�(�*�� �
�)�� �
�"%�����
�� �$�$�(�(�*��� �
�s_ �B�B�A�A�A�A/�B� B�A� A,� A'�'A,�,A/�/ B � B�B�Bc �n � | j j � s| j j � yy)aF
Set the task to a cancelled state.
This will interrupt any interruptible asynchronous operation, and will cause
any further awaits on this task to get immediately cancelled, unless done in
a shielded cancel scope.
If the task has already finished, this method has no effect.
N)rx �is_setrw rB rD s r+ rB zTaskHandle.cancel s- � � �#�#�*�*�,� � � � %� %� '� -r- c � � | j S )zy
The coroutine object that was passed to one of the task-spawning methods in
:class:`TaskGroup`.
)ru rD s r+ r� zTaskHandle.coro* s � � �z�z�r- c � � | j j � sJ| j j rt j
j S t j
j S | j �Rt | j t � � rt j
j S t j
j S t j
j S )a=
The current status of the task.
Every task starts in the :attr:`~TaskHandle.Status.PENDING` state.
If a task is cancelled while in this state, it will transition to the
:attr:`~TaskHandle.Status.CANCELLING` state. When the task finishes, it will
transition to one of the three final states (
:attr:`~TaskHandle.Status.FINISHED`, :attr:`~TaskHandle.Status.FAILED`, or
:attr:`~TaskHandle.Status.CANCELLING`) depending on the exception the task
raised, if any. No other status transitions will happen.
)rx r� rw rI rl rt rq ro r{ �
isinstancer rr rs rp rD s r+ �statuszTaskHandle.status2 s� � � �#�#�*�*�,��!�!�/�/�!�(�(�3�3�3�!�(�(�0�0�0�
�_�_�
(��$�/�/�+B�+D�E�!�(�(�2�2�2�!�(�(�/�/�/� �$�$�-�-� -r- c � � | j S )zThe name of the task.)rv rD s r+ r� zTaskHandle.nameL s � � �z�z�r- c � � | j xt j j k( r t d� �xt j j
k( r yxt j j k( r t d� �xt j j k( r t d� | j �t j j k( r | j S y)z�
The exception raised by the task, or ``None`` if it finished without raising.
:raises TaskNotFinished: if the task has not finished yet
:raises TaskCancelled: if the task was cancelled
� the task has not finished yetN�the task was cancelled) r� rl rt ro r rp rq r rr r{ rs rD s r+ � exceptionzTaskHandle.exceptionQ s� � � �k�k�*��"�"�*�*�%�&E�F�F�+��"�"�+�+��-��"�"�-�-�#�$<�=�=�,��"�"�,�,�#�$<�=�4�?�?�R��"�"�)�)����&� *r- c �� � | j xt j j k( r t d� �xt j j
k( r
| j S xt j j k( r t d� �xt j j k( r t d� | j �t j j k( rt d� | j �y)z�
The return value of the task.
:raises TaskNotFinished: if the task has not finished yet
:raises TaskCancelled: if the task was cancelled
:raises TaskFailed: if the task raised an exception
r� r� z the task raised an exceptionN)
r� rl rt ro r rp ry rq r rr r{ rs r rD s r+ � return_valuezTaskHandle.return_valuef s� � � �k�k�*��"�"�*�*�%�&E�F�F�+��"�"�+�+��)�)�)�-��"�"�-�-�#�$<�=�=�,��"�"�,�,�#�$<�=�4�?�?�R��"�"�)�)� �!?�@�d�o�o�U� *r- c �N � | j S # t $ r
t d� d�w xY w)z�
The value passed to :meth:`task_status.started() <.abc.TaskStatus.started>`,
:raises RuntimeError: if the task was not started with :meth:`TaskGroup.start()
<.abc.TaskGroup.start>`
z/the task was not started with TaskGroup.start()N)rz �AttributeError� RuntimeErrorrD s r+ � start_valuezTaskHandle.start_value| s5 � � ��$�$� $�� � � �A���
� �s � �$c � �T K � | j j � � d{ ��� y7 ��w)z�
Wait for the task to finish.
This method will return as soon as the task has finished, no matter how it
happened.
N)rx �waitrD s r+ r� zTaskHandle.wait� s � �� � �"�"�'�'�)�)�)�s � (�&�(c # � K � | j j � j � E d { ��� | j S 7 ��wr& )rx r� � __await__r� rD s r+ r� zTaskHandle.__await__� s8 � �� ��'�'�,�,�.�8�8�:�:�:�� � � � ;�s �,A�?�Ac � � d| j j � d| j j j � � d| j
�d| j �d� S )N�<� z name=z coro=�>)� __class__r1 r� r� �lowerrv ru rD s r+ �__repr__zTaskHandle.__repr__� sS � �����'�'�(��$�+�+�*:�*:�*@�*@�*B�)C� D��J�J�>���
�
�~�Q�
8�
r- N)r� �Coroutine[Any, Any, T_co]r� r. r/ r0 )r/ r0 )r/ r� )r/ rn )r/ r )r/ rX )r/ r )r/ r )r/ zGenerator[Any, Any, T_co])r1 r2 r3 rY r rt rZ �__annotations__r� r� rB r] r� r� r� r� r� r� r� r� r� r' r- r+ rl rl � s� � ���� �6 �I� �� � �
#�
� (� �� �� �.� �.�2 �� �� �'� �'�( �V� �V�* � � � � *�!�
r- rl )F)rb � float | Noner9 rV r/ z"Generator[CancelScope, None, None])rb r� r9 rV r/ r5 rW )r/ r )0�
__future__r r[ �sys�collections.abcr r �
contextlibr �enumr r �inspectr �typesr
�typingr r r
�abcr r �
_eventloopr r � _exceptionsr r r � version_infor �typing_extensionsr r r r r r" r. r$ �TASK_STATUS_IGNOREDr5 rd rf rh rj rl r' r- r+ �<module>r� s �� "� �
��� � � � &� &� '� B� C� C����w� � �)����w� �*�*�5� �C�L���v��&��
�\�T�5�
A�
� �
� #��
��F�+�
�
)�*� �Q"� Q"�h �(-�� ��!%��'�� ��6U�$
<� 3� �P
���z�)�*� P
� �P
r-