← back to Atmos Game

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

114 lines

�

c�bj.����UddlmZdZddlZddlmZddlmZmZm	Z	m
Z
mZmZddlm
Z
ddlmZddlmZmZmZmZmZmZmZmZmZdd	lmZd
dlmZd
dlmZd
d
l m!Z!m"Z"ed�Z#ed�Z$ed�Z%e!d�Z&de'd<Gd�d�Z(e(�Z)de'd<Gd�de�Z*Gd�de�Z+Gd�dee#�Z,eGd�dee%e#f��Z-Gd�d�Z.e				d.d ��Z/ed/d!��Z/d0d"�Z/ed#d#d#d#d$�									d1d%��Z0e				d.d&��Z0ed/d'��Z0	d2d(d)d)dd$�											d3d*�Z0e								d4d+��Z1e						d5d,��Z1e)f							d6d-�Z1y)7�)�annotations)�AsyncCacheInfo�AsyncCacheParameters�AsyncLRUCacheWrapper�cache�	lru_cache�reduceN)�OrderedDict)�
AsyncIterable�	Awaitable�Callable�	Coroutine�Hashable�Iterable)�update_wrapper)�iscoroutinefunction)	�Any�Generic�
NamedTuple�	ParamSpec�	TypedDict�TypeVar�cast�final�overload)�WeakKeyDictionary�)�current_time)�Lock)�RunVar�
checkpoint�T�S�P�lru_cache_itemsz�RunVar[WeakKeyDictionary[AsyncLRUCacheWrapper[Any, Any], OrderedDict[Hashable, tuple[_InitialMissingType, Lock, float | None] | tuple[Any, None, float | None]]]]c��eZdZy)�_InitialMissingTypeN)�__name__�
__module__�__qualname__���f/Users/macstudio3/Projects/atmos-game/assets/gen/.venv/lib/python3.12/site-packages/anyio/functools.pyr'r'8s��r,r'�initial_missingc�@�eZdZUded<ded<ded<ded<ded<y)	r�int�hits�misses�
int | None�maxsize�currsize�ttlN�r(r)r*�__annotations__r+r,r-rr?s��

�I��K�
���M�	�Or,rc�6�eZdZUded<ded<ded<ded<y)rr3r4�bool�typed�always_checkpointr6Nr7r+r,r-rrGs��
���K���	�Or,rc�4�eZdZdd�Zdd�Zd	d�Zd
d�Zdd�Zy)�_LRUMethodWrapperc� �||_||_y�N)�_LRUMethodWrapper__wrapper�_LRUMethodWrapper__instance)�self�wrapper�instances   r-�__init__z_LRUMethodWrapper.__init__Os�� ���"��r,c�6�|jj�Sr@)rA�
cache_info�rCs r-rHz_LRUMethodWrapper.cache_infoSs���~�~�(�(�*�*r,c�6�|jj�Sr@)rA�cache_parametersrIs r-rKz"_LRUMethodWrapper.cache_parametersVs���~�~�.�.�0�0r,c�8�|jj�yr@)rA�cache_clearrIs r-rMz_LRUMethodWrapper.cache_clearYs�����"�"�$r,c��K�|j�|j|i|���d{���S|j|jg|��i|���d{���S7�,7��wr@)rBrA)rC�args�kwargss   r-�__call__z_LRUMethodWrapper.__call__\sT�����?�?�"�'�����8��8�8�8�#�T�^�^�D�O�O�E�d�E�f�E�E�E�9��E�s!�"A�A�'A�A�
A�AN)rDzAsyncLRUCacheWrapper[..., T]rE�object��returnr�rTr�rT�None)rOrrPrrTr")r(r)r*rFrHrKrMrQr+r,r-r>r>Ns��#�+�1�%�Fr,r>c�^�eZdZ										dd�Zd	d�Zd
d�Zdd�Zdd�Z	d
					dd�Zy)rc��||_d|_d|_|�t|d�nd|_d|_||_||_||_t||�y�Nr)
�__wrapped__�_hits�_misses�max�_maxsize�	_currsize�_typed�_always_checkpoint�_ttlr)rC�funcr4r;r<r6s      r-rFzAsyncLRUCacheWrapper.__init__esU�� �����
����+2�+>��G�Q��D��
�������"3�����	��t�T�"r,c��t|j|j|j|j|j
�Sr@)rr\r]r_r`rcrIs r-rHzAsyncLRUCacheWrapper.cache_infows.����J�J����d�m�m�T�^�^�T�Y�Y�
�	
r,c�`�|j|j|j|jd�S)N�r4r;r<r6�r_rarbrcrIs r-rKz%AsyncLRUCacheWrapper.cache_parameters|s*���}�}��[�[�!%�!8�!8��9�9�	
�	
r,c��tjd�x}r(|j|d�dx|_x|_|_yyrZ)r%�get�popr\r]r`)rCrs  r-rMz AsyncLRUCacheWrapper.cache_clear�s@��#�'�'��-�-�5�-��I�I�d�D�!�9:�:�D�J�:�����.r,c��rK�|jdk(r1|j|i|���d{���}|xjdz
c_|S|}|r%|tft	|j�d�zz
}|jrB|td�|D��z
}|r+|tftd�|j�D��zz
}	tj�}	||}	||\}}}	|��|	�Jt%�|	k\r=|xj&dzc_tt!|j"��d}	}}|||	f||<nT|xj(dz
c_|j+|�|j"rt-��d{���t/t0|�S|4�d{���||dx}tur�|xjdz
c_|j�,|j&|jk\r|j3d��n|xj&dz
c_|j|i|���d{���}|j4�t%�|j4znd}	|d|	f||<n6|xj(dz
c_|j+|�t/t0|�}ddd��d{���|S7��g#t$r#t�}tj|�Y���wxYw#t$rt�x}||<Y��wxYw#t$r+tt!|j"��d}	}}|||	f||<Y��3wxYw7���7���7��	7��#1�d{���7swYSxYw�w)	Nrrr+c3�2K�|]}t|����y�wr@��type)�.0�args  r-�	<genexpr>z0AsyncLRUCacheWrapper.__call__.<locals>.<genexpr>�s����3�d�s��c��d���c3�2K�|]}t|����y�wr@rn)rp�vals  r-rrz0AsyncLRUCacheWrapper.__call__.<locals>.<genexpr>�s����1W���$�s�)��rs)�fast_acquireF)�last)r_r[r]r.�sum�itemsra�tuple�valuesr%rj�LookupErrorr�set�KeyErrorr
rrbrr`r\�move_to_endr!rr"�popitemrc)
rCrOrP�value�keyr�cache_entry�cached_value�lock�
expires_ats
          r-rQzAsyncLRUCacheWrapper.__call__�s�����=�=�A��*�$�*�*�D�;�F�;�;�E��L�L�A��L��L� $����O�%��F�L�L�N�B�(?�?�?�C��;�;��5�3�d�3�3�3�C����)�E�1W�v�}�}��1W�,W�W�W��	'�#�'�'�)�E�
	6���+�K�
		>�-8��-=�*�L�$�
��<��%�,�.�J�*F����!�#��#��$�*A�*A�&A�B��%/�d��
$0��z�#A��C� ��
�
�a��
��'�'��,��*�*�$�,�&�&��A�|�,�,��4� +�C� 0�� 3�3���G�����!���=�=�,����4�=�=�1P��'�'�U�'�3��N�N�a�'�N�.�d�.�.��?��?�?��26�)�)�2G�L�N�T�Y�Y�.�T��$)�$�
�#:��C� ��
�
�a��
��'�'��,��Q��-��%�4�(��Y<��"�	'�%�'�E�����&�	'���	6�(3�
�5�K�%��+�	6���	>� ��d�&=�&=�"=�>��!+�$�L�
 ,�T�:�=�K���	>��.'����@����4�4�4�(��s��%L7�J�BL7�;J�K�	K�B
L7�,L�-L7�L�L7�BL!�L�A(L!�<L7�L�L7�(J=�9L7�<J=�=L7�K�L7�K�L7�0L�L7�L�L7�L7�L!�L7�!L4�'L*�(L4�/L7Nc�J�t||�}t||j�|Sr@)r>rr[)rCrE�ownerrDs    r-�__get__zAsyncLRUCacheWrapper.__get__�s%��$�D�(�3���w�� 0� 0�1��r,)
rdzCallable[P, Awaitable[T]]r4r3r;r:r<r:r6r3rSrUrV)rOzP.argsrPzP.kwargsrTr"r@)rErRr�ztype | NonerTz_LRUMethodWrapper[T])	r(r)r*rFrHrKrMrQr�r+r,r-rrcso��#�'�#��#��	#�
 �#��
#�$
�

�;�
O�d6:����'2��	�r,rc�h�eZdZ								dd�Ze				dd��Ze				dd��Z				d	d�Zy)
�_LRUCacheWrapperc�<�||_||_||_||_yr@rh)rCr4r;r<r6s     r-rFz_LRUCacheWrapper.__init__�s!�� ��
����"3�����	r,c��yr@r+�rCrds  r-rQz_LRUCacheWrapper.__call__�s��&)r,c��yr@r+r�s  r-rQz_LRUCacheWrapper.__call__�s��+.r,c���t|�r7t||j|j|j|j
�St
j|j|j��|�S)N)r4r;)rrr_rarbrc�	functoolsr)rC�fs  r-rQz_LRUCacheWrapper.__call__�s[���q�!�'��4�=�=�$�+�+�t�/F�/F��	�	��
�M�y�"�"�4�=�=����L�Q�O�Or,N)r4r3r;r:r<r:r6r3�rdz#Callable[P, Coroutine[Any, Any, T]]rTzAsyncLRUCacheWrapper[P, T]�rdzCallable[..., T]rTzfunctools._lru_cache_wrapper[T])r�z6Callable[P, Coroutine[Any, Any, T]] | Callable[..., T]rTz<AsyncLRUCacheWrapper[P, T] | functools._lru_cache_wrapper[T])r(r)r*rFrrQr+r,r-r�r��s����!��*.��CG��NX���)�7�)�	#�)��)��.�$�.�	(�.��.�P�G�P�	E�Pr,r�c��yr@r+�rds r-rr���"%r,c��yr@r+r�s r-rrs��ILr,c�&�td��|�S)z�
    A convenient shortcut for :func:`lru_cache` with ``maxsize=None``.

    This is the asynchronous equivalent to :func:`functools.cache`.

    N)r4)rr�s r-rr
s��#�9�T�"�4�(�(r,.rgc��yr@r+rgs    r-rrs��r,c��yr@r+r�s r-rrr�r,c��yr@r+r�s r-rr$s��MPr,�Fc�v�|�t||||�St|�std��t||||�|�S)a�
    An asynchronous version of :func:`functools.lru_cache`.

    If a synchronous function is passed, the standard library
    :func:`functools.lru_cache` is applied instead.

    :param always_checkpoint: if ``True``, every call to the cached function will be
        guaranteed to yield control to the event loop at least once
    :param ttl: time in seconds after which to invalidate cache entries

    .. note:: Caches and locks are managed on a per-event loop basis.

    z#the first argument must be callable)r��callable�	TypeError)rdr4r;r<r6s     r-rr(sH��,�|����0A�3�G�G��D�>��=�>�>�C��G�U�,=�s�C�D�I�Ir,c��K�y�wr@r+)�function�iterable�initials   r-r	r	Gs����	���c��K�y�wr@r+)r�r�s  r-r	r	Ps����
	�r�c��K�d}t|t�ro|j�}|tur(	t	t
|j
��d{����}nt	t
|�}|23d{���}|||��d{���}d}�t|t�rYt|�}|tur	t	t
t|��}nt	t
|�}|D]}|||��d{���}d}�ntd��|st��d{���|S7��#t$r
td�d�wxYw7��7��6�7#t$r
td�d�wxYw7�d7�B�w)at
    Asynchronous version of :func:`functools.reduce`.

    :param function: a coroutine function that takes two arguments: the accumulated
        value and the next element from the iterable
    :param iterable: an iterable or async iterable
    :param initial: the initial value (if missing, the first element of the iterable is
        used as the initial value)

    FNz0reduce() of empty sequence with no initial valueTz9reduce() argument 2 must be an iterable or async iterable)�
isinstancer�	__aiter__r.rr"�	__anext__�StopAsyncIterationr�r�iter�next�
StopIterationr!)r�r�r��function_called�async_itr��element�its        r-r	r	Xs[����"�O��(�M�*��%�%�'���o�%�
��Q�h�&8�&8�&:� :�;����G�$�E�%�	#�'�"�5�'�2�2�E�"�O�	�H�h�	'�
�(�^���o�%�
��Q��R��)����G�$�E��G�"�5�'�2�2�E�"�O���S�T�T���l����L�E!;��%�
��F����
��	#��2��&��!�
��F����
��3��	�s��+E�D�D
�D�E�'D-�+D)�,D-�/
E�<D+�=*E�(D/�"E�#E�$#E�E
�E�D�D&�&E�)D-�+E�-E�/E�E�
Er�r�)rdz:Callable[..., Any] | Callable[P, Coroutine[Any, Any, Any]]rTr)
r4r3r;r:r<r:r6r3rTr�r@)rdzCCallable[..., Coroutine[Any, Any, Any]] | Callable[..., Any] | Noner4r3r;r:r<r:r6r3rTr)r�r"r�zCallable[[T, S], Awaitable[T]]r�zIterable[S] | AsyncIterable[S]rTr")r�zCallable[[T, T], Awaitable[T]]r�zIterable[T] | AsyncIterable[T]rTr")r�zT | _InitialMissingTyper�z?Callable[[T, T], Awaitable[T]] | Callable[[T, S], Awaitable[T]]r�z?Iterable[T] | Iterable[S] | AsyncIterable[T] | AsyncIterable[S]rTr")2�
__future__r�__all__r��collectionsr
�collections.abcrrr
rrrr�inspectr�typingrrrrrrrrr�weakrefr�_core._eventloopr�_core._synchronizationr�lowlevelr r!r"r#r$r%r8r'r.rrr>rr�rrr	r+r,r-�<module>r�s���"����#���%�'�
�
�
�&�*�(�(��C�L���C�L��
�c�N������	�	�	�	�(;�'<��$�<��Z���9��F���
�F�*�{�7�1�a�4�=�{��{�|P�P�<
�%�
-�%��%�
�%�

�L�
�L�)�
���!���
�����	�

���
�
��
�%�
-�%��%�
�%�

�P�
�P�QU�J���#��J�
M�J��	J�
�J��
J�
�J�	�J�>
���	�,��,��
��
��
��,��,���	�
��(7�	8�%�	8�M�8�M�8�
�8r,