o
    ]f9                     @   s*   d dl ZG dd dZG dd deZdS )    Nc                
   @   s  e Zd ZdZd)defddZdeje defdd	Zd
e	dej
fddZd
e	defddZde	dejej
 fddZde	deje	ej
f fddZ	d*d
e	dej
deje deje fddZd*d
e	dej
deje defddZ	d*deje	ej
f deje dejej
 fddZde	dejej
 fddZd
e	defdd Zdefd!d"Zd+d
e	d$edeje fd%d&Zd+d
e	d$edeje fd'd(ZdS ),	BaseCacheaM  Baseclass for the cache systems.  All the cache systems implement this
    API or a superset of it.

    :param default_timeout: the default timeout (in seconds) that is used if
                            no timeout is specified on :meth:`set`. A timeout
                            of 0 indicates that the cache never expires.
    ,  default_timeoutc                 C   s
   || _ d S Nr   )selfr    r   F/home/ubuntu/webapp/venv/lib/python3.10/site-packages/cachelib/base.py__init__   s   
zBaseCache.__init__timeoutreturnc                 C   s   |d u r| j }|S r   r   )r   r   r   r   r	   _normalize_timeout   s   zBaseCache._normalize_timeoutkeyc                 C      dS )zLook up key in the cache and return the value for it.

        :param key: the key to be looked up.
        :returns: The value if it exists and is readable, else ``None``.
        Nr   r   r   r   r   r	   get   s   zBaseCache.getc                 C   r   )zDelete `key` from the cache.

        :param key: the key to delete.
        :returns: Whether the key existed and has been deleted.
        :rtype: boolean
        Tr   r   r   r   r	   delete      zBaseCache.deletekeysc                    s    fdd|D S )a<  Returns a list of values for the given keys.
        For each key an item in the list is created::

            foo, bar = cache.get_many("foo", "bar")

        Has the same error handling as :meth:`get`.

        :param keys: The function accepts multiple keys as positional
                     arguments.
        c                    s   g | ]}  |qS r   )r   ).0kr   r   r	   
<listcomp>1   s    z&BaseCache.get_many.<locals>.<listcomp>r   r   r   r   r   r	   get_many&   s   zBaseCache.get_manyc                 G   s   t t|| j| S )zLike :meth:`get_many` but return a dict::

            d = cache.get_dict("foo", "bar")
            foo = d["foo"]
            bar = d["bar"]

        :param keys: The function accepts multiple keys as positional
                     arguments.
        )dictzipr   r   r   r   r	   get_dict3   s   
zBaseCache.get_dictNvaluec                 C   r   )ak  Add a new key/value to the cache (overwrites value, if key already
        exists in the cache).

        :param key: the key to set
        :param value: the value for the key
        :param timeout: the cache timeout for the key in seconds (if not
                        specified, it uses the default timeout). A timeout of
                        0 indicates that the cache never expires.
        :returns: ``True`` if key has been updated, ``False`` for backend
                  errors. Pickling errors, however, will raise a subclass of
                  ``pickle.PickleError``.
        :rtype: boolean
        Tr   r   r   r   r   r   r   r	   set?   s   zBaseCache.setc                 C   r   )a  Works like :meth:`set` but does not overwrite the values of already
        existing keys.

        :param key: the key to set
        :param value: the value for the key
        :param timeout: the cache timeout for the key in seconds (if not
                        specified, it uses the default timeout). A timeout of
                        0 indicates that the cache never expires.
        :returns: Same as :meth:`set`, but also ``False`` for already
                  existing keys.
        :rtype: boolean
        Tr   r   r   r   r	   addQ   s   zBaseCache.addmappingc                 C   s2   g }|  D ]\}}| |||r|| q|S )a  Sets multiple keys and values from a mapping.

        :param mapping: a mapping with the keys/values to set.
        :param timeout: the cache timeout for the key in seconds (if not
                        specified, it uses the default timeout). A timeout of
                        0 indicates that the cache never expires.
        :returns: A list containing all keys sucessfuly set
        :rtype: boolean
        )itemsr    append)r   r"   r   set_keysr   r   r   r   r	   set_many`   s   
zBaseCache.set_manyc                 G   s&   g }|D ]}|  |r|| q|S )zDeletes multiple keys at once.

        :param keys: The function accepts multiple keys as positional
                     arguments.
        :returns: A list containing all sucessfuly deleted keys
        :rtype: boolean
        )r   r$   )r   r   deleted_keysr   r   r   r	   delete_manyr   s   

zBaseCache.delete_manyc                 C   s   t d)zChecks if a key exists in the cache without returning it. This is a
        cheap operation that bypasses loading the actual data on the backend.

        :param key: the key to check
        z%s doesn't have an efficient implementation of `has`. That means it is impossible to check whether a key exists without fully loading the key's data. Consider using `self.get` explicitly if you don't care about performance.)NotImplementedErrorr   r   r   r	   has   s   zBaseCache.hasc                 C   r   )zClears the cache.  Keep in mind that not all caches support
        completely clearing the cache.

        :returns: Whether the cache has been cleared.
        :rtype: boolean
        Tr   r   r   r   r	   clear   r   zBaseCache.clear   deltac                 C   s&   |  |pd| }| ||r|S dS )aH  Increments the value of a key by `delta`.  If the key does
        not yet exist it is initialized with `delta`.

        For supporting caches this is an atomic operation.

        :param key: the key to increment.
        :param delta: the delta to add.
        :returns: The new value or ``None`` for backend errors.
        r   Nr   r    r   r   r-   r   r   r   r	   inc      
zBaseCache.incc                 C   s&   |  |pd| }| ||r|S dS )aL  Decrements the value of a key by `delta`.  If the key does
        not yet exist it is initialized with `-delta`.

        For supporting caches this is an atomic operation.

        :param key: the key to increment.
        :param delta: the delta to subtract.
        :returns: The new value or `None` for backend errors.
        r   Nr.   r/   r   r   r	   dec   r1   zBaseCache.dec)r   r   )r,   )__name__
__module____qualname____doc__intr
   _tOptionalr   strAnyr   boolr   Listr   Dictr   r    r!   r&   r(   r*   r+   r0   r2   r   r   r   r	   r      s@    	
$

	"r   c                   @   s"   e Zd ZdZdedefddZdS )	NullCachezA cache that doesn't cache.  This can be useful for unit testing.

    :param default_timeout: a dummy parameter that is ignored but exists
                            for API compatibility with other caches.
    r   r   c                 C   r   )NFr   r   r   r   r	   r*      s   zNullCache.hasN)r3   r4   r5   r6   r:   r<   r*   r   r   r   r	   r?      s    r?   )typingr8   r   r?   r   r   r   r	   <module>   s     .