
    i,/                    6   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 d
dl m!Z!m"Z" ej#        dk    rd 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          Z+ e+            Z,de*d<    G d de          Z- G d de          Z. G d dee&                   Z/e G d dee(e&f                               Z0 G d  d!ee&                   Z1edKd&            Z2edLd)            Z2dMd,Z2ed-d-d-d-d.dNd6            Z3edKd7            Z3edLd8            Z3	 dOd9d:d:dd.dPd=Z3edQdC            Z4edRdF            Z4e,fdSdJZ4dS )T    )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   )current_time)Lock)RunVar
checkpoint)      )	ParamSpecTSPlru_cache_itemszRunVar[WeakKeyDictionary[AsyncLRUCacheWrapper[Any, Any], OrderedDict[Hashable, tuple[_InitialMissingType, Lock, float | None] | tuple[Any, None, float | None]]]]c                      e Zd ZdS )_InitialMissingTypeN)__name__
__module____qualname__     L/root/projects/qq-shell/venv/lib/python3.11/site-packages/anyio/functools.pyr)   r)   =   s        Dr.   r)   initial_missingc                  B    e Zd ZU ded<   ded<   ded<   ded<   ded<   dS )	r   inthitsmisses
int | NonemaxsizecurrsizettlNr*   r+   r,   __annotations__r-   r.   r/   r   r   D   s@         IIIKKKMMMOOOOOr.   r   c                  8    e Zd ZU ded<   ded<   ded<   ded<   dS )r   r5   r6   booltypedalways_checkpointr8   Nr9   r-   r.   r/   r   r   L   s:         KKKOOOOOr.   r   c                  6    e Zd ZddZddZdd
ZddZddZdS )_LRUMethodWrapperwrapperAsyncLRUCacheWrapper[..., T]instanceobjectc                "    || _         || _        d S N)_LRUMethodWrapper__wrapper_LRUMethodWrapper__instance)selfrA   rC   s      r/   __init__z_LRUMethodWrapper.__init__T   s     "r.   returnr   c                4    | j                                         S rF   )rG   
cache_inforI   s    r/   rM   z_LRUMethodWrapper.cache_infoX   s    ~((***r.   r   c                4    | j                                         S rF   )rG   cache_parametersrN   s    r/   rP   z"_LRUMethodWrapper.cache_parameters[   s    ~..000r.   Nonec                8    | j                                          d S rF   )rG   cache_clearrN   s    r/   rS   z_LRUMethodWrapper.cache_clear^   s    ""$$$$$r.   argsr   kwargsr$   c                r   K   | j          | j        |i | d {V S  | j        | j         g|R i | d {V S rF   )rH   rG   )rI   rT   rU   s      r/   __call__z_LRUMethodWrapper.__call__a   sm      ?"'8888888888#T^DOEdEEEfEEEEEEEEEr.   N)rA   rB   rC   rD   rK   r   rK   r   rK   rQ   )rT   r   rU   r   rK   r$   )r*   r+   r,   rJ   rM   rP   rS   rW   r-   r.   r/   r@   r@   S   s~        # # # #+ + + +1 1 1 1% % % %F F F F F Fr.   r@   c                  B    e Zd Zdd	ZddZd dZd!dZd"dZ	 d#d$dZdS )%r   funcCallable[P, Awaitable[T]]r6   r5   r=   r<   r>   r8   c                    || _         d| _        d| _        |t          |d          nd | _        d| _        || _        || _        || _        t          | |           d S Nr   )
__wrapped___hits_missesmax_maxsize	_currsize_typed_always_checkpoint_ttlr   )rI   r\   r6   r=   r>   r8   s         r/   rJ   zAsyncLRUCacheWrapper.__init__j   se      
+2+>GQD"3	tT"""""r.   rK   r   c                Z    t          | j        | j        | j        | j        | j                  S rF   )r   ra   rb   rd   re   rh   rN   s    r/   rM   zAsyncLRUCacheWrapper.cache_info|   s)    JdmT^TY
 
 	
r.   r   c                8    | j         | j        | j        | j        dS )Nr6   r=   r>   r8   rd   rf   rg   rh   rN   s    r/   rP   z%AsyncLRUCacheWrapper.cache_parameters   s&    }[!%!89	
 
 	
r.   rQ   c                    t                               d           x}r-|                    | d            dx| _        x| _        | _        d S d S r_   )r'   getpopra   rb   re   )rI   r   s     r/   rS   z AsyncLRUCacheWrapper.cache_clear   sT    #''---5 	;IIdD!!!9::DJ:	; 	;r.   rT   P.argsrU   P.kwargsr$   c                d  K   | j         dk    r% | j        |i | d {V }| xj        dz  c_        |S |}|r.|t          ft	          |                                d          z   z  }| j        rU|t          d |D                       z  }|r7|t          ft          d |                                D                       z   z  }	 t          
                                }n8# t          $ r+ t                      }t                              |           Y nw xY w	 ||          }n## t          $ r t                      x}|| <   Y nw xY w	 ||         \  }}}	n7# t          $ r* t          t!          | j                   d }	}}|||	f||<   Y nw xY w||	Jt%                      |	k    r8| xj        dz  c_        t          t!          | j                   d }	}}|||	f||<   nU| xj        dz  c_        |                    |           | j        rt-                       d {V  t/          t0          |          S |4 d {V  ||         d         x}t          u r| xj        dz  c_        | j         '| j        | j         k    r|                    d           n| xj        dz  c_         | j        |i | d {V }| j        t%                      | j        z   nd }	|d |	f||<   n:| xj        dz  c_        |                    |           t/          t0          |          }	 d d d           d {V  n# 1 d {V swxY w Y   |S )	Nr   r   r-   c              3  4   K   | ]}t          |          V  d S rF   type).0args     r/   	<genexpr>z0AsyncLRUCacheWrapper.__call__.<locals>.<genexpr>   s(      33sc333333r.   c              3  4   K   | ]}t          |          V  d S rF   rt   )rv   vals     r/   rx   z0AsyncLRUCacheWrapper.__call__.<locals>.<genexpr>   s(      1W1W$s))1W1W1W1W1W1Wr.   )fast_acquireF)last)rd   r`   rb   r0   sumitemsrf   tuplevaluesr'   rn   LookupErrorr   setKeyErrorr
   r   rg   r   re   ra   move_to_endr    r   r$   popitemrh   )
rI   rT   rU   valuekeyr   cache_entrycached_valuelock
expires_ats
             r/   rW   zAsyncLRUCacheWrapper.__call__   sp     =A*$*D;F;;;;;;;;ELLALLL  $ 	@O%FLLNNB(?(???C; 	X533d333333C X)E1W1Wv}}1W1W1W,W,WWW	'#''))EE 	' 	' 	'%''E&&&&&	'	6+KK 	6 	6 	6(35K%+++	6		>-8-=*L$

 	> 	> 	>  d&="=>>> !+$L
  ,T:=K	> <%,..J*F*F!##$*A&ABBB %/d
 $0z#AC   

a

'',,,* '$,,&&&&&&&A|,,, 	. 	. 	. 	. 	. 	. 	. 	. +C 0 33GG!=,4=1P1P''U'3333NNa'NN.d.?????????26)2GLNNTY..T  $)$
#:C   

a

'',,,Q---%	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	. 	.( sI   C 2DDD D>=D>E 1FF1CL
L),L)NrC   rD   ownertype | None_LRUMethodWrapper[T]c                P    t          | |          }t          || j                   |S rF   )r@   r   r`   )rI   rC   r   rA   s       r/   __get__zAsyncLRUCacheWrapper.__get__   s+     $D(33w 0111r.   )
r\   r]   r6   r5   r=   r<   r>   r<   r8   r5   rX   rY   rZ   )rT   rp   rU   rq   rK   r$   rF   )rC   rD   r   r   rK   r   )	r*   r+   r,   rJ   rM   rP   rS   rW   r   r-   r.   r/   r   r   h   s        # # # #$
 
 
 


 
 
 
; ; ; ;
O O O Od 6:      r.   r   c                  N    e Zd ZddZedd            Zedd            ZddZdS )_LRUCacheWrapperr6   r5   r=   r<   r>   r8   c                >    || _         || _        || _        || _        d S rF   rl   )rI   r6   r=   r>   r8   s        r/   rJ   z_LRUCacheWrapper.__init__   s%      "3			r.   r\   #Callable[P, Coroutine[Any, Any, T]]rK   AsyncLRUCacheWrapper[P, T]c                   d S rF   r-   rI   r\   s     r/   rW   z_LRUCacheWrapper.__call__   s	     &)Sr.   Callable[..., T]functools._lru_cache_wrapper[T]c                   d S rF   r-   r   s     r/   rW   z_LRUCacheWrapper.__call__   s	     +.#r.   f6Callable[P, Coroutine[Any, Any, T]] | Callable[..., T]<AsyncLRUCacheWrapper[P, T] | functools._lru_cache_wrapper[T]c                   t          |          r't          || j        | j        | j        | j                  S  t          j        | j        | j                  |          S )N)r6   r=   )r   r   rd   rf   rg   rh   	functoolsr   )rI   r   s     r/   rW   z_LRUCacheWrapper.__call__   sa     q!! 	'4=$+t/F	   My"4=LLLQOOOr.   N)r6   r5   r=   r<   r>   r<   r8   r5   r\   r   rK   r   r\   r   rK   r   )r   r   rK   r   )r*   r+   r,   rJ   r   rW   r-   r.   r/   r   r      s            ) ) ) X) . . . X.P P P P P Pr.   r   r\   r   rK   r   c                   d S rF   r-   r\   s    r/   r   r     	     "%r.   r   r   c                   d S rF   r-   r   s    r/   r   r     s    ILr.   6Callable[..., T] | Callable[P, Coroutine[Any, Any, T]]r   c               4     t          d          |           S )z
    A convenient shortcut for :func:`lru_cache` with ``maxsize=None``.

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

    N)r6   )r   r   s    r/   r   r     s     #9T"""4(((r.   .rk   r6   r5   r=   r<   r>   r8   _LRUCacheWrapper[Any]c                    d S rF   r-   rk   s       r/   r   r     s	      Cr.   c                   d S rF   r-   r   s    r/   r   r   %  r   r.   c                   d S rF   r-   r   s    r/   r   r   +  s    MPSr.      F=Callable[P, Coroutine[Any, Any, T]] | Callable[..., T] | NoneTAsyncLRUCacheWrapper[P, T] | functools._lru_cache_wrapper[T] | _LRUCacheWrapper[Any]c                  | 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
    :param ttl: time in seconds after which to invalidate cache entries

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

    Nz#the first argument must be callable)r   r   callable	TypeErrorr$   )r\   r6   r=   r>   r8   s        r/   r   r   /  se    0 |$We5FLLLD>> ?=>>>FAw/@#FFtLLLr.   initialfunctionCallable[[T, S], Awaitable[T]]iterableIterable[S] | AsyncIterable[S]c               
   K   d S rF   r-   )r   r   r   s      r/   r	   r	   P  s       	r.   Callable[[T, T], Awaitable[T]]Iterable[T] | AsyncIterable[T]c               
   K   d S rF   r-   )r   r   s     r/   r	   r	   Y  s      
 	r.   T | _InitialMissingType?Callable[[T, T], Awaitable[T]] | Callable[[T, S], Awaitable[T]]?Iterable[T] | Iterable[S] | AsyncIterable[T] | AsyncIterable[S]c                 K   d}t          |t                    r|                                }|t          u rM	 t	          t
          |                                 d{V           }n3# t          $ r t          d          dw xY wt	          t
          |          }|2 3 d{V } | ||           d{V }d}6 nt          |t                    rt          |          }|t          u rB	 t	          t
          t          |                    }n3# t          $ r t          d          dw xY wt	          t
          |          }|D ]} | ||           d{V }d}nt          d          |st                       d{V  |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__r0   r   r$   	__anext__StopAsyncIterationr   r   iternextStopIterationr    )r   r   r   function_calledasync_itr   elementits           r/   r	   r	   a  s     " O(M** U%%''o%%Qh&8&8&:&: : : : : : :;;%   F 
 G$$E% 	# 	# 	# 	# 	# 	# 	#'"(5'22222222E"OO &X 
Hh	'	' U(^^o%%QR))    F 
 G$$E 	# 	#G"(5'22222222E"OO	# STTT  llLs   -A& &BB7'"D
 
D%r   r   )r\   r   rK   r   )
r6   r5   r=   r<   r>   r<   r8   r5   rK   r   rF   )r\   r   r6   r5   r=   r<   r>   r<   r8   r5   rK   r   )r   r$   r   r   r   r   rK   r$   )r   r   r   r   rK   r$   )r   r   r   r   r   r   rK   r$   )5
__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._eventloopr   _core._synchronizationr   lowlevelr   r    version_infor#   typing_extensionsr$   r%   r&   r'   r:   r)   r0   r   r   r@   r   r   r   r   r	   r-   r.   r/   <module>r      s   " " " " " " "     



 # # # # # #                % $ $ $ $ $ ' ' ' ' ' '	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 & % % % % % * * * * * * ( ( ( ( ( ( ( ( ( ( ( ( ( (w       ++++++GCLLGCLLIcNN F  	 	 	 		 	 	 	 	 	 	 	 (;':'<'< < < < <    Z       9   F F F F F
 F F F* { { { { {71a4= { { {|P P P P Pwqz P P P< 
% % % 
%
 
 L L L 
 L	) 	) 	) 	) 
 !          
  
% % % 
%
 
 P P P 
 P KOM #M M M M M MB 
   
 
   
 (7	8 8 8 8 8 8 8r.   