o
    _i*                     @  s"  U d dl mZ dZd dlZd dlZd dlmZ d dlmZm	Z	m
Z
mZmZmZ d dlmZ d dlmZ d dlmZmZmZmZmZmZmZmZ d d	lmZ d
dlmZ d
dlmZm Z  ej!dkrgd dlm"Z" nd dl#m"Z" edZ$edZ%e"dZ&edZ'de(d< G dd dZ)e) Z*de(d< G dd deZ+G dd deZ,G dd dee$ Z-eG dd dee&e$f Z.G dd  d ee$ Z/edLd%d&Z0edMd)d&Z0dNd,d&Z0ed-d-d-d.dOd5d6Z1edLd7d6Z1edMd8d6Z1	dPd9d:d:d.dQd=d6Z1edRdCdDZ2edSdGdDZ2e*fdTdKdDZ2dS )U    )annotations)AsyncCacheInfoAsyncCacheParametersAsyncLRUCacheWrappercache	lru_cachereduceN)OrderedDict)AsyncIterable	AwaitableCallable	CoroutineHashableIterable)update_wrapper)iscoroutinefunction)AnyGeneric
NamedTuple	TypedDictTypeVarcastfinaloverload)WeakKeyDictionary   )Lock)RunVar
checkpoint)      )	ParamSpecTSPlru_cache_itemszRunVar[WeakKeyDictionary[AsyncLRUCacheWrapper[Any, Any], OrderedDict[Hashable, tuple[_InitialMissingType, Lock] | tuple[Any, None]]]]c                   @  s   e Zd ZdS )_InitialMissingTypeN)__name__
__module____qualname__ r*   r*   H/home/air/demo/back/venv/lib/python3.10/site-packages/anyio/functools.pyr&   8   s    r&   initial_missingc                   @  s.   e Zd ZU ded< ded< ded< ded< dS )r   inthitsmisses
int | NonemaxsizecurrsizeNr'   r(   r)   __annotations__r*   r*   r*   r+   r   ?   s
   
 r   c                   @  s&   e Zd ZU ded< ded< ded< dS )r   r0   r1   booltypedalways_checkpointNr3   r*   r*   r*   r+   r   F   s   
 r   c                   @  s>   e Zd ZdddZdd	d
ZdddZdddZdddZdS )_LRUMethodWrapperwrapperAsyncLRUCacheWrapper[..., T]instanceobjectc                 C  s   || _ || _d S N)_LRUMethodWrapper__wrapper_LRUMethodWrapper__instance)selfr9   r;   r*   r*   r+   __init__M   s   
z_LRUMethodWrapper.__init__returnr   c                 C  
   | j  S r=   )r>   
cache_infor@   r*   r*   r+   rD   Q      
z_LRUMethodWrapper.cache_infor   c                 C  rC   r=   )r>   cache_parametersrE   r*   r*   r+   rG   T   rF   z"_LRUMethodWrapper.cache_parametersNonec                 C  s   | j   d S r=   )r>   cache_clearrE   r*   r*   r+   rI   W   s   z_LRUMethodWrapper.cache_clearargsr   kwargsr"   c                   sB   | j d u r| j|i |I d H S | j| j g|R i |I d H S r=   )r?   r>   )r@   rJ   rK   r*   r*   r+   __call__Z   s   
 z_LRUMethodWrapper.__call__N)r9   r:   r;   r<   rB   r   rB   r   rB   rH   )rJ   r   rK   r   rB   r"   )r'   r(   r)   rA   rD   rG   rI   rL   r*   r*   r*   r+   r8   L   s    



r8   c                   @  sL   e Zd Zd#dd	Zd$ddZd%ddZd&ddZd'ddZ	d(d)d!d"ZdS )*r   funcCallable[P, Awaitable[T]]r1   r0   r6   r5   r7   c                 C  sJ   || _ d| _d| _|d urt|dnd | _d| _|| _|| _t| | d S Nr   )	__wrapped___hits_missesmax_maxsize	_currsize_typed_always_checkpointr   )r@   rP   r1   r6   r7   r*   r*   r+   rA   c   s   zAsyncLRUCacheWrapper.__init__rB   r   c                 C  s   t | j| j| j| jS r=   )r   rT   rU   rW   rX   rE   r*   r*   r+   rD   s   s   zAsyncLRUCacheWrapper.cache_infor   c                 C  s   | j | j| jdS )Nr1   r6   r7   rW   rY   rZ   rE   r*   r*   r+   rG   v   s   z%AsyncLRUCacheWrapper.cache_parametersrH   c                 C  s4   t d  }r|| d  d | _ | _| _d S d S rR   )r%   getpoprT   rU   rX   )r@   r   r*   r*   r+   rI   }   s   z AsyncLRUCacheWrapper.cache_clearrJ   P.argsrK   P.kwargsr"   c           	   	     sL  | j dkr| j|i |I d H }|  jd7  _|S |}|r*|tft| d 7 }| jrJ|tdd |D 7 }|rJ|tftdd | D  7 }zt	
 }W n tya   t }t	| Y nw z||  }W n tyx   t  }|| < Y nw z|| \}}W n ty   tt| j d}}||f||< Y nw |d u r|  jd7  _|| | jrt I d H  tt|S |4 I d H Y || d  }tu r|  jd7  _| j d ur| j| j kr|jdd	 n|  jd7  _| j|i |I d H }|d f||< n|  jd7  _|| tt|}W d   I d H  |S 1 I d H sw   Y  |S )
Nr   r   r*   c                 s      | ]}t |V  qd S r=   type).0argr*   r*   r+   	<genexpr>       z0AsyncLRUCacheWrapper.__call__.<locals>.<genexpr>c                 s  ra   r=   rb   )rd   valr*   r*   r+   rf      rg   )fast_acquireF)last)rW   rS   rU   r,   sumitemsrY   tuplevaluesr%   r]   LookupErrorr   setKeyErrorr	   r   rZ   rT   move_to_endr   r   r"   rX   popitem)	r@   rJ   rK   valuekeyr   cache_entrycached_valuelockr*   r*   r+   rL      sh   
 


zAsyncLRUCacheWrapper.__call__Nr;   r<   ownertype | None_LRUMethodWrapper[T]c                 C  s   t | |}t|| j |S r=   )r8   r   rS   )r@   r;   ry   r9   r*   r*   r+   __get__   s   
zAsyncLRUCacheWrapper.__get__)rP   rQ   r1   r0   r6   r5   r7   r5   rM   rN   rO   )rJ   r_   rK   r`   rB   r"   r=   )r;   r<   ry   rz   rB   r{   )	r'   r(   r)   rA   rD   rG   rI   rL   r|   r*   r*   r*   r+   r   a   s    




Er   c                   @  s<   e Zd ZdddZedddZedddZdddZdS )_LRUCacheWrapperr1   r0   r6   r5   r7   c                 C  s   || _ || _|| _d S r=   r\   )r@   r1   r6   r7   r*   r*   r+   rA      s   
z_LRUCacheWrapper.__init__rP   #Callable[P, Coroutine[Any, Any, T]]rB   AsyncLRUCacheWrapper[P, T]c                C     d S r=   r*   r@   rP   r*   r*   r+   rL         z_LRUCacheWrapper.__call__Callable[..., T]functools._lru_cache_wrapper[T]c                C  r   r=   r*   r   r*   r*   r+   rL      r   f6Callable[P, Coroutine[Any, Any, T]] | Callable[..., T]<AsyncLRUCacheWrapper[P, T] | functools._lru_cache_wrapper[T]c                C  s2   t |rt|| j| j| jS tj| j| jd|S )N)r1   r6   )r   r   rW   rY   rZ   	functoolsr   )r@   r   r*   r*   r+   rL      s
   N)r1   r0   r6   r5   r7   r5   rP   r~   rB   r   rP   r   rB   r   )r   r   rB   r   )r'   r(   r)   rA   r   rL   r*   r*   r*   r+   r}      s    
r}   rP   r~   rB   r   c                C  r   r=   r*   rP   r*   r*   r+   r      r   r   r   r   c                C  r   r=   r*   r   r*   r*   r+   r         6Callable[..., T] | Callable[P, Coroutine[Any, Any, T]]r   c                C  s   t dd| S )z
    A convenient shortcut for :func:`lru_cache` with ``maxsize=None``.

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

    N)r1   )r   r   r*   r*   r+   r      s   	.r[   r1   r0   r6   r5   r7   _LRUCacheWrapper[Any]c                 C  r   r=   r*   r[   r*   r*   r+   r      r   r   c                C  r   r=   r*   r   r*   r*   r+   r     r   c                C  r   r=   r*   r   r*   r*   r+   r     r      F=Callable[P, Coroutine[Any, Any, T]] | Callable[..., T] | NoneTAsyncLRUCacheWrapper[P, T] | functools._lru_cache_wrapper[T] | _LRUCacheWrapper[Any]c               C  s<   | du rt t |||S t| stdt 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

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

    Nz#the first argument must be callable)r}   r   callable	TypeErrorr"   )rP   r1   r6   r7   r*   r*   r+   r     s
   initialfunctionCallable[[T, S], Awaitable[T]]iterableIterable[S] | AsyncIterable[S]c                     d S r=   r*   )r   r   r   r*   r*   r+   r   .  s   r   Callable[[T, T], Awaitable[T]]Iterable[T] | AsyncIterable[T]c                  r   r=   r*   )r   r   r*   r*   r+   r   7  s   T | _InitialMissingType?Callable[[T, T], Awaitable[T]] | Callable[[T, S], Awaitable[T]]?Iterable[T] | Iterable[S] | AsyncIterable[T] | AsyncIterable[S]c                  s  d}t |trC| }|tu r)ztt| I dH }W n ty(   tddw tt|}|2 z3 dH W }| ||I dH }d}q06 n<t |t	r{t
|}|tu rfz	ttt|}W n tye   tddw tt|}|D ]}| ||I dH }d}qmntd|st I dH  |S )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,   r   r"   	__anext__StopAsyncIterationr   r   iternextStopIterationr   )r   r   r   function_calledasync_itrt   elementitr*   r*   r+   r   ?  sP   



r   r   )rP   r   rB   r   )r1   r0   r6   r5   r7   r5   rB   r   r=   )
rP   r   r1   r0   r6   r5   r7   r5   rB   r   )r   r"   r   r   r   r   rB   r"   )r   r   r   r   rB   r"   )r   r   r   r   r   r   rB   r"   )3
__future__r   __all__r   syscollectionsr	   collections.abcr
   r   r   r   r   r   r   inspectr   typingr   r   r   r   r   r   r   r   weakrefr   _core._synchronizationr   lowlevelr   r   version_infor!   typing_extensionsr"   r#   r$   r%   r4   r&   r,   r   r   r8   r   r}   r   r   r   r*   r*   r*   r+   <module>   sh    	 (


l
