Mr.X

�


���?�����dZddlZddlmZddlmZmZmZm	Z	m
Z
ddlmZddl
mZddlmZmZd	�ZGd
�de	��ZGd�d
e��ZdS)zPersistent Data Types
�N)�OrderedDict)�	ItemsView�KeysView�MutableMapping�Sequence�
ValuesView)�contextmanager)�rmtree�)�ENOVAL�Cachec����fd�}d��j��|_d}|�|��|_|S)z,Make compare method with Sequence semantics.c�0��t|t��stSt|��}t|��}||kr �tjurdS�tjurdSt||��D]\}}||kr�||��cS��||��S)z&Compare method for deque and sequence.FT)�
isinstancer�NotImplemented�len�op�eq�ne�zip)�self�that�len_self�len_that�alpha�beta�seq_ops      ��t/builddir/build/BUILD/imunify360-venv-2.6.2/opt/imunify360/venv/lib/python3.11/site-packages/diskcache/persistent.py�comparez_make_compare.<locals>.compares�����$��)�)�	"�!�!��t�9�9���t�9�9���x���������u�������t��t�T�?�?�	+�	+�K�E�4���}�}��v�e�T�*�*�*�*�*���v�h��)�)�)�z__{0}__z/Return True if and only if deque is {0} `that`.)�format�__name__�__doc__)r�docr�doc_strs`   r�
_make_comparer&sS���*�*�*�*�*�(!�'�'���8�8�G��?�G��n�n�S�)�)�G�O��Nr c�*�eZdZdZd+d�Zed,d���Zed���Zed���Z	ed���Z
e
jd	���Z
d
�Zd�Z
d�Zd
�Zd�Zeejd��Zeejd��Zeejd��Zeejd��Zeejd��Zeejd��Zd�Zd�Z d�Z!d�Z"d�Z#d�Z$d�Z%e%Z&d�Z'e'Z(d�Z)e)Z*d�Z+d�Z,d �Z-e-Z.d!�Z/d"�Z0d#�Z1d$�Z2e2Z3d%�Z4e4Z5d&�Z6d'�Z7d-d)�Z8dZ9e:d*���Z;dS).�Dequea~Persistent sequence with double-ended queue semantics.

    Double-ended queue is an ordered collection with optimized access at its
    endpoints.

    Items are serialized to disk. Deque may be initialized from directory path
    where items are stored.

    >>> deque = Deque()
    >>> deque += range(5)
    >>> list(deque)
    [0, 1, 2, 3, 4]
    >>> for value in range(5):
    ...     deque.appendleft(-value)
    >>> len(deque)
    10
    >>> list(deque)
    [-4, -3, -2, -1, 0, 0, 1, 2, 3, 4]
    >>> deque.pop()
    4
    >>> deque.popleft()
    -4
    >>> deque.reverse()
    >>> list(deque)
    [3, 2, 1, 0, 0, -1, -2, -3]

    �Nc��t|d���|_|�td��n||_|�|��dS)aInitialize deque instance.

        If directory is None then temporary directory created. The directory
        will *not* be automatically removed.

        :param iterable: iterable of items to append to deque
        :param directory: deque directory (default None)

        �none��eviction_policyN�inf)r
�_cache�float�_maxlen�_extend)r�iterable�	directory�maxlens    r�__init__zDeque.__init__NsE���I�v�>�>�>���'-�~�u�U�|�|�|�6������X�����r c��|�|��}||_|�td��n||_|�|��|S)a�Initialize deque using `cache`.

        >>> cache = Cache()
        >>> deque = Deque.fromcache(cache, [5, 6, 7, 8])
        >>> deque.cache is cache
        True
        >>> len(deque)
        4
        >>> 7 in deque
        True
        >>> deque.popleft()
        5

        :param Cache cache: cache to use
        :param iterable: iterable of items
        :return: initialized Deque

        Nr.)�__new__r/r0r1r2)�cls�cacher3r5rs     r�	fromcachezDeque.fromcache\sH��*�{�{�3�������'-�~�u�U�|�|�|�6������X�����r c��|jS)zCache used by deque.�r/�rs rr:zDeque.cachew����{�r c��|jjS)z%Directory path where deque is stored.�r/r4r>s rr4zDeque.directory|����{�$�$r c��|jS)zMax length of the deque.)r1r>s rr5zDeque.maxlen�s���|�r c��||_|j�d���5t|j��|jkr1|���t|j��|jk�1ddd��dS#1swxYwYdS)aSet max length of the deque.

        Pops items from left while length greater than max.

        >>> deque = Deque()
        >>> deque.extendleft('abcde')
        >>> deque.maxlen = 3
        >>> list(deque)
        ['c', 'd', 'e']

        :param value: max length

        T��retryN)r1r/�transactr�_popleft�r�values  rr5zDeque.maxlen�s������
�[�
!�
!��
!�
-�
-�	 �	 ��d�k�"�"�T�\�1�1��
�
�����d�k�"�"�T�\�1�1�	 �	 �	 �	 �	 �	 �	 �	 �	 �	 �	 �	 ����	 �	 �	 �	 �	 �	 s�AA?�?B�Bc���t|��}|dkr[||krtd���|j���D]+}|dkr	||��cS#t$rY�"wxYw|dz}�,nb||krtd���|dz
}|j�d���D]+}|dkr	||��cS#t$rY�"wxYw|dz
}�,td���)Nrzdeque index out of rangerT��reverse)r�
IndexErrorr/�iterkeys�KeyError)r�index�funcr�keys     r�_indexzDeque._index�sD���t�9�9���A�:�:��� � � �!;�<�<�<��{�+�+�-�-�
�
���A�:�:�!�#�t�C�y�y�(�(�(��#�!�!�!� ��!������
���

���y� � � �!;�<�<�<��Q�J�E��{�+�+�D�+�9�9�
�
���A�:�:�!�#�t�C�y�y�(�(�(��#�!�!�!� ��!������
����3�4�4�4s$�
A�
A'�&A'�0
B=�=
C
�	C
c�B�|�||jj��S)a�deque.__getitem__(index) <==> deque[index]

        Return corresponding item for `index` in deque.

        See also `Deque.peekleft` and `Deque.peek` for indexing deque at index
        ``0`` or ``-1``.

        >>> deque = Deque()
        >>> deque.extend('abcde')
        >>> deque[1]
        'b'
        >>> deque[-2]
        'd'

        :param int index: index of item
        :return: corresponding item
        :raises IndexError: if index out of range

        )rTr/�__getitem__�rrQs  rrVzDeque.__getitem__�s��(�{�{�5�$�+�"9�:�:�:r c�B�����fd�}��||��dS)a�deque.__setitem__(index, value) <==> deque[index] = value

        Store `value` in deque at `index`.

        >>> deque = Deque()
        >>> deque.extend([None] * 3)
        >>> deque[0] = 'a'
        >>> deque[1] = 'b'
        >>> deque[-1] = 'c'
        >>> ''.join(deque)
        'abc'

        :param int index: index of value
        :param value: value to store
        :raises IndexError: if index out of range

        c�:���j�|���S�N)r/�__setitem__)rSrrJs ��r�
_set_valuez%Deque.__setitem__.<locals>._set_value�s����;�*�*�3��6�6�6r N)rT)rrQrJr\s` ` rr[zDeque.__setitem__�s>����&	7�	7�	7�	7�	7�	7�	
���E�:�&�&�&�&�&r c�F�|�||jj��dS)aldeque.__delitem__(index) <==> del deque[index]

        Delete item in deque at `index`.

        >>> deque = Deque()
        >>> deque.extend([None] * 3)
        >>> del deque[0]
        >>> del deque[1]
        >>> del deque[-1]
        >>> len(deque)
        0

        :param int index: index of item
        :raises IndexError: if index out of range

        N)rTr/�__delitem__rWs  rr^zDeque.__delitem__�s#��"	
���E�4�;�2�3�3�3�3�3r c�`�t|��j}d�||j��S)zjdeque.__repr__() <==> repr(deque)

        Return string with printable representation of deque.

        z{0}(directory={1!r})��typer"r!r4�r�names  r�__repr__zDeque.__repr__�s*���D�z�z�"��%�,�,�T�4�>�B�B�Br zequal toznot equal toz	less thanzgreater thanzless than or equal tozgreater than or equal toc�0�|�|��|S)z�deque.__iadd__(iterable) <==> deque += iterable

        Extend back side of deque with items from iterable.

        :param iterable: iterable of items to append to deque
        :return: deque with added items

        )r2)rr3s  r�__iadd__zDeque.__iadd__	s��	
���X�����r c#�|K�|j}|���D]}	||V��#t$rY�wxYwdS)zadeque.__iter__() <==> iter(deque)

        Return iterator of deque from front to back.

        N�r/rOrP�rr/rSs   r�__iter__zDeque.__iter__sj��������?�?�$�$�	�	�C�
��S�k�!�!�!�!���
�
�
���
����	�	s�
,�
9�9c�*�t|j��S)zJdeque.__len__() <==> len(deque)

        Return length of deque.

        �rr/r>s r�__len__z
Deque.__len__#����4�;���r c#�K�|j}|�d���D]}	||V��#t$rY�wxYwdS)a(deque.__reversed__() <==> reversed(deque)

        Return iterator of deque from back to front.

        >>> deque = Deque()
        >>> deque.extend('abcd')
        >>> iterator = reversed(deque)
        >>> next(iterator)
        'd'
        >>> list(iterator)
        ['c', 'b', 'a']

        TrLNrhris   r�__reversed__zDeque.__reversed__+sn��������?�?�4�?�0�0�	�	�C�
��S�k�!�!�!�!���
�
�
���
����	�	s�
.�
;�;c��|j|jfSrZ�r4r5r>s r�__getstate__zDeque.__getstate__As���~�t�{�*�*r c�>�|\}}|�||���dS)Nrr�r6)r�stater4r5s    r�__setstate__zDeque.__setstate__Ds(��!��	�6��
�
�	�&�
�9�9�9�9�9r c��|j�d���5|j�|d���t|j��|jkr|���ddd��dS#1swxYwYdS)aAdd `value` to back of deque.

        >>> deque = Deque()
        >>> deque.append('a')
        >>> deque.append('b')
        >>> deque.append('c')
        >>> list(deque)
        ['a', 'b', 'c']

        :param value: value to add to back of deque

        TrEN)r/rG�pushrr1rHrIs  r�appendzDeque.appendHs����[�
!�
!��
!�
-�
-�	 �	 ��K���U�$��/�/�/��4�;���$�,�.�.��
�
����	 �	 �	 �	 �	 �	 �	 �	 �	 �	 �	 �	 ����	 �	 �	 �	 �	 �	 s�AA7�7A;�>A;c�
�|j�d���5|j�|dd���t|j��|jkr|���ddd��dS#1swxYwYdS)aAdd `value` to front of deque.

        >>> deque = Deque()
        >>> deque.appendleft('a')
        >>> deque.appendleft('b')
        >>> deque.appendleft('c')
        >>> list(deque)
        ['c', 'b', 'a']

        :param value: value to add to front of deque

        TrE�front)�siderFN)r/rGryrr1�_poprIs  r�
appendleftzDeque.appendleft\s����[�
!�
!��
!�
-�
-�	�	��K���U����=�=�=��4�;���$�,�.�.��	�	����	�	�	�	�	�	�	�	�	�	�	�	����	�	�	�	�	�	s�AA8�8A<�?A<c�<�|j�d���dS)z�Remove all elements from deque.

        >>> deque = Deque('abc')
        >>> len(deque)
        3
        >>> deque.clear()
        >>> list(deque)
        []

        TrEN�r/�clearr>s rr�zDeque.clearp�#��	
������%�%�%�%�%r c�N�t|��}||j|j���S)z.Copy deque with same directory and max length.rr)rar4r5)r�TypeSelfs  r�copyz
Deque.copys&����:�:���x�$�.���E�E�E�Er c�:��t�fd�|D����S)atReturn number of occurrences of `value` in deque.

        >>> deque = Deque()
        >>> deque += [num for num in range(1, 5) for _ in range(num)]
        >>> deque.count(0)
        0
        >>> deque.count(1)
        1
        >>> deque.count(4)
        4

        :param value: value to count in deque
        :return: count of items equal to value in deque

        c3�(�K�|]}�|k�dV��
dS)rNr))�.0�itemrJs  �r�	<genexpr>zDeque.count.<locals>.<genexpr>�s'�����7�7���$���1�����7�7r )�sumrIs `r�countzDeque.count�s(��� �7�7�7�7��7�7�7�7�7�7r c�:�|D]}|�|���dS)zmExtend back side of deque with values from `iterable`.

        :param iterable: iterable of values

        N)�_append�rr3rJs   r�extendzDeque.extend�s2���	 �	 �E��L�L������	 �	 r c�:�|D]}|�|���dS)z�Extend front side of deque with value from `iterable`.

        >>> deque = Deque()
        >>> deque.extendleft('abc')
        >>> list(deque)
        ['c', 'b', 'a']

        :param iterable: iterable of values

        N)�_appendleftr�s   r�
extendleftzDeque.extendleft�s4���	$�	$�E����U�#�#�#�#�	$�	$r c��dtf}|j�|dd���\}}|turtd���|S)a�Peek at value at back of deque.

        Faster than indexing deque at -1.

        If deque is empty then raise IndexError.

        >>> deque = Deque()
        >>> deque.peek()
        Traceback (most recent call last):
            ...
        IndexError: peek from an empty deque
        >>> deque += 'abc'
        >>> deque.peek()
        'c'

        :return: value at back of deque
        :raises IndexError: if deque is empty

        N�backT��defaultr}rF�peek from an empty deque�rr/�peekrN�rr��_rJs    rr�z
Deque.peek�sJ��(��,���;�#�#�G�&��#�M�M���5��F�?�?��7�8�8�8��r c��dtf}|j�|dd���\}}|turtd���|S)a�Peek at value at front of deque.

        Faster than indexing deque at 0.

        If deque is empty then raise IndexError.

        >>> deque = Deque()
        >>> deque.peekleft()
        Traceback (most recent call last):
            ...
        IndexError: peek from an empty deque
        >>> deque += 'abc'
        >>> deque.peekleft()
        'a'

        :return: value at front of deque
        :raises IndexError: if deque is empty

        Nr|Tr�r�r�r�s    r�peekleftzDeque.peekleft�sJ��(��,���;�#�#�G�'��#�N�N���5��F�?�?��7�8�8�8��r c��dtf}|j�|dd���\}}|turtd���|S)a�Remove and return value at back of deque.

        If deque is empty then raise IndexError.

        >>> deque = Deque()
        >>> deque += 'ab'
        >>> deque.pop()
        'b'
        >>> deque.pop()
        'a'
        >>> deque.pop()
        Traceback (most recent call last):
            ...
        IndexError: pop from an empty deque

        :return: value at back of deque
        :raises IndexError: if deque is empty

        Nr�Tr��pop from an empty deque�rr/�pullrNr�s    r�popz	Deque.pop�sJ��(��,���;�#�#�G�&��#�M�M���5��F�?�?��6�7�7�7��r c��dtf}|j�|d���\}}|turtd���|S)a�Remove and return value at front of deque.

        >>> deque = Deque()
        >>> deque += 'ab'
        >>> deque.popleft()
        'a'
        >>> deque.popleft()
        'b'
        >>> deque.popleft()
        Traceback (most recent call last):
            ...
        IndexError: pop from an empty deque

        :return: value at front of deque
        :raises IndexError: if deque is empty

        NT�r�rFr�r�r�s    r�popleftz
Deque.popleft�sH��$��,���;�#�#�G�4�#�@�@���5��F�?�?��6�7�7�7��r c���|j}|���D]9}	||}||kr	||=n#t$rY�"wxYwdS�*#t$rY�6wxYwtd���)a�Remove first occurrence of `value` in deque.

        >>> deque = Deque()
        >>> deque += 'aab'
        >>> deque.remove('a')
        >>> list(deque)
        ['a', 'b']
        >>> deque.remove('b')
        >>> list(deque)
        ['a']
        >>> deque.remove('c')
        Traceback (most recent call last):
            ...
        ValueError: deque.remove(value): value not in deque

        :param value: value to remove
        :raises ValueError: if value not in deque

        Nz'deque.remove(value): value not in deque)r/rOrP�
ValueError)rrJr/rSr�s     r�removezDeque.removes���(����?�?�$�$�	�	�C�

��c�{���D�=�=�!�"�3�K�K��#�!�!�!� ��!�����F�F�!���
�
�
���
�����B�C�C�Cs�A�2�
?�?�
A�Ac���tt|�����}|���|�|��|j}|j���~t|��dS)z�Reverse deque in place.

        >>> deque = Deque()
        >>> deque += 'abc'
        >>> deque.reverse()
        >>> list(deque)
        ['c', 'b', 'a']

        )r3N)r(�reversed�_clearr2r4r/�closer
)r�tempr4s   rrMz
Deque.reverse>sk�� �h�t�n�n�-�-�-�����
�
�
����T�����N�	����������y�����r rc��t|t��s&t|��j}t	d|z���t|��}|sdS|dkrU||z}t
|��D]>}	|���}|�|���-#t$rYdSwxYwdS|dz}||z}t
|��D]>}	|�
��}|�|���-#t$rYdSwxYwdS)amRotate deque right by `steps`.

        If steps is negative then rotate left.

        >>> deque = Deque()
        >>> deque += range(5)
        >>> deque.rotate(2)
        >>> list(deque)
        [3, 4, 0, 1, 2]
        >>> deque.rotate(-1)
        >>> list(deque)
        [4, 0, 1, 2, 3]

        :param int steps: number of steps to rotate (default 1)

        z!integer argument expected, got %sNr���)r�intrar"�	TypeErrorr�ranger~r�rNrHr�)r�steps�	type_namerr�rJs      r�rotatezDeque.rotateVsW��"�%��%�%�	M��U���,�I��?�)�K�L�L�L��t�9�9���	��F��A�:�:��X��E��5�\�\�
,�
,��,� �I�I�K�K�E��$�$�U�+�+�+�+��"�����F�F�F�����
,�
,�
�R�K�E��X��E��5�\�\�
(�
(��(� �M�M�O�O�E��L�L��'�'�'�'��"�����F�F�F�����
(�
(s$�,B�
B%�$B%�C0�0
C?�>C?c#�zK�|j�d���5dV�ddd��dS#1swxYwYdS)aContext manager to perform a transaction by locking the deque.

        While the deque is locked, no other write operation is permitted.
        Transactions should therefore be as short as possible. Read and write
        operations performed in a transaction are atomic. Read operations may
        occur concurrent to a transaction.

        Transactions may be nested and may not be shared between threads.

        >>> from diskcache import Deque
        >>> deque = Deque()
        >>> deque += range(5)
        >>> with deque.transact():  # Atomically rotate elements.
        ...     value = deque.pop()
        ...     deque.appendleft(value)
        >>> list(deque)
        [4, 0, 1, 2, 3]

        :return: context manager for use in `with` statement

        TrEN�r/rGr>s rrGzDeque.transact�s�����.�[�
!�
!��
!�
-�
-�	�	��E�E�E�	�	�	�	�	�	�	�	�	�	�	�	����	�	�	�	�	�	��0�4�4)r)NN)r)N)r)<r"�
__module__�__qualname__r#r6�classmethodr;�propertyr:r4r5�setterrTrVr[r^rdr&rr�__eq__r�__ne__�lt�__lt__�gt�__gt__�le�__le__�ge�__ge__rfrjrmrprsrwrzr�rr�r�r�r�r�r�r2r�r�r�r�r~r�rHr�rMr��__hash__r	rGr)r rr(r(1s��������8���������[��4����X���%�%��X�%�����X���]� � ��]� �&5�5�5�<;�;�;�,'�'�'�04�4�4�&C�C�C��]�2�5�*�
-�
-�F�
�]�2�5�.�
1�
1�F�
�]�2�5�+�
.�
.�F�
�]�2�5�.�
1�
1�F�
�]�2�5�"9�
:�
:�F�
�]�2�5�"<�
=�
=�F�
�
�
���� � � ����,+�+�+�:�:�:� � � �$�G����$�K�&�&�&��F�F�F�F�
8�8�8�$ � � ��G�$�$�$����4���4���4�D����0�H�#D�#D�#D�J���0.(�.(�.(�.(�`�H�����^���r r(c��eZdZdZd�ZejZed���Z	e
d���Ze
d���Zd�Z
d�Zd�Zd$d
�Zd%d�Zefd
�Zd%d�Zd&d�Zd'd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd	Zd�Zd�Z d�Z!d�Z"d(d!�Z#e$d"���Z%d#�Z&d	S))�Indexa
Persistent mutable mapping with insertion order iteration.

    Items are serialized to disk. Index may be initialized from directory path
    where items are stored.

    Hashing protocol is not used. Keys are looked up by their serialized
    format. See ``diskcache.Disk`` for details.

    >>> index = Index()
    >>> index.update([('a', 1), ('b', 2), ('c', 3)])
    >>> index['a']
    1
    >>> list(index)
    ['a', 'b', 'c']
    >>> len(index)
    3
    >>> del index['b']
    >>> index.popitem()
    ('c', 3)

    c���|r5t|dttf��r|d}|dd�}n|r|d�
|dd�}d}t|d���|_|j|i|��dS)a�Initialize index in directory and update items.

        Optional first argument may be string specifying directory where items
        are stored. When None or not given, temporary directory is created.

        >>> index = Index({'a': 1, 'b': 2, 'c': 3})
        >>> len(index)
        3
        >>> directory = index.directory
        >>> inventory = Index(directory, d=4)
        >>> inventory['b']
        2
        >>> len(inventory)
        4

        rrNr+r,)r�bytes�strr
r/�_update)r�args�kwargsr4s    rr6zIndex.__init__�s���"�	�J�t�A�w����5�5�	��Q��I�����8�D�D��
 ��Q����A�B�B�x���I��I�v�>�>�>������d�%�f�%�%�%�%�%r c�X�|�|��}||_|j|i|��|S)a�Initialize index using `cache` and update items.

        >>> cache = Cache()
        >>> index = Index.fromcache(cache, {'a': 1, 'b': 2, 'c': 3})
        >>> index.cache is cache
        True
        >>> len(index)
        3
        >>> 'b' in index
        True
        >>> index['c']
        3

        :param Cache cache: cache to use
        :param args: mapping or sequence of items
        :param kwargs: mapping of items
        :return: initialized Index

        )r8r/r�)r9r:r�r�rs     rr;zIndex.fromcache�s8��,�{�{�3����������d�%�f�%�%�%��r c��|jS)zCache used by index.r=r>s rr:zIndex.cache�r?r c��|jjS)z&Directory path where items are stored.rAr>s rr4zIndex.directory�rBr c��|j|S)a�index.__getitem__(key) <==> index[key]

        Return corresponding value for `key` in index.

        >>> index = Index()
        >>> index.update({'a': 1, 'b': 2})
        >>> index['a']
        1
        >>> index['b']
        2
        >>> index['c']
        Traceback (most recent call last):
            ...
        KeyError: 'c'

        :param key: key for item
        :return: value for item in index with given key
        :raises KeyError: if key is not found

        r=�rrSs  rrVzIndex.__getitem__�s��*�{�3��r c��||j|<dS)a)index.__setitem__(key, value) <==> index[key] = value

        Set `key` and `value` item in index.

        >>> index = Index()
        >>> index['a'] = 1
        >>> index[0] = None
        >>> len(index)
        2

        :param key: key for item
        :param value: value for item

        Nr=)rrSrJs   rr[zIndex.__setitem__s��!���C���r c��|j|=dS)a�index.__delitem__(key) <==> del index[key]

        Delete corresponding item for `key` from index.

        >>> index = Index()
        >>> index.update({'a': 1, 'b': 2})
        >>> del index['a']
        >>> del index['b']
        >>> len(index)
        0
        >>> del index['c']
        Traceback (most recent call last):
            ...
        KeyError: 'c'

        :param key: key for item
        :raises KeyError: if key is not found

        Nr=r�s  rr^zIndex.__delitem__$s��(
�K����r Nc�v�|j}		||S#t$r|�||d���YnwxYw�2)a�Set and get value for `key` in index using `default`.

        If `key` is not in index then set corresponding value to `default`. If
        `key` is in index then ignore `default` and return existing value.

        >>> index = Index()
        >>> index.setdefault('a', 0)
        0
        >>> index.setdefault('a', 1)
        0

        :param key: key for item
        :param default: value if key is missing (default None)
        :return: value for item in index with given key

        TrE)r/rP�add)rrSr�r/s    r�
setdefaultzIndex.setdefault:s]��"���	5�
5��c�{�"���
5�
5�
5��
�
�3��t�
�4�4�4�4�4�
5����	5s��"7�7Tc�:�|j�|d���S)a�Peek at key and value item pair in index based on iteration order.

        >>> index = Index()
        >>> for num, letter in enumerate('xyz'):
        ...     index[letter] = num
        >>> index.peekitem()
        ('z', 2)
        >>> index.peekitem(last=False)
        ('x', 0)

        :param bool last: last item in iteration order (default True)
        :return: key and value item pair
        :raises KeyError: if cache is empty

        TrE)r/�peekitem)r�lasts  rr�zIndex.peekitemRs�� �{�#�#�D��#�5�5�5r c�t�|j}|�||d���}|turt|���|S)a�Remove corresponding item for `key` from index and return value.

        If `key` is missing then return `default`. If `default` is `ENOVAL`
        then raise KeyError.

        >>> index = Index({'a': 1, 'b': 2})
        >>> index.pop('a')
        1
        >>> index.pop('b')
        2
        >>> index.pop('c', default=3)
        3
        >>> index.pop('d')
        Traceback (most recent call last):
            ...
        KeyError: 'd'

        :param key: key for item
        :param default: return value if key is missing (default ENOVAL)
        :return: value for item if key is found else default
        :raises KeyError: if key is not found and default is ENOVAL

        Tr�)r/r�rrP)rrSr�r/rJs     rr�z	Index.popds<��0����
�
�3��t�
�<�<���F�?�?��3�-�-���r c��|j}|�d���5|�|���\}}||=ddd��n#1swxYwY||fS)a�Remove and return item pair.

        Item pairs are returned in last-in-first-out (LIFO) order if last is
        True else first-in-first-out (FIFO) order. LIFO order imitates a stack
        and FIFO order imitates a queue.

        >>> index = Index()
        >>> index.update([('a', 1), ('b', 2), ('c', 3)])
        >>> index.popitem()
        ('c', 3)
        >>> index.popitem(last=False)
        ('a', 1)
        >>> index.popitem()
        ('b', 2)
        >>> index.popitem()
        Traceback (most recent call last):
          ...
        KeyError: 'dictionary is empty'

        :param bool last: pop last item pair (default True)
        :return: key and value item pair
        :raises KeyError: if index is empty

        TrE)r�N)r/rGr�)rr�r/rSrJs     r�popitemz
Index.popitem�s���4���
�_�_�4�_�
(�
(�	�	����d��3�3�J�C���s��	�	�	�	�	�	�	�	�	�	�	����	�	�	�	��E�z�s�A�A�Ar�c�>�|j�|||d���S)a�Push `value` onto `side` of queue in index identified by `prefix`.

        When prefix is None, integer keys are used. Otherwise, string keys are
        used in the format "prefix-integer". Integer starts at 500 trillion.

        Defaults to pushing value on back of queue. Set side to 'front' to push
        value on front of queue. Side must be one of 'back' or 'front'.

        See also `Index.pull`.

        >>> index = Index()
        >>> print(index.push('apples'))
        500000000000000
        >>> print(index.push('beans'))
        500000000000001
        >>> print(index.push('cherries', side='front'))
        499999999999999
        >>> index[500000000000001]
        'beans'
        >>> index.push('dates', prefix='fruit')
        'fruit-500000000000000'

        :param value: value for item
        :param str prefix: key prefix (default None, key is integer)
        :param str side: either 'back' or 'front' (default 'back')
        :return: key for item in cache

        TrE)r/ry)rrJ�prefixr}s    rryz
Index.push�s#��:�{����v�t�4��@�@�@r �NNr|c�>�|j�|||d���S)a�Pull key and value item pair from `side` of queue in index.

        When prefix is None, integer keys are used. Otherwise, string keys are
        used in the format "prefix-integer". Integer starts at 500 trillion.

        If queue is empty, return default.

        Defaults to pulling key and value item pairs from front of queue. Set
        side to 'back' to pull from back of queue. Side must be one of 'front'
        or 'back'.

        See also `Index.push`.

        >>> index = Index()
        >>> for letter in 'abc':
        ...     print(index.push(letter))
        500000000000000
        500000000000001
        500000000000002
        >>> key, value = index.pull()
        >>> print(key)
        500000000000000
        >>> value
        'a'
        >>> _, value = index.pull(side='back')
        >>> value
        'c'
        >>> index.pull(prefix='fruit')
        (None, None)

        :param str prefix: key prefix (default None, key is integer)
        :param default: value to return if key is missing
            (default (None, None))
        :param str side: either 'front' or 'back' (default 'front')
        :return: key and value item pair or default if queue is empty

        TrE)r/r�)rr�r�r}s    rr�z
Index.pull�s$��L�{������T��B�B�Br c�<�|j�d���dS)z�Remove all items from index.

        >>> index = Index({'a': 0, 'b': 1, 'c': 2})
        >>> len(index)
        3
        >>> index.clear()
        >>> dict(index)
        {}

        TrENr�r>s rr�zIndex.clear�r�r c�*�t|j��S)zfindex.__iter__() <==> iter(index)

        Return iterator of index keys in insertion order.

        )�iterr/r>s rrjzIndex.__iter__�s���D�K� � � r c�*�t|j��S)aIindex.__reversed__() <==> reversed(index)

        Return iterator of index keys in reversed insertion order.

        >>> index = Index()
        >>> index.update([('a', 1), ('b', 2), ('c', 3)])
        >>> iterator = reversed(index)
        >>> next(iterator)
        'c'
        >>> list(iterator)
        ['b', 'a']

        )r�r/r>s rrpzIndex.__reversed__s�����$�$�$r c�*�t|j��S)zJindex.__len__() <==> len(index)

        Return length of index.

        rlr>s rrmz
Index.__len__rnr c� �t|��S)z�Set-like object providing a view of index keys.

        >>> index = Index()
        >>> index.update({'a': 1, 'b': 2, 'c': 3})
        >>> keys_view = index.keys()
        >>> 'b' in keys_view
        True

        :return: keys view

        )rr>s r�keysz
Index.keyss����~�~�r c� �t|��S)z�Set-like object providing a view of index values.

        >>> index = Index()
        >>> index.update({'a': 1, 'b': 2, 'c': 3})
        >>> values_view = index.values()
        >>> 2 in values_view
        True

        :return: values view

        )rr>s r�valueszIndex.values&s���$���r c� �t|��S)z�Set-like object providing a view of index items.

        >>> index = Index()
        >>> index.update({'a': 1, 'b': 2, 'c': 3})
        >>> items_view = index.items()
        >>> ('b', 2) in items_view
        True

        :return: items view

        )rr>s r�itemszIndex.items4s������r c��|jSrZ)r4r>s rrszIndex.__getstate__Ds
���~�r c�0�|�|��dSrZru)rrvs  rrwzIndex.__setstate__Gs���
�
�e�����r c�F���t���t���krdSt�ttf��rF�fd��D��}�fd��D��}t	||��}td�|D����St
��fd��D����S)a|index.__eq__(other) <==> index == other

        Compare equality for index and `other`.

        Comparison to another index or ordered dictionary is
        order-sensitive. Comparison to all other mappings is order-insensitive.

        >>> index = Index()
        >>> pairs = [('a', 1), ('b', 2), ('c', 3)]
        >>> index.update(pairs)
        >>> from collections import OrderedDict
        >>> od = OrderedDict(pairs)
        >>> index == od
        True
        >>> index == {'c': 3, 'b': 2, 'a': 1}
        True

        :param other: other mapping in equality comparison
        :return: True if index equals other

        Fc3�,�K�|]}|�|fV��dSrZr))r�rSrs  �rr�zIndex.__eq__.<locals>.<genexpr>ds,�����6�6�#�c�4��9�%�6�6�6�6�6�6r c3�,�K�|]}|�|fV��dSrZr))r�rS�others  �rr�zIndex.__eq__.<locals>.<genexpr>es,�����7�7�#�S�%��*�%�7�7�7�7�7�7r c3�@K�|]\\}}\}}||kp||kV��dSrZr))r��a�b�x�ys     rr�zIndex.__eq__.<locals>.<genexpr>gs;����H�H����A���A�1��6�+�Q�!�V�H�H�H�H�H�Hr c3�b�K�|])}�|��|t��kV��*dSrZ)�getr)r�rSr�rs  ��rr�zIndex.__eq__.<locals>.<genexpr>is:�����K�K�s�t�C�y�E�I�I�c�6�$:�$:�:�K�K�K�K�K�Kr )rrr�rr�any�all)rr�rr�pairss``   rr�zIndex.__eq__Js�����,�t�9�9��E�
�
�"�"��5��e�e�[�1�2�2�	L�6�6�6�6��6�6�6�E�7�7�7�7��7�7�7�D���t�$�$�E��H�H�%�H�H�H�H�H�H�H��K�K�K�K�K�d�K�K�K�K�K�Kr c��||kS)aindex.__ne__(other) <==> index != other

        Compare inequality for index and `other`.

        Comparison to another index or ordered dictionary is
        order-sensitive. Comparison to all other mappings is order-insensitive.

        >>> index = Index()
        >>> index.update([('a', 1), ('b', 2), ('c', 3)])
        >>> from collections import OrderedDict
        >>> od = OrderedDict([('c', 3), ('b', 2), ('a', 1)])
        >>> index != od
        True
        >>> index != {'a': 1, 'b': 2}
        True

        :param other: other mapping in inequality comparison
        :return: True if index does not equal other

        r))rr�s  rr�zIndex.__ne__ks��*�5�=� � r Fr)c�<�|j�|||���S)a�Memoizing cache decorator.

        Decorator to wrap callable with memoizing function using cache.
        Repeated calls with the same arguments will lookup result in cache and
        avoid function evaluation.

        If name is set to None (default), the callable name will be determined
        automatically.

        If typed is set to True, function arguments of different types will be
        cached separately. For example, f(3) and f(3.0) will be treated as
        distinct calls with distinct results.

        The original underlying function is accessible through the __wrapped__
        attribute. This is useful for introspection, for bypassing the cache,
        or for rewrapping the function with a different cache.

        >>> from diskcache import Index
        >>> mapping = Index()
        >>> @mapping.memoize()
        ... def fibonacci(number):
        ...     if number == 0:
        ...         return 0
        ...     elif number == 1:
        ...         return 1
        ...     else:
        ...         return fibonacci(number - 1) + fibonacci(number - 2)
        >>> print(fibonacci(100))
        354224848179261915075

        An additional `__cache_key__` attribute can be used to generate the
        cache key used for the given arguments.

        >>> key = fibonacci.__cache_key__(100)
        >>> print(mapping[key])
        354224848179261915075

        Remember to call memoize when decorating a callable. If you forget,
        then a TypeError will occur. Note the lack of parenthenses after
        memoize below:

        >>> @mapping.memoize
        ... def test():
        ...     pass
        Traceback (most recent call last):
            ...
        TypeError: name cannot be callable

        :param str name: name given for callable (default None, automatic)
        :param bool typed: cache different types separately (default False)
        :param set ignore: positional or keyword args to ignore (default ())
        :return: callable decorator

        )�ignore)r/�memoize)rrc�typedrs    rrz
Index.memoize�s"��n�{�"�"�4��v�"�>�>�>r c#�zK�|j�d���5dV�ddd��dS#1swxYwYdS)a�Context manager to perform a transaction by locking the index.

        While the index is locked, no other write operation is permitted.
        Transactions should therefore be as short as possible. Read and write
        operations performed in a transaction are atomic. Read operations may
        occur concurrent to a transaction.

        Transactions may be nested and may not be shared between threads.

        >>> from diskcache import Index
        >>> mapping = Index()
        >>> with mapping.transact():  # Atomically increment two keys.
        ...     mapping['total'] = mapping.get('total', 0) + 123.4
        ...     mapping['count'] = mapping.get('count', 0) + 1
        >>> with mapping.transact():  # Atomically calculate average.
        ...     average = mapping['total'] / mapping['count']
        >>> average
        123.4

        :return: context manager for use in `with` statement

        TrENr�r>s rrGzIndex.transact�s�����0�[�
!�
!��
!�
-�
-�	�	��E�E�E�	�	�	�	�	�	�	�	�	�	�	�	����	�	�	�	�	�	r�c�`�t|��j}d�||j��S)zjindex.__repr__() <==> repr(index)

        Return string with printable representation of index.

        z
{0}({1!r})r`rbs  rrdzIndex.__repr__�s*���D�z�z�"���"�"�4���8�8�8r rZ)T)Nr�)Nr�r|)NFr))'r"r�r�r#r6r�updater�r�r;r�r:r4rVr[r^r�r�rr�r�ryr�r�rjrprmr�r�r�r�rsrwr�r�rr	rGrdr)r rr�r��s)��������,&�&�&�6�#�G�����[��4����X���%�%��X�%� � � �.!�!�!�"���,5�5�5�5�06�6�6�6�$ &�����< � � � �DA�A�A�A�>&C�&C�&C�&C�P&�&�&�!�!�!�%�%�%�  � � ���� � � �����H�������L�L�L�B!�!�!�.7?�7?�7?�7?�r����^��49�9�9�9�9r r�)r#�operatorr�collectionsr�collections.abcrrrrr�
contextlibr	�shutilr
�corerr
r&r(r�r)r r�<module>rs3��������#�#�#�#�#�#���������������&�%�%�%�%�%������������������<o	�o	�o	�o	�o	�H�o	�o	�o	�dz9�z9�z9�z9�z9�N�z9�z9�z9�z9�z9r
Name	Type	Size	Permission
__init__.cpython-311.pyc	File	1.64 KB	0644
cli.cpython-311.pyc	File	269 B	0644
core.cpython-311.pyc	File	93.21 KB	0644
djangocache.cpython-311.pyc	File	19.27 KB	0644
fanout.cpython-311.pyc	File	31.13 KB	0644
persistent.cpython-311.pyc	File	44.95 KB	0644
recipes.cpython-311.pyc	File	21.54 KB	0644
Upload:

Command:

Filemanager

Server Info

System Info
