o
    ii,/                     @  s2  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rmd 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 Z0G d d! d!ee& Z1edNd&d'Z2edOd*d'Z2dPd-d'Z2ed.d.d.d.d/dQd7d8Z3edNd9d8Z3edOd:d8Z3	dRd;d<d<dd/dSd?d8Z3edTdEdFZ4edUdIdFZ4e,fdVdMdFZ4dS )W    )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                   @  s   e Zd ZdS )_InitialMissingTypeN)__name__
__module____qualname__ r+   r+   W/var/www/scraper.webshop2u.hu/html/venv/lib/python3.10/site-packages/anyio/functools.pyr'   =   s    r'   initial_missingc                   @  s6   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   
 r   c                   @  s.   e Zd ZU ded< ded< ded< ded< dS )r   r1   r2   booltypedalways_checkpointr4   Nr5   r+   r+   r+   r,   r   L   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)selfr;   r=   r+   r+   r,   __init__T   s   
z_LRUMethodWrapper.__init__returnr   c                 C  
   | j  S r?   )r@   
cache_inforB   r+   r+   r,   rF   X      
z_LRUMethodWrapper.cache_infor   c                 C  rE   r?   )r@   cache_parametersrG   r+   r+   r,   rI   [   rH   z"_LRUMethodWrapper.cache_parametersNonec                 C  s   | j   d S r?   )r@   cache_clearrG   r+   r+   r,   rK   ^   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?   )rA   r@   )rB   rL   rM   r+   r+   r,   __call__a   s   
 z_LRUMethodWrapper.__call__N)r;   r<   r=   r>   rD   r   rD   r   rD   rJ   )rL   r   rM   r   rD   r#   )r(   r)   r*   rC   rF   rI   rK   rN   r+   r+   r+   r,   r:   S   s    



r:   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]]r2   r1   r8   r7   r9   r4   c                 C  sP   || _ d| _d| _|d urt|dnd | _d| _|| _|| _|| _t	| | d S Nr   )
__wrapped___hits_missesmax_maxsize	_currsize_typed_always_checkpoint_ttlr   )rB   rR   r2   r8   r9   r4   r+   r+   r,   rC   j   s   zAsyncLRUCacheWrapper.__init__rD   r   c                 C  s   t | j| j| j| j| jS r?   )r   rV   rW   rY   rZ   r]   rG   r+   r+   r,   rF   |   s   zAsyncLRUCacheWrapper.cache_infor   c                 C  s   | j | j| j| jdS )Nr2   r8   r9   r4   rY   r[   r\   r]   rG   r+   r+   r,   rI      s
   z%AsyncLRUCacheWrapper.cache_parametersrJ   c                 C  s4   t d  }r|| d  d | _ | _| _d S d S rT   )r&   getpoprV   rW   rZ   )rB   r   r+   r+   r,   rK      s   z AsyncLRUCacheWrapper.cache_clearrL   P.argsrM   P.kwargsr#   c           
   	     s  | 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d }}}	|||	f||< Y nw |d u r|	d urt |	kr|  jd8  _tt| j dd }}}	|||	f||< n|  jd7  _|| | jrt I d H  tt|S |4 I d H k || d  }tu r8|  jd7  _| j d ur| j| j kr|jdd	 n|  jd7  _| j|i |I d H }| jd ur.t | j nd }	|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  rd   r?   re   )rg   valr+   r+   r,   ri      rj   )fast_acquireF)last)rY   rU   rW   r-   sumitemsr[   tuplevaluesr&   r`   LookupErrorr   setKeyErrorr	   r   r\   r   rZ   rV   move_to_endr   r   r#   popitemr]   )
rB   rL   rM   valuekeyr   cache_entrycached_valuelock
expires_atr+   r+   r,   rN      s|   
 
	



zAsyncLRUCacheWrapper.__call__Nr=   r>   ownertype | None_LRUMethodWrapper[T]c                 C  s   t | |}t|| j |S r?   )r:   r   rU   )rB   r=   r}   r;   r+   r+   r,   __get__   s   
zAsyncLRUCacheWrapper.__get__)
rR   rS   r2   r1   r8   r7   r9   r7   r4   r1   rO   rP   rQ   )rL   rb   rM   rc   rD   r#   r?   )r=   r>   r}   r~   rD   r   )	r(   r)   r*   rC   rF   rI   rK   rN   r   r+   r+   r+   r,   r   h   s    




R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 )_LRUCacheWrapperr2   r1   r8   r7   r9   r4   c                 C  s   || _ || _|| _|| _d S r?   r_   )rB   r2   r8   r9   r4   r+   r+   r,   rC      s   
z_LRUCacheWrapper.__init__rR   #Callable[P, Coroutine[Any, Any, T]]rD   AsyncLRUCacheWrapper[P, T]c                C     d S r?   r+   rB   rR   r+   r+   r,   rN         z_LRUCacheWrapper.__call__Callable[..., T]functools._lru_cache_wrapper[T]c                C  r   r?   r+   r   r+   r+   r,   rN      r   f6Callable[P, Coroutine[Any, Any, T]] | Callable[..., T]<AsyncLRUCacheWrapper[P, T] | functools._lru_cache_wrapper[T]c                C  s6   t |rt|| j| j| j| jS tj| j| jd|S )N)r2   r8   )r   r   rY   r[   r\   r]   	functoolsr   )rB   r   r+   r+   r,   rN      s
   N)r2   r1   r8   r7   r9   r7   r4   r1   rR   r   rD   r   rR   r   rD   r   )r   r   rD   r   )r(   r)   r*   rC   r   rN   r+   r+   r+   r,   r      s    
r   rR   r   rD   r   c                C  r   r?   r+   rR   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)r2   )r   r   r+   r+   r,   r     s   	.r^   r2   r1   r8   r7   r9   r4   _LRUCacheWrapper[Any]c                 C  r   r?   r+   r^   r+   r+   r,   r     s   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
    :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#   )rR   r2   r8   r9   r4   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   P  s   r   Callable[[T, T], Awaitable[T]]Iterable[T] | AsyncIterable[T]c                  r   r?   r+   )r   r   r+   r+   r,   r   Y  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_itrw   elementitr+   r+   r,   r   a  sP   



r   r   )rR   r   rD   r   )
r2   r1   r8   r7   r9   r7   r4   r1   rD   r   r?   )rR   r   r2   r1   r8   r7   r9   r7   r4   r1   rD   r   )r   r#   r   r   r   r   rD   r#   )r   r   r   r   rD   r#   )r   r   r   r   r   r   rD   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&   r6   r'   r-   r   r   r:   r   r   r   r   r   r+   r+   r+   r,   <module>   sr    	 (



~
	!