
    Qi,/                    "   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jF                  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	 	 	 	 d0d"       Z2ed1d#       Z2	 	 	 	 d2d$Z2ed%d%d%d%d&	 	 	 	 	 	 	 	 	 d3d'       Z3e	 	 	 	 d0d(       Z3ed1d)       Z3	 d4d*d+d+dd&	 	 	 	 	 	 	 	 	 	 	 d5d,Z3e	 	 	 	 	 	 	 	 d6d-       Z4e	 	 	 	 	 	 d7d.       Z4e,f	 	 	 	 	 	 	 d8d/Z4y)9    )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y)_InitialMissingTypeN)__name__
__module____qualname__     :/app/.venv/lib/python3.12/site-packages/anyio/functools.pyr)   r)   =   s    r.   r)   initial_missingc                  @    e Zd ZU ded<   ded<   ded<   ded<   ded<   y)	r   inthitsmisses
int | NonemaxsizecurrsizettlNr*   r+   r,   __annotations__r-   r.   r/   r   r   D   s    
IKM	Or.   r   c                  6    e Zd ZU ded<   ded<   ded<   ded<   y)r   r5   r6   booltypedalways_checkpointr8   Nr9   r-   r.   r/   r   r   L   s    K	Or.   r   c                  4    e Zd ZddZddZd	dZd
dZddZy)_LRUMethodWrapperc                     || _         || _        y N)_LRUMethodWrapper__wrapper_LRUMethodWrapper__instance)selfwrapperinstances      r/   __init__z_LRUMethodWrapper.__init__T   s     "r.   c                6    | j                   j                         S rB   )rC   
cache_inforE   s    r/   rJ   z_LRUMethodWrapper.cache_infoX   s    ~~((**r.   c                6    | j                   j                         S rB   )rC   cache_parametersrK   s    r/   rM   z"_LRUMethodWrapper.cache_parameters[   s    ~~..00r.   c                8    | j                   j                          y rB   )rC   cache_clearrK   s    r/   rO   z_LRUMethodWrapper.cache_clear^   s    ""$r.   c                   K   | j                    | j                  |i | d {   S  | j                  | j                   g|i | d {   S 7 ,7 wrB   )rD   rC   )rE   argskwargss      r/   __call__z_LRUMethodWrapper.__call__a   sT     ??"'8888#T^^DOOEdEfEEE 9Es!   "AA'AAAAN)rF   zAsyncLRUCacheWrapper[..., T]rG   objectreturnr   rV   r   rV   None)rQ   r   rR   r   rV   r$   )r*   r+   r,   rH   rJ   rM   rO   rS   r-   r.   r/   r@   r@   S   s    #+1%Fr.   r@   c                  ^    e Zd Z	 	 	 	 	 	 	 	 	 	 ddZd	dZd
dZddZddZ	 d	 	 	 	 	 ddZy)r   c                    || _         d| _        d| _        |t        |d      nd | _        d| _        || _        || _        || _        t        | |       y Nr   )
__wrapped___hits_missesmax_maxsize	_currsize_typed_always_checkpoint_ttlr   )rE   funcr6   r=   r>   r8   s         r/   rH   zAsyncLRUCacheWrapper.__init__j   sU      
+2+>GQD"3	tT"r.   c                    t        | j                  | j                  | j                  | j                  | j
                        S rB   )r   r^   r_   ra   rb   re   rK   s    r/   rJ   zAsyncLRUCacheWrapper.cache_info|   s.    JJdmmT^^TYY
 	
r.   c                `    | j                   | j                  | j                  | j                  dS )Nr6   r=   r>   r8   ra   rc   rd   re   rK   s    r/   rM   z%AsyncLRUCacheWrapper.cache_parameters   s*    }}[[!%!8!899	
 	
r.   c                    t         j                  d       x}r(|j                  | d        dx| _        x| _        | _        y y r\   )r'   getpopr^   r_   rb   )rE   r   s     r/   rO   z AsyncLRUCacheWrapper.cache_clear   s@    #''--5-IIdD!9::DJ: .r.   c                r  K   | j                   dk(  r1 | j                  |i | d {   }| xj                  dz  c_        |S |}|r%|t        ft	        |j                         d      z   z  }| j                  rB|t        d |D              z  }|r+|t        ft        d |j                         D              z   z  }	 t        j                         }	 ||    }	 ||   \  }}}	||	Jt%               |	k\  r=| xj&                  dz  c_        t        t!        | j"                         d }	}}|||	f||<   nT| xj(                  dz  c_        |j+                  |       | j"                  rt-                d {    t/        t0        |      S |4 d {    ||   d   x}t        u r| xj                  dz  c_        | j                   ,| j&                  | j                   k\  r|j3                  d       n| xj&                  dz  c_         | j                  |i | d {   }| j4                  t%               | j4                  z   nd }	|d |	f||<   n6| xj(                  dz  c_        |j+                  |       t/        t0        |      }d d d       d {    |S 7 g# t        $ r# t               }t        j                  |       Y w xY w# t        $ r t               x}|| <   Y w xY w# t        $ r+ t        t!        | j"                         d }	}}|||	f||<   Y 3w xY w7 7 7 	7 # 1 d {  7  sw Y   S xY ww)	Nr   r   r-   c              3  2   K   | ]  }t        |        y wrB   type).0args     r/   	<genexpr>z0AsyncLRUCacheWrapper.__call__.<locals>.<genexpr>   s     3dscd   c              3  2   K   | ]  }t        |        y wrB   rp   )rr   vals     r/   rt   z0AsyncLRUCacheWrapper.__call__.<locals>.<genexpr>   s     1W$s)ru   )fast_acquireF)last)ra   r]   r_   r0   sumitemsrc   tuplevaluesr'   rl   LookupErrorr   setKeyErrorr
   r   rd   r   rb   r^   move_to_endr    r   r$   popitemre   )
rE   rQ   rR   valuekeyr   cache_entrycached_valuelock
expires_ats
             r/   rS   zAsyncLRUCacheWrapper.__call__   s    ==A*$**D;F;;ELLALL  $O%FLLNB(???C;;53d333C)E1Wv}}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NNa'N.d..???26))2GLNTYY.T  $)$
#:C  

a
'',Q-% 4( Y <"  	'%'E&	'  	6(35K%+	6  	>  d&=&="=> !+$L
  ,T:=K	>. '  @ 444( s   %L7JBL7;J K  	K BL7,L-L7LL7BL!LA(L!<L7LL7(J=9L7<J==L7 KL7KL70LL7LL7L7L!L7!L4'L*(L4/L7Nc                J    t        | |      }t        || j                         |S rB   )r@   r   r]   )rE   rG   ownerrF   s       r/   __get__zAsyncLRUCacheWrapper.__get__   s%     $D(3w 0 01r.   )
rf   zCallable[P, Awaitable[T]]r6   r5   r=   r<   r>   r<   r8   r5   rU   rW   rX   )rQ   zP.argsrR   zP.kwargsrV   r$   rB   )rG   rT   r   ztype | NonerV   z_LRUMethodWrapper[T])	r*   r+   r,   rH   rJ   rM   rO   rS   r   r-   r.   r/   r   r   h   so    #'# # 	#
  # #$


;
Od 6:'2	r.   r   c                  h    e Zd Z	 	 	 	 	 	 	 	 ddZe	 	 	 	 dd       Ze	 	 	 	 dd       Z	 	 	 	 d	dZy)
_LRUCacheWrapperc                <    || _         || _        || _        || _        y rB   rj   )rE   r6   r=   r>   r8   s        r/   rH   z_LRUCacheWrapper.__init__   s!      "3	r.   c                    y rB   r-   rE   rf   s     r/   rS   z_LRUCacheWrapper.__call__   s     &)r.   c                    y rB   r-   r   s     r/   rS   z_LRUCacheWrapper.__call__   s     +.r.   c                   t        |      r7t        || j                  | j                  | j                  | j
                        S  t        j                  | j                  | j                        |      S )N)r6   r=   )r   r   ra   rc   rd   re   	functoolsr   )rE   fs     r/   rS   z_LRUCacheWrapper.__call__   s[     q!'4==$++t/F/F		  My""4==LQOOr.   N)r6   r5   r=   r<   r>   r<   r8   r5   rf   z#Callable[P, Coroutine[Any, Any, T]]rV   zAsyncLRUCacheWrapper[P, T]rf   zCallable[..., T]rV   zfunctools._lru_cache_wrapper[T])r   z6Callable[P, Coroutine[Any, Any, T]] | Callable[..., T]rV   <AsyncLRUCacheWrapper[P, T] | functools._lru_cache_wrapper[T])r*   r+   r,   rH   r   rS   r-   r.   r/   r   r      s    !*.CGNX )7)	#) ) .$.	(. .PGP	EPr.   r   c                    y rB   r-   rf   s    r/   r   r          "%r.   c                    y rB   r-   r   s    r/   r   r     s    ILr.   c               &     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.   .ri   c                     y rB   r-   ri   s       r/   r   r     s      r.   c                    y rB   r-   r   s    r/   r   r   %  r   r.   c                    y rB   r-   r   s    r/   r   r   +  s    MPr.      Fc                  | 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.

    z#the first argument must be callable)r   r   callable	TypeErrorr$   )rf   r6   r=   r>   r8   s        r/   r   r   /  sR    0 |$We5FLLD>=>>FAw/@#FtLLr.   c                  K   y wrB   r-   )functioniterableinitials      r/   r	   r	   P  s      	   c                  K   y wrB   r-   )r   r   s     r/   r	   r	   Y  s     
 	r   c                 K   d}t        |t              ro|j                         }|t        u r(	 t	        t
        |j                          d{         }nt	        t
        |      }|2 3 d{   } | ||       d{   }d}t        |t              rYt        |      }|t        u r	 t	        t
        t        |            }nt	        t
        |      }|D ]  } | ||       d{   }d} nt        d      |st                d{    |S 7 # t        $ r t        d      dw xY w7 7 6 7# t        $ r t        d      dw xY w7 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__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*%%'o%Qh&8&8&: :; G$E% 	#'"5'22E"O	Hh	'(^o%QR) G$EG"5'22E"O  STT lLE !;% 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   )rf   z6Callable[..., T] | Callable[P, Coroutine[Any, Any, T]]rV   r   )
r6   r5   r=   r<   r>   r<   r8   r5   rV   z_LRUCacheWrapper[Any]rB   )rf   z=Callable[P, Coroutine[Any, Any, T]] | Callable[..., T] | Noner6   r5   r=   r<   r>   r<   r8   r5   rV   zTAsyncLRUCacheWrapper[P, T] | functools._lru_cache_wrapper[T] | _LRUCacheWrapper[Any])r   r$   r   zCallable[[T, S], Awaitable[T]]r   zIterable[S] | AsyncIterable[S]rV   r$   )r   zCallable[[T, T], Awaitable[T]]r   zIterable[T] | AsyncIterable[T]rV   r$   )r   zT | _InitialMissingTyper   z?Callable[[T, T], Awaitable[T]] | Callable[[T, S], Awaitable[T]]r   z?Iterable[T] | Iterable[S] | AsyncIterable[T] | AsyncIterable[S]rV   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 +CLCLcN   	 		 	 (;'<$ <Z 9 F
 F* {71a4= { {|Pwqz P< 
%
-%% 
%
 
 L 
 L	)
@	)A	) 
 !     	 
 
    
  
%
-%% 
%
 
 P 
 P KOM #M
GM 	M
 M M 
M YMB 
 	,,
  
 
,, 	 
 (7	8 %	8M8M8
 8r.   