bda.cache 2.0.0__py3-none-any.whl

bda/cache/__init__.py

@@ -0,0 +1,14 @@
+# Copyright 2009, Blue Dynamics Alliance, Austria - http://bluedynamics.com
+# GNU General Public Licence Version 2 or later
+
+from bda.cache.fscache import FSCache  # noqa
+from bda.cache.fscache import FSCacheException  # noqa
+from bda.cache.fscache import FSCacheManager  # noqa
+from bda.cache.interfaces import ICacheManager  # noqa
+from bda.cache.interfaces import ICacheProvider  # noqa
+from bda.cache.interfaces import ICacheVary  # noqa
+from bda.cache.memcached import Memcached  # noqa
+from bda.cache.memcached import MemcachedException  # noqa
+from bda.cache.memcached import MemcachedManager  # noqa
+from bda.cache.nullcache import NullCache  # noqa
+from bda.cache.nullcache import NullCacheManager  # noqa

bda/cache/configure.zcml

@@ -0,0 +1,5 @@
+<configure xmlns="http://namespaces.zope.org/zope">
+
+<!-- DEPRECATED - REMOVED IN FUTURE -->
+
+</configure>

bda/cache/fscache.py

@@ -0,0 +1,243 @@
+# Copyright 2009, Blue Dynamics Alliance, Austria - http://bluedynamics.com
+# GNU General Public Licence Version 2 or later
+"""
+Module fscache.
+
+This module provides fuctionallity for caching objects on the filesystem.
+
+Therefor it uses pickle.
+
+This module was originally designed for very simple caching tasks like caching
+mail headers in a MUA or similar. It is NOT a cache manager.
+
+If you find this module useful and you have some improvements or bugfixes,
+please contact the author.
+"""
+
+from bda.cache.interfaces import CacheException
+from bda.cache.interfaces import ICacheManager
+from bda.cache.interfaces import IFSCacheProvider
+from zope.component import adapter
+from zope.component import provideAdapter
+from zope.interface import implementer
+import logging
+import os
+import pickle
+import time
+
+
+logger = logging.getLogger('bda.cache.cachemanager')
+
+
+class FSCacheException(CacheException):
+    pass
+
+
+@implementer(IFSCacheProvider)
+class FSCache:
+    """Class FsCache.
+
+    Simple object caching.
+
+    This class is accessible like a dictionary. For example:
+
+    cache = FsCache('var/cache/mycache')
+    cache['foo.bar'] = obj
+    obj = ['foo.bar']
+    obj = cache.get('foo.bar', False)
+    del cache['foo.bar']
+
+    The key for objects must ALWAYS be a string, it results directly in a
+    file path.
+
+    By convention, if the key is seperated by a dot like in the example above,
+    the files created on your filesystem are placed in a directory tree, so
+    the file for the key given in this example is placed at 'foo/bar.'.
+
+    Take care of your keys, things like 'foo..bar', 'foo.',  '.foo' or using
+    path seperators like '/' and '\\' will end up in strange results and cause
+    inconsistent data.
+
+    On the other hand, it is no problem to store an object with key 'foo',
+    since every file gets a trailing '.', so key 'foo' ends up in a file with
+    the name 'foo.' while 'foo.bar' is sored at 'foo/bar.'.
+    """
+
+    def __init__(self, cachedir, protocol=2, createDirIfNotExist=False):
+        """Create the cache object.
+
+        * basedir - the directory you want to store the cached objects.
+        * protocol - the protocol you want to use for pickling. defaults to 2.
+
+        Raise an FSCacheException when given basedir is invalid. Does not check
+        if there is read/write access on this directory. Keep this in mind.
+
+        Read the documentation of the module pickle to know about the
+        limitations on object pickling.
+        """
+        if not os.path.isabs(cachedir):
+            errmsg = "Cannot initialize cache. '%s' is not an absolute path."
+            raise FSCacheException(errmsg % cachedir)
+        if not os.path.exists(cachedir) and not createDirIfNotExist:
+            errmsg = "Cannot initialize cache. Directory '%s' not exists."
+            raise FSCacheException(errmsg % cachedir)
+        if createDirIfNotExist:
+            self._createDirIfNotExist(cachedir)
+        if not os.path.isdir(cachedir):
+            errmsg = "Cannot initialize cache. '%s' is not a Directory."
+            raise FSCacheException(errmsg % cachedir)
+        self.cachedir = cachedir
+        self.protocol = protocol
+
+    def reset(self):
+        for key in self.keys():
+            del self[key]
+
+    def size(self):
+        # XXX
+        return 0
+
+    def keys(self):
+        return self._readkeys([])
+
+    def values(self):
+        values = []
+        for key in self.keys():
+            values.append(self[key])
+        return values
+
+    def get(self, key, default=None):
+        return self._getitem(key, default)
+
+    def __getitem__(self, key):
+        return self._getitem(key)
+
+    def __setitem__(self, key, object):
+        """Read the class documentation how keys must look like."""
+        objpath = key.split('.')
+        objlen = len(objpath)
+        pt = 1
+        path = self.cachedir
+        while pt < objlen:
+            path = os.path.join(self.cachedir, *[f for f in objpath[:pt]])
+            exists = os.path.exists(path)
+            if not exists:
+                os.mkdir(path)
+            pt += 1
+        path = os.path.join(path, '%s.' % objpath[-1])
+        file = open(path, 'wb')
+        pickle.dump(object, file, self.protocol)
+        file.close()
+
+    def __delitem__(self, key):
+        path = key.split('.')
+        path[-1] = '%s.' % path[-1]
+        try:
+            os.remove(os.path.join(self.cachedir, *path))
+        except OSError:
+            return None
+        pt = len(path) - 1
+        while pt > 0:
+            previous = path[:pt]
+            curpath = os.path.join(self.cachedir, *previous)
+            contents = os.listdir(curpath)
+            if not contents:
+                os.rmdir(curpath)
+            else:
+                break
+            pt -= 1
+        return None
+
+    def _getitem(self, key, default=None):
+        path = '%s.' % os.path.join(self.cachedir, *key.split('.'))
+        try:
+            file = open(path, 'rb')
+        except OSError:
+            return default
+        obj = pickle.load(file)
+        file.close()
+        return obj
+
+    def _readkeys(self, keys, path=[]):
+        entries = os.listdir(os.path.join(self.cachedir, *path))
+        for entry in entries:
+            if entry[-1] == '.':
+                key = ''
+                for part in path:
+                    key = '%s%s.' % (key, part)
+                keys.append('%s%s' % (key, entry[: len(entry) - 1]))
+            else:
+                self._readkeys(keys, path + [entry])
+        return keys
+
+    def _createDirIfNotExist(self, cachedir):
+        if os.path.exists(cachedir):
+            return
+        path = cachedir.split(os.path.sep)
+        for i in range(len(path)):
+            if not os.path.exists(os.path.sep.join(path[: i + 1])) and path[i]:
+                os.mkdir(os.path.sep.join(path[: i + 1]))
+
+
+@implementer(ICacheManager)
+@adapter(IFSCacheProvider)
+class FSCacheManager:
+    def __init__(self, context):
+        self.timeout = 300  # defaults to 300 seconds
+        self.cache = context
+
+    def setTimeout(self, timeout):
+        self.timeout = timeout
+
+    def getData(self, func, key, force_reload=False, args=[], kwargs={}):
+        # from_cache = True
+        ret = self.get(key, force_reload)
+        if ret is None:
+            # from_cache = False
+            ret = func(*args, **kwargs)
+            self.set(key, ret)
+        return ret
+
+    def get(self, key, force_reload=False):
+        if force_reload or self._isTimedOut(key):
+            del self.cache[key]
+            creationmap = self.cache.get('creationmap', None)
+            if creationmap is not None and key in creationmap:
+                del creationmap[key]
+                self.cache['creationmap'] = creationmap
+            return None
+        return self.cache.get(key, None)
+
+    def set(self, key, item, set_creationtime=True):
+        self.cache[key] = item
+        if not set_creationtime:
+            return
+        creationmap = self.cache.get('creationmap', None)
+        if not creationmap:
+            creationmap = dict()
+        creationmap[key] = time.time()
+        self.cache['creationmap'] = creationmap
+
+    def rem(self, key):
+        del self.cache[key]
+        creationmap = self.cache.get('creationmap', None)
+        if creationmap is not None and key in creationmap:
+            del creationmap[key]
+            self.cache['creationmap'] = creationmap
+
+    def __delitem__(self, key):
+        self.rem(key)
+
+    def _isTimedOut(self, key):
+        """Return wether the item with key is timed out or not."""
+        cur = time.time()
+        creationmap = self.cache.get('creationmap', None)
+        if not creationmap:
+            return True
+        creationtime = creationmap.get(key, None)
+        if not creationtime or creationtime + self.timeout < cur:
+            return True
+        return False
+
+
+provideAdapter(FSCacheManager)

bda/cache/interfaces.py

@@ -0,0 +1,101 @@
+# Copyright 2009, Blue Dynamics Alliance, Austria - http://bluedynamics.com
+# GNU General Public Licence Version 2 or later
+
+from zope.interface import Interface
+
+
+class CacheException(Exception):
+    pass
+
+
+class ICacheVary(Interface):
+    """This interface describes an API for manipulating objects inside a cache."""
+
+    def vary(*args, **kwargs):
+        """Manipulate objects inside the cache."""
+
+
+class ICacheManager(Interface):
+    """Interface for read/write operations on ICacheProvider implementing
+    objects.
+    """
+
+    def setTimeout(timeout):
+        """Set cache timeout in seconds."""
+
+    def getData(func, key, force_reload=False, args=[], kwargs={}):
+        """Convenience to read and cache results at once.
+
+        * Tries to read result from cache.
+        * If no result, call given functions with *args ang **kwargs
+        * If function called, store returned value to cache
+        * Return result
+        """
+
+    def get(key, force_reload=False):
+        """Return item with key or None.
+
+        If force_reload is True, try to delete object with key from cache and
+        return None.
+        """
+
+    def set(key, item, set_creationtime=True):
+        """Store an item with key to cache.
+
+        XXX: get rid of ``set_creationtime``
+        """
+
+    def rem(key):
+        """Remove item with key from cache if exists.
+
+        Legacy. Replaced by ``__delitem__``
+        """
+
+    def __delitem__(key):
+        """Remove item with key from cache if exists."""
+
+
+class ICacheProvider(Interface):
+    """This interface describes an API for caching objects."""
+
+    def reset():
+        """Reset the cache object.
+
+        Remove all objects from cache.
+        """
+
+    def size():
+        """Return the current size of the cache in byte."""
+
+    def keys():
+        """Return the keys of the objects contained in this cache as list."""
+
+    def values():
+        """Return objects contained in this cache as list."""
+
+    def get(key, default=None):
+        """Return object by key or default value if not exist."""
+
+    def __getitem__(key):
+        """Return object by key or None if not exists."""
+
+    def __setitem__(key, object):
+        """Store object to cache by given key."""
+
+    def __delitem__(key):
+        """Delete object by key from cache.
+
+        Always return None.
+        """
+
+
+class INullCacheProvider(ICacheProvider):
+    """Marker"""
+
+
+class IFSCacheProvider(ICacheProvider):
+    """Marker"""
+
+
+class IMemcachedProvider(ICacheProvider):
+    """Marker"""

bda/cache/memcached.py

@@ -0,0 +1,131 @@
+# Copyright 2009, Blue Dynamics Alliance, Austria - http://bluedynamics.com
+# GNU General Public Licence Version 2 or later
+"""
+Module memcache.
+
+This module provides fuctionallity for caching objects in a memcache server.
+"""
+
+from bda.cache.interfaces import CacheException
+from bda.cache.interfaces import ICacheManager
+from bda.cache.interfaces import IMemcachedProvider
+from zope.component import adapter
+from zope.component import provideAdapter
+from zope.interface import implementer
+
+
+try:
+    import libmc
+
+    LIBMC = True
+except ImportError:
+    LIBMC = False
+try:
+    import pylibmc
+    import zlib
+
+    PYLIBMC = True
+except ImportError:
+    PYLIBMC = False
+
+if LIBMC:
+    Client = libmc.Client
+elif PYLIBMC:
+    Client = pylibmc.Client
+else:
+    from memcache import Client
+
+
+class MemcachedException(CacheException):
+    pass
+
+
+@implementer(IMemcachedProvider)
+class Memcached:
+    def __init__(self, servers):
+        """Initialize memcached.
+        @param servers: an array of servers. Servers can be passed in two forms:
+            1. Strings of the form host:port (implies a default weight of 1).
+            2. Tuples of the form (host:port, weight) (weight as integer)
+        """
+        if LIBMC:
+            self._client = Client(servers, comp_threshold=10240, noreply=True)
+        else:
+            self._client = Client(servers)
+        self.timeout = 0
+
+    def reset(self):
+        self._client.flush_all()
+
+    def size(self):
+        bytes = 0
+        stats = self._client.get_stats()
+        for name, stat in stats:
+            bytes += int(stat['bytes'])
+        return bytes
+
+    def keys(self):
+        raise MemcachedException("It's not possible to fetch keys from memcached")
+
+    def values(self):
+        raise MemcachedException("It's not possible to fetch values from memcached")
+
+    def get(self, key, default=None):
+        value = self._client.get(key)
+        if value is not None:
+            return value
+        return default
+
+    def __getitem__(self, key):
+        return self._client.get(key)
+
+    def __setitem__(self, key, object):
+        if PYLIBMC and not LIBMC:
+            self._client.set(
+                key,
+                object,
+                time=self.timeout,
+                min_compress_len=1024000,
+                compress_level=zlib.Z_BEST_SPEED,
+            )
+        else:
+            self._client.set(key, object, time=self.timeout)
+
+    def __delitem__(self, key):
+        self._client.delete(key)
+
+
+@implementer(ICacheManager)
+@adapter(IMemcachedProvider)
+class MemcachedManager:
+    def __init__(self, context):
+        self.cache = context
+
+    def setTimeout(self, timeout):
+        self.cache.timeout = timeout
+
+    def getData(self, func, key, force_reload=False, args=[], kwargs={}):
+        ret = self.get(key, force_reload)
+        if ret is None:
+            ret = func(*args, **kwargs)
+            self.set(key, ret)
+        return ret
+
+    def get(self, key, force_reload=False):
+        if force_reload:
+            del self.cache[key]
+            return None
+        return self.cache.get(key, None)
+
+    def set(self, key, item):
+        self.cache[key] = item
+
+    def rem(self, key):
+        """deprecated, use __delitem___"""
+        del self.cache[key]
+
+    def __delitem__(self, key):
+        del self.cache[key]
+
+
+provideAdapter(MemcachedManager)

bda/cache/nullcache.py

@@ -0,0 +1,68 @@
+# Copyright 2009, Blue Dynamics Alliance, Austria - http://bluedynamics.com
+# GNU General Public Licence Version 2 or later
+
+from bda.cache.interfaces import ICacheManager
+from bda.cache.interfaces import INullCacheProvider
+from zope.component import adapter
+from zope.component import provideAdapter
+from zope.interface import implementer
+
+
+@implementer(INullCacheProvider)
+class NullCache:
+    """Dummy implementation which does nothing and can be used as fallback."""
+
+    def __init__(self):
+        pass
+
+    def reset(self):
+        pass
+
+    def size(self):
+        return 0
+
+    def keys(self):
+        raise NotImplementedError("It's not possible to fetch keys from nothing")
+
+    def values(self):
+        raise NotImplementedError("It's not possible to fetch values from nothing")
+
+    def get(self, key, default=None):
+        return None
+
+    def __getitem__(self, key):
+        return None
+
+    def __setitem__(self, key, object):
+        pass
+
+    def __delitem__(self, key):
+        pass
+
+
+@implementer(ICacheManager)
+@adapter(INullCacheProvider)
+class NullCacheManager:
+    def __init__(self, context):
+        pass
+
+    def setTimeout(self, timeout):
+        pass
+
+    def getData(self, func, key, force_reload=False, args=[], kwargs={}):
+        return func(*args, **kwargs)
+
+    def get(self, key, force_reload=False):
+        return None
+
+    def set(self, key, item):
+        pass
+
+    def rem(self, key):
+        pass
+
+    def __delitem__(self, key):
+        pass
+
+
+provideAdapter(NullCacheManager)

bda/cache/tests/__init__.py

@@ -0,0 +1 @@
+#

bda/cache/tests/test_fscache.py

@@ -0,0 +1,236 @@
+from bda.cache import FSCache
+from bda.cache import FSCacheException
+from bda.cache import FSCacheManager
+from bda.cache import ICacheManager
+from bda.cache.interfaces import IFSCacheProvider
+from unittest import mock
+import os
+import shutil
+import tempfile
+import time
+import unittest
+
+
+class FSCacheTestCase(unittest.TestCase):
+    def setUp(self):
+        self.tempdir = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, self.tempdir)
+        self.cachedir = os.path.join(self.tempdir, 'cache')
+        os.mkdir(self.cachedir)
+
+    def listdir(self, *path):
+        return sorted(os.listdir(os.path.join(self.cachedir, *path)))
+
+
+class TestFSCacheInit(FSCacheTestCase):
+    def test_relative_path(self):
+        with self.assertRaises(FSCacheException) as cm:
+            FSCache('notabspath')
+        self.assertEqual(
+            str(cm.exception),
+            "Cannot initialize cache. 'notabspath' is not an absolute path.",
+        )
+
+    def test_missing_directory(self):
+        path = os.path.join(self.tempdir, 'missing')
+        with self.assertRaises(FSCacheException) as cm:
+            FSCache(path)
+        self.assertEqual(
+            str(cm.exception), f"Cannot initialize cache. Directory '{path}' not exists."
+        )
+
+    def test_not_a_directory(self):
+        path = os.path.join(self.tempdir, 'file')
+        with open(path, 'w') as f:
+            f.write('hallo')
+        with self.assertRaises(FSCacheException) as cm:
+            FSCache(path)
+        self.assertEqual(
+            str(cm.exception), f"Cannot initialize cache. '{path}' is not a Directory."
+        )
+
+    def test_create_missing_directory(self):
+        path = os.path.join(self.tempdir, 'a', 'b')
+        cache = FSCache(path, createDirIfNotExist=True)
+        self.assertTrue(os.path.isdir(path))
+        self.assertEqual(cache.cachedir, path)
+
+    def test_create_existing_directory(self):
+        cache = FSCache(self.cachedir, createDirIfNotExist=True)
+        self.assertEqual(cache.cachedir, self.cachedir)
+
+    def test_defaults(self):
+        cache = FSCache(self.cachedir)
+        self.assertTrue(IFSCacheProvider.providedBy(cache))
+        self.assertEqual(cache.protocol, 2)
+        self.assertEqual(cache.size(), 0)
+
+
+class TestFSCache(FSCacheTestCase):
+    def setUp(self):
+        super().setUp()
+        self.cache = FSCache(self.cachedir)
+
+    def test_dotted_key_is_stored_in_directory_tree(self):
+        self.cache['user.section.msg'] = 'message'
+        self.assertEqual(self.listdir(), ['user'])
+        self.assertEqual(self.listdir('user'), ['section'])
+        self.assertEqual(self.listdir('user', 'section'), ['msg.'])
+        self.assertEqual(self.cache['user.section.msg'], 'message')
+
+    def test_key_may_be_part_of_another_key(self):
+        # Every file gets a trailing dot, thus 'user' is stored at 'user.'
+        # next to the directory 'user' containing 'user.section'.
+        self.cache['user'] = {'key': 'user'}
+        self.cache['user.section'] = {'key': 'user.section'}
+        self.assertEqual(self.listdir(), ['user', 'user.'])
+        self.assertEqual(self.cache['user'], {'key': 'user'})
+        self.assertEqual(self.cache['user.section'], {'key': 'user.section'})
+
+    def test_missing_key(self):
+        self.assertIsNone(self.cache['notavailable'])
+        self.assertIsNone(self.cache.get('notavailable'))
+        self.assertEqual(self.cache.get('notavailable', 'works'), 'works')
+
+    def test_overwrite(self):
+        self.cache['user.section.msg'] = 'message'
+        self.cache['user.section.msg'] = {'anykey': 'anydata'}
+        self.assertEqual(self.cache.get('user.section.msg'), {'anykey': 'anydata'})
+
+    def test_keys_and_values(self):
+        self.cache['anythingelse'] = 'anythingelse'
+        self.cache['user'] = 'user'
+        self.cache['user.section'] = ['user.section']
+        self.cache['user.section.msg0'] = {'msg': 0}
+        self.cache['user.section.msg1'] = {'msg': 1}
+        self.assertEqual(
+            sorted(self.cache.keys()),
+            [
+                'anythingelse',
+                'user',
+                'user.section',
+                'user.section.msg0',
+                'user.section.msg1',
+            ],
+        )
+        self.assertCountEqual(
+            self.cache.values(),
+            ['anythingelse', 'user', ['user.section'], {'msg': 0}, {'msg': 1}],
+        )
+
+    def test_delete_removes_empty_directories(self):
+        self.cache['user.section'] = 'section'
+        self.cache['user.section.msg0'] = 'msg0'
+        self.cache['user.section.msg1'] = 'msg1'
+        del self.cache['user.section.msg0']
+        self.assertEqual(self.listdir('user', 'section'), ['msg1.'])
+        del self.cache['user.section.msg1']
+        self.assertEqual(self.listdir('user'), ['section.'])
+        del self.cache['user.section']
+        self.assertEqual(self.listdir(), [])
+
+    def test_delete_removes_empty_directories_recursively(self):
+        self.cache['1.2.3.4'] = 'value'
+        self.assertEqual(self.listdir('1', '2', '3'), ['4.'])
+        del self.cache['1.2.3.4']
+        self.assertEqual(self.listdir(), [])
+
+    def test_delete_keeps_non_empty_directories(self):
+        self.cache['user.whatever.object'] = 'something'
+        self.cache['user.other'] = 'other'
+        del self.cache['user.whatever.object']
+        self.assertEqual(self.listdir(), ['user'])
+        self.assertEqual(self.listdir('user'), ['other.'])
+
+    def test_delete_missing_key(self):
+        del self.cache['notavailable']
+        del self.cache['not.available']
+        self.assertEqual(self.listdir(), [])
+
+    def test_reset(self):
+        for key in ['1', '2', '1.1', '1.1.1', '1.2.3.1', '1.2.3.2']:
+            self.cache[key] = ['something']
+        self.assertEqual(
+            sorted(self.cache.keys()), ['1', '1.1', '1.1.1', '1.2.3.1', '1.2.3.2', '2']
+        )
+        self.cache.reset()
+        self.assertEqual(self.cache.keys(), [])
+
+
+class TestFSCacheManager(FSCacheTestCase):
+    def setUp(self):
+        super().setUp()
+        self.cache = FSCache(self.cachedir)
+        self.manager = ICacheManager(self.cache)
+
+    def test_adapter_registered(self):
+        self.assertIsInstance(self.manager, FSCacheManager)
+        self.assertIs(self.manager.cache, self.cache)
+        self.assertEqual(self.manager.timeout, 300)
+
+    def test_set_timeout(self):
+        self.manager.setTimeout(10)
+        self.assertEqual(self.manager.timeout, 10)
+
+    def test_set_and_get(self):
+        self.manager.set('foo', 'bar')
+        self.assertEqual(self.manager.get('foo'), 'bar')
+        self.assertEqual(list(self.cache['creationmap']), ['foo'])
+
+    def test_set_without_creationtime(self):
+        # Items without creation time are considered as timed out.
+        self.manager.set('foo', 'bar', set_creationtime=False)
+        self.assertEqual(self.cache['foo'], 'bar')
+        self.assertIsNone(self.cache['creationmap'])
+        self.assertIsNone(self.manager.get('foo'))
+        self.assertIsNone(self.cache['foo'])
+
+    def test_get_missing_creationtime(self):
+        self.manager.set('foo', 'bar')
+        self.manager.set('baz', 'qux', set_creationtime=False)
+        self.assertIsNone(self.manager.get('baz'))
+        self.assertIsNone(self.cache['baz'])
+        self.assertEqual(list(self.cache['creationmap']), ['foo'])
+
+    def test_get_timed_out(self):
+        self.manager.set('foo', 'bar')
+        with mock.patch('time.time', return_value=time.time() + 301):
+            self.assertIsNone(self.manager.get('foo'))
+        self.assertIsNone(self.cache['foo'])
+        self.assertEqual(self.cache['creationmap'], {})
+
+    def test_get_force_reload(self):
+        self.manager.set('foo', 'bar')
+        self.assertIsNone(self.manager.get('foo', force_reload=True))
+        self.assertIsNone(self.cache['foo'])
+        self.assertEqual(self.cache['creationmap'], {})
+
+    def test_get_data(self):
+        calls = []
+
+        def square(x):
+            calls.append(x)
+            return x * x
+
+        self.assertEqual(self.manager.getData(square, '4', args=[4]), 16)
+        self.assertEqual(self.manager.getData(square, '4', args=[4]), 16)
+        self.assertEqual(calls, [4])
+        self.assertEqual(self.manager.getData(square, '4', True, args=[4]), 16)
+        self.assertEqual(self.manager.getData(square, '5', kwargs={'x': 5}), 25)
+        self.assertEqual(calls, [4, 4, 5])
+
+    def test_rem(self):
+        self.manager.set('foo', 'bar')
+        self.manager.set('baz', 'qux')
+        self.manager.rem('foo')
+        self.assertIsNone(self.cache['foo'])
+        self.assertEqual(list(self.cache['creationmap']), ['baz'])
+        del self.manager['baz']
+        self.assertIsNone(self.cache['baz'])
+        self.assertEqual(self.cache['creationmap'], {})
+
+    def test_rem_without_creationtime(self):
+        self.manager.set('foo', 'bar', set_creationtime=False)
+        self.manager.rem('foo')
+        self.assertIsNone(self.cache['foo'])
+        self.assertIsNone(self.cache['creationmap'])

bda/cache/tests/test_memcached.py

@@ -0,0 +1,231 @@
+from bda.cache import ICacheManager
+from bda.cache import Memcached
+from bda.cache import memcached
+from bda.cache import MemcachedException
+from bda.cache import MemcachedManager
+from bda.cache.interfaces import IMemcachedProvider
+from unittest import mock
+import importlib.util
+import sys
+import types
+import unittest
+import zlib
+
+
+SERVERS = ['127.0.0.1:11211']
+
+
+class FakeClient:
+    """In-memory replacement for ``memcache.Client``.
+
+    Keeps the tests independent of a running memcached server.
+    """
+
+    stats = [
+        ('127.0.0.1:11211 (1)', {'bytes': '40'}),
+        ('127.0.0.1:11212 (1)', {'bytes': '25'}),
+    ]
+
+    def __init__(self, servers):
+        self.servers = servers
+        self.data = {}
+        self.expiration_times = {}
+
+    def get(self, key):
+        return self.data.get(key)
+
+    def set(self, key, value, time=0):
+        self.data[key] = value
+        self.expiration_times[key] = time
+
+    def delete(self, key):
+        self.data.pop(key, None)
+
+    def flush_all(self):
+        self.data.clear()
+
+    def get_stats(self):
+        return self.stats
+
+
+def patch_python_memcached(testcase):
+    patcher = mock.patch.multiple(
+        memcached, Client=FakeClient, LIBMC=False, PYLIBMC=False
+    )
+    patcher.start()
+    testcase.addCleanup(patcher.stop)
+
+
+class TestMemcached(unittest.TestCase):
+    def setUp(self):
+        patch_python_memcached(self)
+        self.provider = Memcached(SERVERS)
+        self.client = self.provider._client
+
+    def test_init(self):
+        self.assertTrue(IMemcachedProvider.providedBy(self.provider))
+        self.assertIsInstance(self.client, FakeClient)
+        self.assertEqual(self.client.servers, SERVERS)
+        self.assertEqual(self.provider.timeout, 0)
+
+    def test_set_and_get(self):
+        self.assertIsNone(self.provider['somekey'])
+        self.assertEqual(self.provider.get('somekey', 'default'), 'default')
+        self.provider['somekey'] = 'somevalue'
+        self.assertEqual(self.provider['somekey'], 'somevalue')
+        self.assertEqual(self.provider.get('somekey', 'default'), 'somevalue')
+
+    def test_timeout_is_passed_as_expiration_time(self):
+        self.provider['1'] = 1
+        self.provider.timeout = 2
+        self.provider['2'] = 2
+        self.assertEqual(self.client.expiration_times, {'1': 0, '2': 2})
+
+    def test_delete(self):
+        self.provider['somekey'] = 'somevalue'
+        del self.provider['somekey']
+        self.assertIsNone(self.provider['somekey'])
+
+    def test_reset(self):
+        self.provider['1'] = 'Eins'
+        self.provider['2'] = 'Zwei'
+        self.provider.reset()
+        self.assertEqual((self.provider['1'], self.provider['2']), (None, None))
+
+    def test_size_sums_up_bytes_of_all_servers(self):
+        self.assertEqual(self.provider.size(), 65)
+
+    def test_keys_not_supported(self):
+        with self.assertRaises(MemcachedException) as cm:
+            self.provider.keys()
+        self.assertEqual(
+            str(cm.exception), "It's not possible to fetch keys from memcached"
+        )
+
+    def test_values_not_supported(self):
+        with self.assertRaises(MemcachedException) as cm:
+            self.provider.values()
+        self.assertEqual(
+            str(cm.exception), "It's not possible to fetch values from memcached"
+        )
+
+
+class TestMemcachedManager(unittest.TestCase):
+    def setUp(self):
+        patch_python_memcached(self)
+        self.provider = Memcached(SERVERS)
+        self.manager = ICacheManager(self.provider)
+
+    def test_adapter_registered(self):
+        self.assertIsInstance(self.manager, MemcachedManager)
+        self.assertIs(self.manager.cache, self.provider)
+
+    def test_set_timeout(self):
+        self.manager.setTimeout(10)
+        self.assertEqual(self.provider.timeout, 10)
+
+    def test_set_and_get(self):
+        self.manager.set('AnotherKey', 'AnotherValue')
+        self.assertEqual(self.manager.get('AnotherKey'), 'AnotherValue')
+
+    def test_get_force_reload(self):
+        self.manager.set('AnotherKey', 'AnotherValue')
+        self.assertIsNone(self.manager.get('AnotherKey', True))
+        self.assertIsNone(self.manager.get('AnotherKey'))
+
+    def test_get_data(self):
+        calls = []
+
+        def square(x):
+            calls.append(x)
+            return x * x
+
+        self.assertEqual(self.manager.getData(square, '4', args=[4]), 16)
+        self.assertEqual(self.manager.getData(square, '4', args=[4]), 16)
+        self.assertEqual(calls, [4])
+        self.assertEqual(self.manager.getData(square, '4', True, args=[4]), 16)
+        self.assertEqual(self.manager.getData(square, '5', True, kwargs={'x': 5}), 25)
+        self.assertEqual(calls, [4, 4, 5])
+        self.assertEqual(self.manager.get('5'), 25)
+
+    def test_delete(self):
+        self.manager.set('5', 25)
+        del self.manager['5']
+        self.assertIsNone(self.manager.get('5'))
+
+    def test_rem(self):
+        self.manager.set('5', 25)
+        self.manager.rem('5')
+        self.assertIsNone(self.manager.get('5'))
+
+
+def fake_module(name):
+    module = types.ModuleType(name)
+    module.Client = mock.Mock(name=f'{name}.Client')
+    return module
+
+
+def load_memcached_module(**modules):
+    """Load a fresh copy of ``bda.cache.memcached``.
+
+    The client library is selected at import time, the given ``modules``
+    replace the installed ones meanwhile, ``None`` means not installed. The
+    copy is not added to ``sys.modules`` and does not register its adapter.
+    """
+    spec = importlib.util.find_spec('bda.cache.memcached')
+    module = importlib.util.module_from_spec(spec)
+    with (
+        mock.patch.dict(sys.modules, modules),
+        mock.patch('zope.component.provideAdapter') as provide_adapter,
+    ):
+        spec.loader.exec_module(module)
+    provide_adapter.assert_called_once_with(module.MemcachedManager)
+    return module
+
+
+class TestClientLibrarySelection(unittest.TestCase):
+    def test_python_memcached(self):
+        memcache = fake_module('memcache')
+        module = load_memcached_module(libmc=None, pylibmc=None, memcache=memcache)
+        self.assertFalse(module.LIBMC)
+        self.assertFalse(module.PYLIBMC)
+        provider = module.Memcached(SERVERS)
+        memcache.Client.assert_called_once_with(SERVERS)
+        provider['key'] = 'value'
+        provider._client.set.assert_called_once_with('key', 'value', time=0)
+
+    def test_libmc(self):
+        libmc = fake_module('libmc')
+        module = load_memcached_module(libmc=libmc, pylibmc=None)
+        self.assertTrue(module.LIBMC)
+        self.assertFalse(module.PYLIBMC)
+        provider = module.Memcached(SERVERS)
+        libmc.Client.assert_called_once_with(SERVERS, comp_threshold=10240, noreply=True)
+        provider['key'] = 'value'
+        provider._client.set.assert_called_once_with('key', 'value', time=0)
+
+    def test_pylibmc(self):
+        pylibmc = fake_module('pylibmc')
+        module = load_memcached_module(libmc=None, pylibmc=pylibmc)
+        self.assertFalse(module.LIBMC)
+        self.assertTrue(module.PYLIBMC)
+        provider = module.Memcached(SERVERS)
+        pylibmc.Client.assert_called_once_with(SERVERS)
+        provider['key'] = 'value'
+        provider._client.set.assert_called_once_with(
+            'key',
+            'value',
+            time=0,
+            min_compress_len=1024000,
+            compress_level=zlib.Z_BEST_SPEED,
+        )
+
+    def test_libmc_is_preferred_over_pylibmc(self):
+        libmc = fake_module('libmc')
+        pylibmc = fake_module('pylibmc')
+        module = load_memcached_module(libmc=libmc, pylibmc=pylibmc)
+        provider = module.Memcached(SERVERS)
+        libmc.Client.assert_called_once_with(SERVERS, comp_threshold=10240, noreply=True)
+        pylibmc.Client.assert_not_called()
+        provider['key'] = 'value'
+        provider._client.set.assert_called_once_with('key', 'value', time=0)

bda/cache/tests/test_nullcache.py

@@ -0,0 +1,61 @@
+from bda.cache import ICacheManager
+from bda.cache import NullCache
+from bda.cache import NullCacheManager
+from bda.cache.interfaces import INullCacheProvider
+import unittest
+
+
+class TestNullCache(unittest.TestCase):
+    def test_provides_null_cache_provider(self):
+        self.assertTrue(INullCacheProvider.providedBy(NullCache()))
+
+    def test_is_always_empty(self):
+        provider = NullCache()
+        provider['foo'] = object()
+        self.assertIsNone(provider['foo'])
+        self.assertIsNone(provider.get('foo'))
+        self.assertIsNone(provider.get('foo', 'default'))
+        self.assertEqual(provider.size(), 0)
+        provider.reset()
+        del provider['foo']
+
+    def test_keys_not_supported(self):
+        with self.assertRaises(NotImplementedError) as cm:
+            NullCache().keys()
+        self.assertEqual(
+            str(cm.exception), "It's not possible to fetch keys from nothing"
+        )
+
+    def test_values_not_supported(self):
+        with self.assertRaises(NotImplementedError) as cm:
+            NullCache().values()
+        self.assertEqual(
+            str(cm.exception), "It's not possible to fetch values from nothing"
+        )
+
+
+class TestNullCacheManager(unittest.TestCase):
+    def test_adapter_registered(self):
+        manager = ICacheManager(NullCache())
+        self.assertIsInstance(manager, NullCacheManager)
+
+    def test_never_caches(self):
+        manager = ICacheManager(NullCache())
+        manager.setTimeout(0)
+        manager.set('foo', object())
+        self.assertIsNone(manager.get('foo'))
+        manager.rem('foo')
+        del manager['foo']
+
+    def test_get_data_always_calls_function(self):
+        calls = []
+
+        def func(*args, **kwargs):
+            calls.append((args, kwargs))
+            return 'result'
+
+        manager = ICacheManager(NullCache())
+        result = manager.getData(func, 'foo', args=[1], kwargs={'a': 2})
+        self.assertEqual(result, 'result')
+        manager.getData(func, 'foo', args=[1], kwargs={'a': 2})
+        self.assertEqual(calls, [((1,), {'a': 2}), ((1,), {'a': 2})])

bda_cache-2.0.0.dist-info/METADATA

@@ -0,0 +1,197 @@
+Metadata-Version: 2.5
+Name: bda.cache
+Version: 2.0.0
+Summary: Simple caching infrastructure.
+Project-URL: Homepage, https://github.com/bluedynamics/bda.cache
+Author-email: Robert Niederreiter <rnix@squarewave.at>
+License: GNU General Public License v2 or later (GPLv2+)
+Keywords: caching,fscache,memcached,zca,zope
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.10
+Requires-Dist: python-memcached
+Requires-Dist: zope-component
+Provides-Extra: libmc
+Requires-Dist: libmc; extra == 'libmc'
+Provides-Extra: pylibmc
+Requires-Dist: pylibmc; extra == 'pylibmc'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/x-rst
+
+.. image:: https://img.shields.io/pypi/v/bda.cache.svg
+    :target: https://pypi.python.org/pypi/bda.cache
+    :alt: Latest PyPI version
+
+.. image:: https://img.shields.io/pypi/dm/bda.cache.svg
+    :target: https://pypi.python.org/pypi/bda.cache
+    :alt: Number of PyPI downloads
+
+.. image:: https://github.com/bluedynamics/bda.cache/actions/workflows/test.yml/badge.svg
+    :target: https://github.com/bluedynamics/bda.cache/actions/workflows/test.yml
+    :alt: Test bda.cache
+
+
+General Caching API
+===================
+
+This package is designed to be used by applications which require different
+kinds of caching flavour. This is abstracted due to the interfaces
+``ICacheProvider`` and  ``ICacheManager``. ICacheProvider takes care of the
+concrete cache implementation, ICacheManager is the read/write interface.
+
+The convention is to adapt a concrete ICacheProvider implementation
+
+.. code-block:: python
+
+    from bda.cache import ICacheManager
+    from bda.cache import Memcached
+
+    provider = Memcached(['127.0.0.1:11211'])
+    manager = ICacheManager(provider)
+
+We can ask the manager for data inside the cache
+
+.. code-block:: python
+
+    data = manager.get('somekey', force_reload=False)
+
+If ``force_reload`` is set to True, try to delete data with key from cache and
+return None.
+
+We're also able to manipulate the cache's data (some restrictions my result out
+of backend not providing them)
+
+.. code-block:: python
+
+    manager.set('somekey', object())
+
+There exist a convenience to use some API's and cache it's results all at once.
+
+.. code-block:: python
+
+    data = manager.getData(func, key, force_reload=False, args=[], kwargs={})
+
+First the data for ``key`` is looked up inside the cache provider. If not found
+there or if ``force_reload`` is set to True, call given ``func`` . The return
+value of this function will be stored in the cache provider. ``args`` and
+``kwargs`` are passed as parameters to given function if it's call is required.
+
+You might ask why all this is done due to 2 seperate interfaces...
+
+Some usecase might require different cache providers i.e. for different payload
+size. This way you can implement any other cache provider usage as well due to
+the cache manager interface.
+
+
+Dependencies
+------------
+
+- ``zope.interface``
+
+- ``zope.component``
+
+- ``bda.cache.memcached.Memcached`` requires ``python-memcached``
+
+
+Notes
+-----
+
+If you're interessted to contribute; Feel free but keep in mind that this code
+is planned to be released under a BSD like licence in future.
+
+
+Changes
+=======
+
+2.0.0 (2026-10-31)
+------------------
+
+- Fix the client library selection in ``bda.cache.memcached`` if both
+  ``libmc`` and ``pylibmc`` are installed. ``pylibmc.Client`` was initialized
+  with the ``libmc`` arguments. ``libmc`` is preferred now, as intended.
+  [rnix]
+
+- Drop the Python 2 remnants: the ``six`` imports in ``bda.cache.fscache``
+  and ``bda.cache.memcached`` (``six`` never was a declared dependency),
+  ``class X(object)`` and the ``IOError`` alias. Remove the unreachable code
+  in ``FSCache.__delitem__`` and the unused ``ICacheProvider`` import in
+  ``bda.cache.memcached``. Behaviour unchanged.
+  [rnix]
+
+- Convert the doctests to unittest tests and use pytest as test runner. The
+  memcached tests use a fake client and no longer need a running memcached
+  server. Drop the ``interlude`` and ``zope.testing`` test dependencies.
+  [rnix]
+
+- Sort the imports with ruff (one per line, ``from`` imports first, no
+  sections) and format the code with ``ruff format`` (90 characters per line,
+  single quotes).
+  [rnix]
+
+- Add ``Makefile`` (mxmake) with ``qa.ruff``, ``qa.test`` and ``qa.coverage``
+  domains, pin the ruff configuration in ``pyproject.toml`` and add a GitHub
+  Actions test workflow.
+  [rnix]
+
+- Refactor package layout to use ``pyproject.toml`` and implicit namespace
+  packages.
+  [rnix]
+
+- Drop Python 2 support. Python >= 3.10 is required.
+  [rnix]
+
+
+1.3.0 (2019-02-05)
+------------------
+
+- Python 3 comaptibility [reinhardt]
+
+- Code style (black/isort) [jensens]
+
+1.2.0 (2017-10-19)
+------------------
+
+- Change to use libmc or pylibmc when available
+
+- Add option to require with bda.cache[pylibmc] or bda.cache[libmc]
+
+
+1.1.2 (2009-02-10)
+------------------
+
+- remove legacy code
+
+
+1.1.1 (2009-02-10)
+------------------
+
+- bugfix in zcml configuration.
+
+
+1.1 (2009-02-09)
+----------------
+
+- Cache Managers are now adapters.
+
+- Implement memcached server support
+
+- deprecate the default CacheManager
+
+- Fix tests for FSCache
+
+
+1.0
+---
+
+- Initial work
+

bda_cache-2.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+bda/cache/__init__.py,sha256=6F3RtJXBWpmpqAXJJUd2TtazSn64-IJhWxtLz6p-lO0,715
+bda/cache/configure.zcml,sha256=I1CysdnqB3ak2tfReSKlnQPaEySG8f9deffbFCD0fEo,106
+bda/cache/fscache.py,sha256=GqU3eqCkYlG_mDXhkAXrR9uf5B4-CgdegprLP2aavX8,7869
+bda/cache/interfaces.py,sha256=9KU8Brhy6-8mDgaahuI91pXve7emyhNZhqDgkuJ11jw,2516
+bda/cache/memcached.py,sha256=LkRoRyCWWAKDwwbtUVGTcyXlEeYOUfLProcYKjP2--Q,3351
+bda/cache/nullcache.py,sha256=I-RNavUCQ2kCibdFAklUrTcAScdDYT715X2dWBvvHWQ,1522
+bda/cache/tests/__init__.py,sha256=MsSFjiLMLJZ7QhUPpVBWKiyDnCzryquRyr329NoCACI,2
+bda/cache/tests/test_fscache.py,sha256=BkSkSdPp4YZxBUVLDtBsWLMUKn18U0ap1pwBxWf_-Og,9013
+bda/cache/tests/test_memcached.py,sha256=eWugOcIHSayKx_snQM8nHMjFriK4jLg-3b_tCZ2rKgs,7858
+bda/cache/tests/test_nullcache.py,sha256=bQEEgJqBy2-QMuncrsiFrgDbw6Do1XgbGYD9EyKHnCA,2085
+bda_cache-2.0.0.dist-info/METADATA,sha256=CYGfIWRUk-WUbSbfhnezuePUndGspeTWIhaSNdC4q2E,5747
+bda_cache-2.0.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+bda_cache-2.0.0.dist-info/RECORD,,

bda_cache-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any