/usr/lib/python3/dist-packages/cement/core/cache.py is in python3-cement 2.10.0-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 | """Cement core cache module."""
from ..core import interface, handler
from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
def cache_validator(klass, obj):
"""Validates a handler implementation against the ICache interface."""
members = [
'_setup',
'get',
'set',
'delete',
'purge',
]
interface.validate(ICache, obj, members)
class ICache(interface.Interface):
"""
This class defines the Cache Handler Interface. Classes that
implement this handler must provide the methods and attributes defined
below.
Implementations do *not* subclass from interfaces.
Usage:
.. code-block:: python
from cement.core import cache
class MyCacheHandler(object):
class Meta:
interface = cache.ICache
label = 'my_cache_handler'
...
"""
# pylint: disable=W0232, C0111, R0903
class IMeta:
"""Interface meta-data."""
label = 'cache'
"""The label (or type identifier) of the interface."""
validator = cache_validator
"""Interface validator function."""
# Must be provided by the implementation
Meta = interface.Attribute('Handler meta-data')
def _setup(app_obj):
"""
The _setup function is called during application initialization and
must 'setup' the handler object making it ready for the framework
or the application to make further calls to it.
:param app_obj: The application object.
:returns: ``None``
"""
def get(key, fallback=None):
"""
Get the value for a key in the cache. If the key does not exist
or the key/value in cache is expired, this functions must return
'fallback' (which in turn must default to None).
:param key: The key of the value stored in cache
:param fallback: Optional value that is returned if the cache is
expired or the key does not exist. Default: None
:returns: Unknown (whatever the value is in cache, or the `fallback`)
"""
def set(key, value, time=None):
"""
Set the key/value in the cache for a set amount of `time`.
:param key: The key of the value to store in cache.
:param value: The value of that key to store in cache.
:param time: A one-off expire time. If no time is given, then a
default value is used (determined by the implementation).
:type time: ``int`` (seconds) or ``None``
:returns: ``None``
"""
def delete(key):
"""
Deletes a key/value from the cache.
:param key: The key in the cache to delete.
:returns: True if the key is successfully deleted, False otherwise.
:rtype: ``boolean``
"""
# pylint: disable=E0211
def purge():
"""
Clears all data from the cache.
"""
class CementCacheHandler(handler.CementBaseHandler):
"""
Base class that all Cache Handlers should sub-class from.
"""
class Meta:
"""
Handler meta-data (can be passed as keyword arguments to the parent
class).
"""
label = None
"""String identifier of this handler implementation."""
interface = ICache
"""The interface that this handler class implements."""
def __init__(self, *args, **kw):
super(CementCacheHandler, self).__init__(*args, **kw)
|