File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/cachetools.zip
Back
PK ��Z�3��Y �Y $ __pycache__/__init__.cpython-310.pycnu �[��� o �h+U � @ s, d Z dZdZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z G dd � d �Z G d d � d ejj�ZG d d � d e�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�Ze�d g d ��Ze jdd fd d �Z e j dfd!d"�Z dS )#z0Extensible memoizing collections and decorators.) �Cache� FIFOCache�LFUCache�LRUCache�MRUCache�RRCache� TLRUCache�TTLCache�cached� cachedmethodz5.5.2� N� )�keys)�_cached_wrapperc @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � _DefaultSize� c C � dS �Nr r ��self�_r r �I/usr/local/CyberPanel/lib/python3.10/site-packages/cachetools/__init__.py� __getitem__ � z_DefaultSize.__getitem__c C s |dksJ �d S r r )r r �valuer r r � __setitem__# s z_DefaultSize.__setitem__c C r r r r r r r �pop& r z_DefaultSize.popN)�__name__� __module__� __qualname__� __slots__r r r r r r r r s r c @ s� e Zd ZdZe� Ze� Zd!dd�Zdd� Z dd� Z d d � Z d d � Z d d� Z dd� Zdd� Zdd� Zd!dd�Zefdd�Zd!dd�Zedd � �Zed d � �Zed d � �ZdS )"r z?Mutable mapping to serve as a simple cache or cache base class.Nc C s6 |r|| _ | j tj urt� | _t� | _d| _|| _d S �Nr )� getsizeofr �dict� _Cache__size� _Cache__data�_Cache__currsize�_Cache__maxsize�r �maxsizer! r r r �__init__1 s zCache.__init__c C s d| j jt| j�| j| jf S )Nz %s(%s, maxsize=%r, currsize=%r))� __class__r �reprr$ r& r% �r r r r �__repr__: s �zCache.__repr__c C s* z| j | W S ty | �|� Y S w �N)r$ �KeyError� __missing__�r �keyr r r r B s �zCache.__getitem__c C s� | j }| �|�}||krtd��|| jvs | j| |k r.| j| |kr.| �� | j| |ks#|| jv r;|| j| }n|}|| j|< || j|< | j|7 _d S )Nzvalue too large)r& r! � ValueErrorr$ r# r% �popitem)r r2 r r( �size�diffsizer r r r H s � zCache.__setitem__c C s& | j �|�}| j|= | j|8 _d S r. )r# r r$ r% )r r2 r5 r r r � __delitem__X s zCache.__delitem__c C s || j v S r. )r$ r1 r r r � __contains__] � zCache.__contains__c C s t |��r. )r/ r1 r r r r0 ` s zCache.__missing__c C � t | j�S r. )�iterr$ r, r r r �__iter__c r9 zCache.__iter__c C r: r. )�lenr$ r, r r r �__len__f r9 z Cache.__len__c C s || v r| | S |S r. r )r r2 �defaultr r r �geti s z Cache.getc C s4 || v r | | }| |= |S || j u rt|��|}|S r. )�_Cache__markerr/ �r r2 r? r r r r r o s �z Cache.popc C s$ || v r | | }|S | | |< }|S r. r rB r r r � setdefaulty s �zCache.setdefaultc C � | j S )z The maximum size of the cache.)r& r, r r r r( � � z Cache.maxsizec C rD )z The current size of the cache.)r% r, r r r �currsize� rE zCache.currsizec C r )z+Return the size of a cache element's value.r r )r r r r r! � s zCache.getsizeofr. )r r r �__doc__�objectrA r r# r) r- r r r7 r8 r0 r< r> r@ r rC �propertyr( rF � staticmethodr! r r r r r * s, r c @ s> e Zd ZdZd dd�Zejfdd�Zejfdd�Zd d � ZdS ) r z/First In First Out (FIFO) cache implementation.Nc C � t �| ||� t�� | _d S r. )r r) � collections� OrderedDict�_FIFOCache__orderr' r r r r) � � zFIFOCache.__init__c C s> || ||� z | j �|� W d S ty d | j |< Y d S w r. )rN � move_to_endr/ �r r2 r � cache_setitemr r r r � s �zFIFOCache.__setitem__c C � || |� | j |= d S r. )rN �r r2 � cache_delitemr r r r7 � � zFIFOCache.__delitem__c C �D z t t| j��}W n ty tdt| �j �d�w || �|�fS )z9Remove and return the `(key, value)` pair first inserted.� %s is emptyN)�nextr; rN � StopIterationr/ �typer r r1 r r r r4 � � �zFIFOCache.popitemr. ) r r r rG r) r r r7 r4 r r r r r � s r c @ sL e Zd ZdZd dd�Zejfdd�Zejfdd�Zejfd d �Zd d � Z dS )r z1Least Frequently Used (LFU) cache implementation.Nc C rK r. )r r) rL �Counter�_LFUCache__counterr' r r r r) � rO zLFUCache.__init__c C s( || |�}|| v r| j | d8 < |S r �r^ �r r2 � cache_getitemr r r r r � s zLFUCache.__getitem__c C s" || ||� | j | d8 < d S r r_ rQ r r r r � s zLFUCache.__setitem__c C rS r. r_ rT r r r r7 � rV zLFUCache.__delitem__c C sH z | j �d�\\}}W n ty tdt| �j �d�w || �|�fS )z@Remove and return the `(key, value)` pair least frequently used.r rX N)r^ � most_commonr3 r/ r[ r r )r r2 r r r r r4 � s �zLFUCache.popitemr. ) r r r rG r) r r r r7 r4 r r r r r � s r c @ �T e Zd ZdZddd�Zejfdd�Zejfdd�Zejfd d �Zd d � Z d d� Z dS )r z/Least Recently Used (LRU) cache implementation.Nc C rK r. )r r) rL rM �_LRUCache__orderr' r r r r) � rO zLRUCache.__init__c C � || |�}|| v r| � |� |S r. ��_LRUCache__updater` r r r r � � zLRUCache.__getitem__c C � || ||� | � |� d S r. rf rQ r r r r � � zLRUCache.__setitem__c C rS r. )rd rT r r r r7 � rV zLRUCache.__delitem__c C rW )z>Remove and return the `(key, value)` pair least recently used.rX N)rY r; rd rZ r/ r[ r r r1 r r r r4 � r\ zLRUCache.popitemc C s2 z | j �|� W d S ty d | j |< Y d S w r. )rd rP r/ r1 r r r �__update� s �zLRUCache.__updater. ) r r r rG r) r r r r7 r4 rg r r r r r � s r c @ rc )r z.Most Recently Used (MRU) cache implementation.Nc C s6 ddl m} |dtdd� t�| ||� t�� | _d S )Nr )�warnzMRUCache is deprecated� )� stacklevel)�warningsrl �DeprecationWarningr r) rL rM �_MRUCache__order)r r( r! rl r r r r) � s zMRUCache.__init__c C re r. ��_MRUCache__updater` r r r r � rh zMRUCache.__getitem__c C ri r. rr rQ r r r r rj zMRUCache.__setitem__c C rS r. )rq rT r r r r7 rV zMRUCache.__delitem__c C rW )z=Remove and return the `(key, value)` pair most recently used.rX N)rY r; rq rZ r/ r[ r r r1 r r r r4 r\ zMRUCache.popitemc C s6 z | j j|dd� W d S ty d | j |< Y d S w )NF)�last)rq rP r/ r1 r r r rk s �zMRUCache.__updater. ) r r r rG r) r r r r7 r4 rs r r r r r � s r c @ s4 e Zd ZdZejdfdd�Zedd� �Zdd� ZdS ) r z-Random Replacement (RR) cache implementation.Nc C s t �| ||� || _d S r. )r r) �_RRCache__choice)r r( �choicer! r r r r) s zRRCache.__init__c C rD )z(The `choice` function used by the cache.)ru r, r r r rv rE zRRCache.choicec C sD z | � t| ��}W n ty tdt| �j �d�w || �|�fS )z/Remove and return a random `(key, value)` pair.rX N)ru �list� IndexErrorr/ r[ r r r1 r r r r4 % r\ zRRCache.popitem) r r r rG �randomrv r) rI r4 r r r r r s r c s� e Zd ZdZG dd� d�Zejdfdd�Zej fdd�Z ej fd d �Z e � fd d ��Z e d d� �Z dd� Zdd� Zdd� Zdd� Z� ZS )� _TimedCachez0Base class for time aware cache implementations.c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd S )z_TimedCache._Timerc C s || _ d| _d S r )� _Timer__timer�_Timer__nesting)r �timerr r r r) 3 � z_TimedCache._Timer.__init__c C s | j dkr | �� S | jS r �r| r{ � _Timer__timer, r r r �__call__7 s z_TimedCache._Timer.__call__c C s2 | j dkr | �� | _}n| j}| j d7 _ |S )Nr r r �r �timer r r � __enter__= s z _TimedCache._Timer.__enter__c G s | j d8 _ d S r )r| )r �excr r r �__exit__E � z_TimedCache._Timer.__exit__c C s t j| jffS r. )rz �_Timerr{ r, r r r � __reduce__H � z _TimedCache._Timer.__reduce__c C s t | j|�S r. )�getattrr{ )r �namer r r � __getattr__K � z _TimedCache._Timer.__getattr__N) r r r r) r� r� r� r� r� r r r r r� 2 s r� Nc C s t �| ||� t�|�| _d S r. )r r) rz r� �_TimedCache__timer)r r( r} r! r r r r) N s z_TimedCache.__init__c C �< | j �}| �|� || �W d � S 1 sw Y d S r. �r� �expire)r � cache_reprr� r r r r- R � $�z_TimedCache.__repr__c C r� r. r� )r � cache_lenr� r r r r> W r� z_TimedCache.__len__c s< | j �}| �|� t� jW d � S 1 sw Y d S r. )r� r� �superrF r� �r* r r rF \ s $�z_TimedCache.currsizec C rD )z%The timer function used by the cache.)r� r, r r r r} b rE z_TimedCache.timerc C s@ | j �}| �|� t�| � W d � d S 1 sw Y d S r. )r� r� r �clearr� r r r r� g s "�z_TimedCache.clearc O �B | j � tj| g|�R i |��W d � S 1 sw Y d S r. )r� r r@ �r �args�kwargsr r r r@ l � $�z_TimedCache.getc O r� r. )r� r r r� r r r r p r� z_TimedCache.popc O r� r. )r� r rC r� r r r rC t r� z_TimedCache.setdefault)r r r rG r� r� � monotonicr) r r- r> rI rF r} r� r@ r rC � __classcell__r r r� r rz / s rz c @ s� e Zd ZdZG dd� d�Zejdfdd�Zdd� Ze j fd d �Z e j fd d �Z e j fd d�Z dd� Z dd� Zedd� �Zddd�Zdd� Zdd� ZdS ) r z@LRU Cache implementation with per-item time-to-live (TTL) value.c @ s* e Zd ZdZd dd�Zdd� Zdd� ZdS ) zTTLCache._Link)r2 �expiresrY �prevNc C s || _ || _d S r. )r2 r� �r r2 r� r r r r) r~ zTTLCache._Link.__init__c C s t j| j| jffS r. )r �_Linkr2 r� r, r r r r� � r� zTTLCache._Link.__reduce__c C s | j }| j}||_ ||_d S r. )rY r� )r rY r� r r r �unlink� s zTTLCache._Link.unlink�NN)r r r r r) r� r� r r r r r� | s r� Nc C s> t �| |||� t�� | _}| |_|_t�� | _ || _ d S r. ) rz r) r r� �_TTLCache__rootr� rY rL rM �_TTLCache__links�_TTLCache__ttl)r r( �ttlr} r! �rootr r r r) � s zTTLCache.__init__c C �2 z| j | }W n ty Y dS w | �� |jk S �NF)r� r/ r} r� )r r2 �linkr r r r8 � � �zTTLCache.__contains__c C �N z| � |�}W n ty d}Y n w | �� |jk }|r"| �|�S || |�S r� )�_TTLCache__getlinkr/ r} r� r0 )r r2 ra r� �expiredr r r r � � � zTTLCache.__getitem__c C s� | j �}| �|� || ||� W d � n1 sw Y z| �|�}W n ty8 t�|� | j|< }Y nw |�� || j |_ | j |_ }|j |_ }| |_ |_ d S r. ) r} r� r� r/ r r� r� r� r� r� r� rY r� )r r2 r rR r� r� r� r� r r r r � s � � zTTLCache.__setitem__c C s8 || |� | j �|�}|�� | �� |jk st|��d S r. )r� r r� r} r� r/ )r r2 rU r� r r r r7 � s �zTTLCache.__delitem__c c sd � | j }|j}||ur0| j�}||jk r|jV W d � n1 s"w Y |j}||us d S d S r. )r� rY r} r� r2 )r r� �currr� r r r r< � s � � ��zTTLCache.__iter__c C sj | j �|� | j}| |_|_t| j�� dd� d�D ]}||_|j |_}| |_|_q| �| � � � d S )Nc S rD r. �r� )�objr r r �<lambda>� s z'TTLCache.__setstate__.<locals>.<lambda>)r2 ) �__dict__�updater� r� rY �sortedr� �valuesr� r} )r �stater� r� r� r r r � __setstate__� s zTTLCache.__setstate__c C rD )z,The time-to-live value of the cache's items.)r� r, r r r r� � rE z TTLCache.ttlc C s� |du r| � � }| j}|j}| j}g }tj}tj}||urJ||jk sJ|�|j || |j �f� || |j � ||j = |j}|� � |}||urJ||jk r"|S )�qRemove expired items from the cache and return an iterable of the expired `(key, value)` pairs. N) r} r� rY r� r r7 r r� �appendr2 r� ) r r� r� r� �linksr� rU ra rY r r r r� � s" �zTTLCache.expirec C sx | j �/}| �|� z tt| j��}W n ty# tdt| �j �d�w || � |�fW d � S 1 s5w Y dS �zmRemove and return the `(key, value)` pair least recently used that has not already expired. rX N) r} r� rY r; r� rZ r/ r[ r r �r r� r2 r r r r4 � s � $�zTTLCache.popitemc C � | j | }| j �|� |S r. )r� rP �r r2 r r r r � __getlink� � zTTLCache.__getlinkr. )r r r rG r� r� r� r) r8 r r r r7 r< r� rI r� r� r4 r� r r r r r y s r c @ s� e Zd ZdZejG dd� d��Zejdfdd�Z dd� Z e j fd d �Z e j fd d �Z e jfd d�Zdd� Zedd� �Zddd�Zdd� Zdd� ZdS )r z;Time aware Least Recently Used (TLRU) cache implementation.c @ s" e Zd ZdZddd�Zdd� ZdS )zTLRUCache._Item�r2 r� �removedNc C s || _ || _d| _d S r� r� r� r r r r) s zTLRUCache._Item.__init__c C s | j |j k S r. r� )r �otherr r r �__lt__ r� zTLRUCache._Item.__lt__r� )r r r r r) r� r r r r �_Item s r� Nc C s* t �| |||� t�� | _g | _|| _d S r. )rz r) rL rM �_TLRUCache__items�_TLRUCache__order�_TLRUCache__ttu)r r( �ttur} r! r r r r) s zTLRUCache.__init__c C r� r� )r� r/ r} r� )r r2 �itemr r r r8 r� zTLRUCache.__contains__c C r� r� )�_TLRUCache__getitemr/ r} r� r0 )r r2 ra r� r� r r r r r� zTLRUCache.__getitem__c C s� | j �'}| �|||�}||k s W d � d S | �|� || ||� W d � n1 s-w Y zd| �|�_W n tyC Y nw t�||� | j|< }t � | j |� d S �NT) r} r� r� r� r� r/ r r� r� �heapq�heappushr� )r r2 r rR r� r� r� r r r r ) s � � �zTLRUCache.__setitem__c C sX | j � }|| |� W d � n1 sw Y | j�|�}d|_||jk s*t|��d S r� )r} r� r r� r� r/ )r r2 rU r� r� r r r r7 9 s � �zTLRUCache.__delitem__c c sP � | j D ]!}| j�}||jk r|js|jV W d � n1 s w Y qd S r. )r� r} r� r� r2 )r r� r� r r r r< B s � � ���zTLRUCache.__iter__c C rD )z1The local time-to-use function used by the cache.)r� r, r r r r� I rE z TLRUCache.ttuc C s� |du r| � � }| j}| j}t|�t|�d kr'dd� |D � | _}t�|� g }tj}tj}|ri|d j s=||d j k sit� |�}|j s[|� |j || |j �f� || |j � ||j = |ri|d j s=||d j k r=|S )r� Nrm c S s g | ]}|j s|�qS r )r� )�.0r� r r r � <listcomp>Y s z$TLRUCache.expire.<locals>.<listcomp>r )r} r� r� r= r� �heapifyr r7 r r� r� �heappopr� r2 )r r� �items�orderr� rU ra r� r r r r� N s$ �zTLRUCache.expirec C sv | j �.}| �|� z tt| j��}W n ty" td| jj �d�w || � |�fW d � S 1 s4w Y dS r� ) r} r� rY r; r� rZ r/ r* r r r� r r r r4 f s � $�zTLRUCache.popitemc C r� r. )r� rP r� r r r � __getitemt r� zTLRUCache.__getitemr. )r r r rG � functools�total_orderingr� r� r� r) r8 r r r r7 r< rI r� r� r4 r� r r r r r s r � CacheInfo)�hits�missesr( rF Fc s � ���fdd�}|S )z_Decorator to wrap a function with a memoizing callable that saves results in a cache. c s� �r)t � t�r� fdd�}nt � tjj�r � fdd�}ndd� }t| � ��|�}nt| � ��d �}� |_�|_�|_t � || �S )Nc s t | |� j� j�S r. )� _CacheInfor( rF �r� r� ��cacher r � make_info� r� z,cached.<locals>.decorator.<locals>.make_infoc s t | |d t� ��S r. )r� r= r� r� r r r� � r� c S s t | |dd�S r )r� r� r r r r� � r� ) � isinstancer rL �abc�Mappingr r� � cache_key� cache_lockr� �update_wrapper)�funcr� �wrapper�r� �infor2 �lockr r � decorator� s zcached.<locals>.decoratorr )r� r2 r� r� r� r r� r r s r c s � ��fdd�}|S )zoDecorator to wrap a class or instance method with a memoizing callable that saves results in a cache. c sj �d u r��� fdd�}�fdd�}n���� fdd�}��fdd�}�|_ �|_�|_||_t�|� �S )Nc s� � | �}|d u r�| g|�R i |��S �| g|�R i |��}z|| W S t y, Y nw �| g|�R i |��}z|||< W |S tyI Y |S w r. )r/ r3 �r r� r� �c�k�v)r� r2 �methodr r r� � s" � ��z0cachedmethod.<locals>.decorator.<locals>.wrapperc s � | �}|d ur|� � d S d S r. �r� �r r� r� r r r� � s �z.cachedmethod.<locals>.decorator.<locals>.clearc s� � | �}|d u r�| g|�R i |��S �| g|�R i |��}z�| �� || W d � W S 1 s3w Y W n t yB Y nw �| g|�R i |��}z �| �� |�||�W d � W S 1 sew Y W d S tyw | Y S w r. )r/ rC r3 r� )r� r2 r� r� r r r� � s& &� � (� �c sJ � | �}|d ur#�| �� |� � W d � d S 1 s w Y d S d S r. r� r� )r� r� r r r� � s "��)r� r� r� � cache_clearr� r� )r� r� r� �r� r2 r� )r� r r� � s z cachedmethod.<locals>.decoratorr )r� r2 r� r� r r� r r � s 9r ) rG �__all__� __version__rL �collections.abcr� r� ry r� � r � _decoratorsr r r� �MutableMappingr r r r r r rz r r � namedtupler� �hashkeyr � methodkeyr r r r r �<module> s6 f %)J z�$PK ��Z���{ { __pycache__/keys.cpython-310.pycnu �[��� o �h� � @ sB d Z dZG dd� de�ZefZdd� Zdd� Zdd � Zd d � Zd S ) z'Key functions for memoizing decorators.)�hashkey� methodkey�typedkey�typedmethodkeyc @ sF e Zd ZdZdZejfdd�Zejfdd�Zejfdd�Zd d � Z dS ) � _HashedTuplez�A tuple that ensures that hash() will be called no more than once per element, since cache decorators will hash the key multiple times on a cache miss. See also _HashedSeq in the standard library functools implementation. Nc C s | j }|d u r|| � | _ }|S �N)�_HashedTuple__hashvalue)�self�hash� hashvalue� r �E/usr/local/CyberPanel/lib/python3.10/site-packages/cachetools/keys.py�__hash__ s z_HashedTuple.__hash__c C s t || |��S r �r �r �other�addr r r �__add__ � z_HashedTuple.__add__c C s t ||| ��S r r r r r r �__radd__ r z_HashedTuple.__radd__c C s i S r r )r r r r � __getstate__ s z_HashedTuple.__getstate__) �__name__� __module__� __qualname__�__doc__r �tupler r r r r r r r r s r c O s& |rt | tt|�� �t� �S t | �S )z8Return a cache key for the specified hashable arguments.)r �sum�sorted�items�_kwmark)�args�kwargsr r r r % s r c O � t |i |��S )z/Return a cache key for use with cached methods.)r �r r r r r r r . � r c O sF t | i |��}|tdd� | D ��7 }|tdd� t|�� �D ��7 }|S )z>Return a typed cache key for the specified hashable arguments.c s s � | ]}t |�V qd S r ��type)�.0�vr r r � <genexpr>7 s � ztypedkey.<locals>.<genexpr>c s s � | ] \}}t |�V qd S r r$ )r& �_r' r r r r( 8 s � )r r r r )r r �keyr r r r 3 s r c O r! )z5Return a typed cache key for use with cached methods.)r r" r r r r < r# r N) r �__all__r r r r r r r r r r r �<module> s PK ��Zk�{�. . __pycache__/func.cpython-310.pycnu �[��� o �h� � @ s� d Z dZddlZddlZddlZzddlmZ W n ey' ddlmZ Y nw ddl m Z m Z m Z m Z mZmZ ddl mZ ddl mZ G d d � d e�Zd d � Zd dd�Zd dd�Zd dd�Zd dd�Zd ejdfdd�Zd dejdfdd�ZdS ) z?`functools.lru_cache` compatible memoizing function decorators.)� fifo_cache� lfu_cache� lru_cache� mru_cache�rr_cache� ttl_cache� N)�RLock� )� FIFOCache�LFUCache�LRUCache�MRUCache�RRCache�TTLCache)�cached)�keysc @ s e Zd Zdd� Zedd� �ZdS )�_UnboundTTLCachec C s t �| tj||� d S �N)r �__init__�math�inf)�self�ttl�timer� r �E/usr/local/CyberPanel/lib/python3.10/site-packages/cachetools/func.pyr s z_UnboundTTLCache.__init__c C s d S r r )r r r r �maxsize s z_UnboundTTLCache.maxsizeN)�__name__� __module__� __qualname__r �propertyr r r r r r s r c s � ��fdd�}|S )Nc s: �rt jnt j}t� |t� dd�| �}��fdd�|_|S )NT)�cache�key�lock�infoc s � �d�S )N�r �typedr r r% r r �<lambda> s z+_cache.<locals>.decorator.<locals>.<lambda>)r �typedkey�hashkeyr r �cache_parameters)�funcr" �wrapper�r! r r& r r � decorator s z_cache.<locals>.decoratorr )r! r r& r. r r- r �_cache s r/ � Fc C �@ | du r t i d|�S t| �rt td�d|�| �S t t| �| |�S )z�Decorator to wrap a function with a memoizing callable that saves up to `maxsize` results based on a First In First Out (FIFO) algorithm. Nr0 )r/ �callabler r% r r r r & � r c C r1 )z�Decorator to wrap a function with a memoizing callable that saves up to `maxsize` results based on a Least Frequently Used (LFU) algorithm. Nr0 )r/ r2 r r% r r r r 4 r3 r c C r1 )z�Decorator to wrap a function with a memoizing callable that saves up to `maxsize` results based on a Least Recently Used (LRU) algorithm. Nr0 )r/ r2 r r% r r r r B r3 r c C sZ ddl m} |dtdd� | du rti d|�S t| �r%ttd�d|�| �S tt| �| |�S )z�Decorator to wrap a function with a memoizing callable that saves up to `maxsize` results based on a Most Recently Used (MRU) algorithm. r )�warnz@mru_cache is deprecated� )� stacklevelNr0 )�warningsr4 �DeprecationWarningr/ r2 r )r r& r4 r r r r P s r c C sD | du r t i d|�S t| �rt td|�d|�| �S t t| |�| |�S )z�Decorator to wrap a function with a memoizing callable that saves up to `maxsize` results based on a Random Replacement (RR) algorithm. Nr0 )r/ r2 r )r �choicer& r r r r a s r iX c C sN | du r t t||�d|�S t| �r t td||�d|�| �S t t| ||�| |�S )z�Decorator to wrap a function with a memoizing callable that saves up to `maxsize` results based on a Least Recently Used (LRU) algorithm with a per-item time-to-live (TTL) value. Nr0 )r/ r r2 r )r r r r& r r r r o s r )r0 F) �__doc__�__all__r �random�time� threadingr � ImportError�dummy_threading� r r r r r r r r r r/ r r r r r9 r � monotonicr r r r r �<module> s* � PK ��Z�}/�� � ' __pycache__/_decorators.cpython-310.pycnu �[��� o �h� � @ s@ d Z dd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� ZdS )z'Extensible memoizing decorator helpers.c sR d ��� �����fdd�}� ���fdd�}����fdd�}||_ ||_|S )N� c s� �| i |��}��( z� | }�d7 �|W W d � S t y) �d7 �Y nw W d � n1 s4w Y �| i |��}��" z� �||�W W d � S tyc | Y W d � S w 1 sgw Y d S �N� ��KeyError� setdefault� ValueError��args�kwargs�k�result�v)�cache�func�hits�key�lock�misses� �L/usr/local/CyberPanel/lib/python3.10/site-packages/cachetools/_decorators.py�wrapper s, � � � � ��z$_cached_locked_info.<locals>.wrapperc s: �� � � � d ��W d � d S 1 sw Y d S �Nr ��clearr )r r r r r r � cache_clear s "�z(_cached_locked_info.<locals>.cache_clearc s2 �� �� ��W d � S 1 sw Y d S �Nr r )r �infor r r r � cache_info s $�z'_cached_locked_info.<locals>.cache_info�r r )r r r r r r r r r )r r r r r r r r �_cached_locked_info s r c sH d ��� ����fdd�}� ��fdd�}||_ ���fdd�|_|S )Nr c sr �| i |��}z � | }�d7 �|W S t y �d7 �Y nw �| i |��}z|� |< W |S ty8 Y |S w r �r r r )r r r r r r r r + s � ��z&_cached_unlocked_info.<locals>.wrapperc s � � � d ��d S r r r )r r r r r r ; s z*_cached_unlocked_info.<locals>.cache_clearc s �� ��S r r r )r r r r r �<lambda>A � z'_cached_unlocked_info.<locals>.<lambda>r )r r r r r r r )r r r r r r r �_cached_unlocked_info( s r# c s8 d�� �fdd�}�fdd�}||_ ��fdd�|_|S )Nr c s �d7 �� | i |��S r r �r r )r r r r r H s z _uncached_info.<locals>.wrapperc s d� d S r r r )r r r r M s z#_uncached_info.<locals>.cache_clearc s � d��S r r r )r r r r r! R r" z _uncached_info.<locals>.<lambda>r )r r r r r )r r r r �_uncached_infoE s r% c s* � ���fdd�}� �fdd�}||_ |S )Nc s� �| i |��}�� z � | W W d � S t y Y nw W d � n1 s*w Y �| i |��}��" z� �||�W W d � S tyY | Y W d � S w 1 s]w Y d S r r �r r r r �r r r r r r r W s( � � � � ��z _cached_locked.<locals>.wrapperc s2 �� � � � W d � d S 1 sw Y d S r r r )r r r r r f s "�z#_cached_locked.<locals>.cache_clear�r )r r r r r r r r' r �_cached_lockedV s r) c s" � ��fdd�}� fdd�|_ |S )Nc s^ �| i |��}z� | W S t y Y nw �| i |��}z|� |< W |S ty. Y |S w r r r& �r r r r r r o s � ��z!_cached_unlocked.<locals>.wrapperc s � � � S r r r )r r r r! | s z"_cached_unlocked.<locals>.<lambda>r( )r r r r r r* r �_cached_unlockedn s r+ c s � fdd�}dd� |_ |S )Nc s � | i |��S r r r$ �r r r r � s z_uncached.<locals>.wrapperc S s d S r r r r r r r! � s z_uncached.<locals>.<lambda>r( )r r r r, r � _uncached� s r- c C s� |d ur&|d u rt | |�}|S |d u r t| |||�}|S t| ||||�}|S |d u r/t| �}n|d u r:t| ||�}nt| |||�}d |_|S r )r% r# r r- r+ r) r )r r r r r r r r r �_cached_wrapper� s � � � r. N)�__doc__r r# r% r) r+ r- r. r r r r �<module> s $ PK ��Z-: v� � _decorators.pynu �[��� """Extensible memoizing decorator helpers.""" def _cached_locked_info(func, cache, key, lock, info): hits = misses = 0 def wrapper(*args, **kwargs): nonlocal hits, misses k = key(*args, **kwargs) with lock: try: result = cache[k] hits += 1 return result except KeyError: misses += 1 v = func(*args, **kwargs) with lock: try: # in case of a race, prefer the item already in the cache return cache.setdefault(k, v) except ValueError: return v # value too large def cache_clear(): nonlocal hits, misses with lock: cache.clear() hits = misses = 0 def cache_info(): with lock: return info(hits, misses) wrapper.cache_clear = cache_clear wrapper.cache_info = cache_info return wrapper def _cached_unlocked_info(func, cache, key, info): hits = misses = 0 def wrapper(*args, **kwargs): nonlocal hits, misses k = key(*args, **kwargs) try: result = cache[k] hits += 1 return result except KeyError: misses += 1 v = func(*args, **kwargs) try: cache[k] = v except ValueError: pass # value too large return v def cache_clear(): nonlocal hits, misses cache.clear() hits = misses = 0 wrapper.cache_clear = cache_clear wrapper.cache_info = lambda: info(hits, misses) return wrapper def _uncached_info(func, info): misses = 0 def wrapper(*args, **kwargs): nonlocal misses misses += 1 return func(*args, **kwargs) def cache_clear(): nonlocal misses misses = 0 wrapper.cache_clear = cache_clear wrapper.cache_info = lambda: info(0, misses) return wrapper def _cached_locked(func, cache, key, lock): def wrapper(*args, **kwargs): k = key(*args, **kwargs) with lock: try: return cache[k] except KeyError: pass # key not found v = func(*args, **kwargs) with lock: try: # in case of a race, prefer the item already in the cache return cache.setdefault(k, v) except ValueError: return v # value too large def cache_clear(): with lock: cache.clear() wrapper.cache_clear = cache_clear return wrapper def _cached_unlocked(func, cache, key): def wrapper(*args, **kwargs): k = key(*args, **kwargs) try: return cache[k] except KeyError: pass # key not found v = func(*args, **kwargs) try: cache[k] = v except ValueError: pass # value too large return v wrapper.cache_clear = lambda: cache.clear() return wrapper def _uncached(func): def wrapper(*args, **kwargs): return func(*args, **kwargs) wrapper.cache_clear = lambda: None return wrapper def _cached_wrapper(func, cache, key, lock, info): if info is not None: if cache is None: wrapper = _uncached_info(func, info) elif lock is None: wrapper = _cached_unlocked_info(func, cache, key, info) else: wrapper = _cached_locked_info(func, cache, key, lock, info) else: if cache is None: wrapper = _uncached(func) elif lock is None: wrapper = _cached_unlocked(func, cache, key) else: wrapper = _cached_locked(func, cache, key, lock) wrapper.cache_info = None return wrapper PK ��ZL�1�� � keys.pynu �[��� """Key functions for memoizing decorators.""" __all__ = ("hashkey", "methodkey", "typedkey", "typedmethodkey") class _HashedTuple(tuple): """A tuple that ensures that hash() will be called no more than once per element, since cache decorators will hash the key multiple times on a cache miss. See also _HashedSeq in the standard library functools implementation. """ __hashvalue = None def __hash__(self, hash=tuple.__hash__): hashvalue = self.__hashvalue if hashvalue is None: self.__hashvalue = hashvalue = hash(self) return hashvalue def __add__(self, other, add=tuple.__add__): return _HashedTuple(add(self, other)) def __radd__(self, other, add=tuple.__add__): return _HashedTuple(add(other, self)) def __getstate__(self): return {} # used for separating keyword arguments; we do not use an object # instance here so identity is preserved when pickling/unpickling _kwmark = (_HashedTuple,) def hashkey(*args, **kwargs): """Return a cache key for the specified hashable arguments.""" if kwargs: return _HashedTuple(args + sum(sorted(kwargs.items()), _kwmark)) else: return _HashedTuple(args) def methodkey(self, *args, **kwargs): """Return a cache key for use with cached methods.""" return hashkey(*args, **kwargs) def typedkey(*args, **kwargs): """Return a typed cache key for the specified hashable arguments.""" key = hashkey(*args, **kwargs) key += tuple(type(v) for v in args) key += tuple(type(v) for _, v in sorted(kwargs.items())) return key def typedmethodkey(self, *args, **kwargs): """Return a typed cache key for use with cached methods.""" return typedkey(*args, **kwargs) PK ��Z\�WЇ � func.pynu �[��� """`functools.lru_cache` compatible memoizing function decorators.""" __all__ = ("fifo_cache", "lfu_cache", "lru_cache", "mru_cache", "rr_cache", "ttl_cache") import math import random import time try: from threading import RLock except ImportError: # pragma: no cover from dummy_threading import RLock from . import FIFOCache, LFUCache, LRUCache, MRUCache, RRCache, TTLCache from . import cached from . import keys class _UnboundTTLCache(TTLCache): def __init__(self, ttl, timer): TTLCache.__init__(self, math.inf, ttl, timer) @property def maxsize(self): return None def _cache(cache, maxsize, typed): def decorator(func): key = keys.typedkey if typed else keys.hashkey wrapper = cached(cache=cache, key=key, lock=RLock(), info=True)(func) wrapper.cache_parameters = lambda: {"maxsize": maxsize, "typed": typed} return wrapper return decorator def fifo_cache(maxsize=128, typed=False): """Decorator to wrap a function with a memoizing callable that saves up to `maxsize` results based on a First In First Out (FIFO) algorithm. """ if maxsize is None: return _cache({}, None, typed) elif callable(maxsize): return _cache(FIFOCache(128), 128, typed)(maxsize) else: return _cache(FIFOCache(maxsize), maxsize, typed) def lfu_cache(maxsize=128, typed=False): """Decorator to wrap a function with a memoizing callable that saves up to `maxsize` results based on a Least Frequently Used (LFU) algorithm. """ if maxsize is None: return _cache({}, None, typed) elif callable(maxsize): return _cache(LFUCache(128), 128, typed)(maxsize) else: return _cache(LFUCache(maxsize), maxsize, typed) def lru_cache(maxsize=128, typed=False): """Decorator to wrap a function with a memoizing callable that saves up to `maxsize` results based on a Least Recently Used (LRU) algorithm. """ if maxsize is None: return _cache({}, None, typed) elif callable(maxsize): return _cache(LRUCache(128), 128, typed)(maxsize) else: return _cache(LRUCache(maxsize), maxsize, typed) def mru_cache(maxsize=128, typed=False): """Decorator to wrap a function with a memoizing callable that saves up to `maxsize` results based on a Most Recently Used (MRU) algorithm. """ from warnings import warn warn("@mru_cache is deprecated", DeprecationWarning, stacklevel=2) if maxsize is None: return _cache({}, None, typed) elif callable(maxsize): return _cache(MRUCache(128), 128, typed)(maxsize) else: return _cache(MRUCache(maxsize), maxsize, typed) def rr_cache(maxsize=128, choice=random.choice, typed=False): """Decorator to wrap a function with a memoizing callable that saves up to `maxsize` results based on a Random Replacement (RR) algorithm. """ if maxsize is None: return _cache({}, None, typed) elif callable(maxsize): return _cache(RRCache(128, choice), 128, typed)(maxsize) else: return _cache(RRCache(maxsize, choice), maxsize, typed) def ttl_cache(maxsize=128, ttl=600, timer=time.monotonic, typed=False): """Decorator to wrap a function with a memoizing callable that saves up to `maxsize` results based on a Least Recently Used (LRU) algorithm with a per-item time-to-live (TTL) value. """ if maxsize is None: return _cache(_UnboundTTLCache(ttl, timer), None, typed) elif callable(maxsize): return _cache(TTLCache(128, ttl, timer), 128, typed)(maxsize) else: return _cache(TTLCache(maxsize, ttl, timer), maxsize, typed) PK ��Z�©+U +U __init__.pynu �[��� """Extensible memoizing collections and decorators.""" __all__ = ( "Cache", "FIFOCache", "LFUCache", "LRUCache", "MRUCache", "RRCache", "TLRUCache", "TTLCache", "cached", "cachedmethod", ) __version__ = "5.5.2" import collections import collections.abc import functools import heapq import random import time from . import keys from ._decorators import _cached_wrapper class _DefaultSize: __slots__ = () def __getitem__(self, _): return 1 def __setitem__(self, _, value): assert value == 1 def pop(self, _): return 1 class Cache(collections.abc.MutableMapping): """Mutable mapping to serve as a simple cache or cache base class.""" __marker = object() __size = _DefaultSize() def __init__(self, maxsize, getsizeof=None): if getsizeof: self.getsizeof = getsizeof if self.getsizeof is not Cache.getsizeof: self.__size = dict() self.__data = dict() self.__currsize = 0 self.__maxsize = maxsize def __repr__(self): return "%s(%s, maxsize=%r, currsize=%r)" % ( self.__class__.__name__, repr(self.__data), self.__maxsize, self.__currsize, ) def __getitem__(self, key): try: return self.__data[key] except KeyError: return self.__missing__(key) def __setitem__(self, key, value): maxsize = self.__maxsize size = self.getsizeof(value) if size > maxsize: raise ValueError("value too large") if key not in self.__data or self.__size[key] < size: while self.__currsize + size > maxsize: self.popitem() if key in self.__data: diffsize = size - self.__size[key] else: diffsize = size self.__data[key] = value self.__size[key] = size self.__currsize += diffsize def __delitem__(self, key): size = self.__size.pop(key) del self.__data[key] self.__currsize -= size def __contains__(self, key): return key in self.__data def __missing__(self, key): raise KeyError(key) def __iter__(self): return iter(self.__data) def __len__(self): return len(self.__data) def get(self, key, default=None): if key in self: return self[key] else: return default def pop(self, key, default=__marker): if key in self: value = self[key] del self[key] elif default is self.__marker: raise KeyError(key) else: value = default return value def setdefault(self, key, default=None): if key in self: value = self[key] else: self[key] = value = default return value @property def maxsize(self): """The maximum size of the cache.""" return self.__maxsize @property def currsize(self): """The current size of the cache.""" return self.__currsize @staticmethod def getsizeof(value): """Return the size of a cache element's value.""" return 1 class FIFOCache(Cache): """First In First Out (FIFO) cache implementation.""" def __init__(self, maxsize, getsizeof=None): Cache.__init__(self, maxsize, getsizeof) self.__order = collections.OrderedDict() def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): cache_setitem(self, key, value) try: self.__order.move_to_end(key) except KeyError: self.__order[key] = None def __delitem__(self, key, cache_delitem=Cache.__delitem__): cache_delitem(self, key) del self.__order[key] def popitem(self): """Remove and return the `(key, value)` pair first inserted.""" try: key = next(iter(self.__order)) except StopIteration: raise KeyError("%s is empty" % type(self).__name__) from None else: return (key, self.pop(key)) class LFUCache(Cache): """Least Frequently Used (LFU) cache implementation.""" def __init__(self, maxsize, getsizeof=None): Cache.__init__(self, maxsize, getsizeof) self.__counter = collections.Counter() def __getitem__(self, key, cache_getitem=Cache.__getitem__): value = cache_getitem(self, key) if key in self: # __missing__ may not store item self.__counter[key] -= 1 return value def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): cache_setitem(self, key, value) self.__counter[key] -= 1 def __delitem__(self, key, cache_delitem=Cache.__delitem__): cache_delitem(self, key) del self.__counter[key] def popitem(self): """Remove and return the `(key, value)` pair least frequently used.""" try: ((key, _),) = self.__counter.most_common(1) except ValueError: raise KeyError("%s is empty" % type(self).__name__) from None else: return (key, self.pop(key)) class LRUCache(Cache): """Least Recently Used (LRU) cache implementation.""" def __init__(self, maxsize, getsizeof=None): Cache.__init__(self, maxsize, getsizeof) self.__order = collections.OrderedDict() def __getitem__(self, key, cache_getitem=Cache.__getitem__): value = cache_getitem(self, key) if key in self: # __missing__ may not store item self.__update(key) return value def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): cache_setitem(self, key, value) self.__update(key) def __delitem__(self, key, cache_delitem=Cache.__delitem__): cache_delitem(self, key) del self.__order[key] def popitem(self): """Remove and return the `(key, value)` pair least recently used.""" try: key = next(iter(self.__order)) except StopIteration: raise KeyError("%s is empty" % type(self).__name__) from None else: return (key, self.pop(key)) def __update(self, key): try: self.__order.move_to_end(key) except KeyError: self.__order[key] = None class MRUCache(Cache): """Most Recently Used (MRU) cache implementation.""" def __init__(self, maxsize, getsizeof=None): from warnings import warn warn("MRUCache is deprecated", DeprecationWarning, stacklevel=2) Cache.__init__(self, maxsize, getsizeof) self.__order = collections.OrderedDict() def __getitem__(self, key, cache_getitem=Cache.__getitem__): value = cache_getitem(self, key) if key in self: # __missing__ may not store item self.__update(key) return value def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): cache_setitem(self, key, value) self.__update(key) def __delitem__(self, key, cache_delitem=Cache.__delitem__): cache_delitem(self, key) del self.__order[key] def popitem(self): """Remove and return the `(key, value)` pair most recently used.""" try: key = next(iter(self.__order)) except StopIteration: raise KeyError("%s is empty" % type(self).__name__) from None else: return (key, self.pop(key)) def __update(self, key): try: self.__order.move_to_end(key, last=False) except KeyError: self.__order[key] = None class RRCache(Cache): """Random Replacement (RR) cache implementation.""" def __init__(self, maxsize, choice=random.choice, getsizeof=None): Cache.__init__(self, maxsize, getsizeof) self.__choice = choice @property def choice(self): """The `choice` function used by the cache.""" return self.__choice def popitem(self): """Remove and return a random `(key, value)` pair.""" try: key = self.__choice(list(self)) except IndexError: raise KeyError("%s is empty" % type(self).__name__) from None else: return (key, self.pop(key)) class _TimedCache(Cache): """Base class for time aware cache implementations.""" class _Timer: def __init__(self, timer): self.__timer = timer self.__nesting = 0 def __call__(self): if self.__nesting == 0: return self.__timer() else: return self.__time def __enter__(self): if self.__nesting == 0: self.__time = time = self.__timer() else: time = self.__time self.__nesting += 1 return time def __exit__(self, *exc): self.__nesting -= 1 def __reduce__(self): return _TimedCache._Timer, (self.__timer,) def __getattr__(self, name): return getattr(self.__timer, name) def __init__(self, maxsize, timer=time.monotonic, getsizeof=None): Cache.__init__(self, maxsize, getsizeof) self.__timer = _TimedCache._Timer(timer) def __repr__(self, cache_repr=Cache.__repr__): with self.__timer as time: self.expire(time) return cache_repr(self) def __len__(self, cache_len=Cache.__len__): with self.__timer as time: self.expire(time) return cache_len(self) @property def currsize(self): with self.__timer as time: self.expire(time) return super().currsize @property def timer(self): """The timer function used by the cache.""" return self.__timer def clear(self): with self.__timer as time: self.expire(time) Cache.clear(self) def get(self, *args, **kwargs): with self.__timer: return Cache.get(self, *args, **kwargs) def pop(self, *args, **kwargs): with self.__timer: return Cache.pop(self, *args, **kwargs) def setdefault(self, *args, **kwargs): with self.__timer: return Cache.setdefault(self, *args, **kwargs) class TTLCache(_TimedCache): """LRU Cache implementation with per-item time-to-live (TTL) value.""" class _Link: __slots__ = ("key", "expires", "next", "prev") def __init__(self, key=None, expires=None): self.key = key self.expires = expires def __reduce__(self): return TTLCache._Link, (self.key, self.expires) def unlink(self): next = self.next prev = self.prev prev.next = next next.prev = prev def __init__(self, maxsize, ttl, timer=time.monotonic, getsizeof=None): _TimedCache.__init__(self, maxsize, timer, getsizeof) self.__root = root = TTLCache._Link() root.prev = root.next = root self.__links = collections.OrderedDict() self.__ttl = ttl def __contains__(self, key): try: link = self.__links[key] # no reordering except KeyError: return False else: return self.timer() < link.expires def __getitem__(self, key, cache_getitem=Cache.__getitem__): try: link = self.__getlink(key) except KeyError: expired = False else: expired = not (self.timer() < link.expires) if expired: return self.__missing__(key) else: return cache_getitem(self, key) def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): with self.timer as time: self.expire(time) cache_setitem(self, key, value) try: link = self.__getlink(key) except KeyError: self.__links[key] = link = TTLCache._Link(key) else: link.unlink() link.expires = time + self.__ttl link.next = root = self.__root link.prev = prev = root.prev prev.next = root.prev = link def __delitem__(self, key, cache_delitem=Cache.__delitem__): cache_delitem(self, key) link = self.__links.pop(key) link.unlink() if not (self.timer() < link.expires): raise KeyError(key) def __iter__(self): root = self.__root curr = root.next while curr is not root: # "freeze" time for iterator access with self.timer as time: if time < curr.expires: yield curr.key curr = curr.next def __setstate__(self, state): self.__dict__.update(state) root = self.__root root.prev = root.next = root for link in sorted(self.__links.values(), key=lambda obj: obj.expires): link.next = root link.prev = prev = root.prev prev.next = root.prev = link self.expire(self.timer()) @property def ttl(self): """The time-to-live value of the cache's items.""" return self.__ttl def expire(self, time=None): """Remove expired items from the cache and return an iterable of the expired `(key, value)` pairs. """ if time is None: time = self.timer() root = self.__root curr = root.next links = self.__links expired = [] cache_delitem = Cache.__delitem__ cache_getitem = Cache.__getitem__ while curr is not root and not (time < curr.expires): expired.append((curr.key, cache_getitem(self, curr.key))) cache_delitem(self, curr.key) del links[curr.key] next = curr.next curr.unlink() curr = next return expired def popitem(self): """Remove and return the `(key, value)` pair least recently used that has not already expired. """ with self.timer as time: self.expire(time) try: key = next(iter(self.__links)) except StopIteration: raise KeyError("%s is empty" % type(self).__name__) from None else: return (key, self.pop(key)) def __getlink(self, key): value = self.__links[key] self.__links.move_to_end(key) return value class TLRUCache(_TimedCache): """Time aware Least Recently Used (TLRU) cache implementation.""" @functools.total_ordering class _Item: __slots__ = ("key", "expires", "removed") def __init__(self, key=None, expires=None): self.key = key self.expires = expires self.removed = False def __lt__(self, other): return self.expires < other.expires def __init__(self, maxsize, ttu, timer=time.monotonic, getsizeof=None): _TimedCache.__init__(self, maxsize, timer, getsizeof) self.__items = collections.OrderedDict() self.__order = [] self.__ttu = ttu def __contains__(self, key): try: item = self.__items[key] # no reordering except KeyError: return False else: return self.timer() < item.expires def __getitem__(self, key, cache_getitem=Cache.__getitem__): try: item = self.__getitem(key) except KeyError: expired = False else: expired = not (self.timer() < item.expires) if expired: return self.__missing__(key) else: return cache_getitem(self, key) def __setitem__(self, key, value, cache_setitem=Cache.__setitem__): with self.timer as time: expires = self.__ttu(key, value, time) if not (time < expires): return # skip expired items self.expire(time) cache_setitem(self, key, value) # removing an existing item would break the heap structure, so # only mark it as removed for now try: self.__getitem(key).removed = True except KeyError: pass self.__items[key] = item = TLRUCache._Item(key, expires) heapq.heappush(self.__order, item) def __delitem__(self, key, cache_delitem=Cache.__delitem__): with self.timer as time: # no self.expire() for performance reasons, e.g. self.clear() [#67] cache_delitem(self, key) item = self.__items.pop(key) item.removed = True if not (time < item.expires): raise KeyError(key) def __iter__(self): for curr in self.__order: # "freeze" time for iterator access with self.timer as time: if time < curr.expires and not curr.removed: yield curr.key @property def ttu(self): """The local time-to-use function used by the cache.""" return self.__ttu def expire(self, time=None): """Remove expired items from the cache and return an iterable of the expired `(key, value)` pairs. """ if time is None: time = self.timer() items = self.__items order = self.__order # clean up the heap if too many items are marked as removed if len(order) > len(items) * 2: self.__order = order = [item for item in order if not item.removed] heapq.heapify(order) expired = [] cache_delitem = Cache.__delitem__ cache_getitem = Cache.__getitem__ while order and (order[0].removed or not (time < order[0].expires)): item = heapq.heappop(order) if not item.removed: expired.append((item.key, cache_getitem(self, item.key))) cache_delitem(self, item.key) del items[item.key] return expired def popitem(self): """Remove and return the `(key, value)` pair least recently used that has not already expired. """ with self.timer as time: self.expire(time) try: key = next(iter(self.__items)) except StopIteration: raise KeyError("%s is empty" % self.__class__.__name__) from None else: return (key, self.pop(key)) def __getitem(self, key): value = self.__items[key] self.__items.move_to_end(key) return value _CacheInfo = collections.namedtuple( "CacheInfo", ["hits", "misses", "maxsize", "currsize"] ) def cached(cache, key=keys.hashkey, lock=None, info=False): """Decorator to wrap a function with a memoizing callable that saves results in a cache. """ def decorator(func): if info: if isinstance(cache, Cache): def make_info(hits, misses): return _CacheInfo(hits, misses, cache.maxsize, cache.currsize) elif isinstance(cache, collections.abc.Mapping): def make_info(hits, misses): return _CacheInfo(hits, misses, None, len(cache)) else: def make_info(hits, misses): return _CacheInfo(hits, misses, 0, 0) wrapper = _cached_wrapper(func, cache, key, lock, make_info) else: wrapper = _cached_wrapper(func, cache, key, lock, None) wrapper.cache = cache wrapper.cache_key = key wrapper.cache_lock = lock return functools.update_wrapper(wrapper, func) return decorator def cachedmethod(cache, key=keys.methodkey, lock=None): """Decorator to wrap a class or instance method with a memoizing callable that saves results in a cache. """ def decorator(method): if lock is None: def wrapper(self, *args, **kwargs): c = cache(self) if c is None: return method(self, *args, **kwargs) k = key(self, *args, **kwargs) try: return c[k] except KeyError: pass # key not found v = method(self, *args, **kwargs) try: c[k] = v except ValueError: pass # value too large return v def clear(self): c = cache(self) if c is not None: c.clear() else: def wrapper(self, *args, **kwargs): c = cache(self) if c is None: return method(self, *args, **kwargs) k = key(self, *args, **kwargs) try: with lock(self): return c[k] except KeyError: pass # key not found v = method(self, *args, **kwargs) # in case of a race, prefer the item already in the cache try: with lock(self): return c.setdefault(k, v) except ValueError: return v # value too large def clear(self): c = cache(self) if c is not None: with lock(self): c.clear() wrapper.cache = cache wrapper.cache_key = key wrapper.cache_lock = lock wrapper.cache_clear = clear return functools.update_wrapper(wrapper, method) return decorator PK ��Z�3��Y �Y $ __pycache__/__init__.cpython-310.pycnu �[��� PK ��Z���{ { KZ __pycache__/keys.cpython-310.pycnu �[��� PK ��Zk�{�. . d __pycache__/func.cpython-310.pycnu �[��� PK ��Z�}/�� � ' �s __pycache__/_decorators.cpython-310.pycnu �[��� PK ��Z-: v� � �� _decorators.pynu �[��� PK ��ZL�1�� � ە keys.pynu �[��� PK ��Z\�WЇ � � func.pynu �[��� PK ��Z�©+U +U �� __init__.pynu �[��� PK � '
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings