fix timed-sized cache

- add cache_info and cache_access attributes
- add and update tests

Author: jaemk

README.md

@@ -10,13 +10,20 @@
 
 The `cached` decorator requires the arguments of the wrapped function to be hashable.
 `cached` accepts arguments `capacity` and `seconds` to limit the size of the cache and limit age of cached items.
+`cached` functions similarly to `functools.lru_cache` with the additional of the optional time constraint.
 
 ```python
+import time
 from cashed import cached
 
-@cached(capacity=100)
+@cached(capacity=100, seconds=5)
 def fib(n):
     if n == 0 or n == 1:
         return n
     return fib(n-1) + fib(n-2)
+
+fib(100)          # -> 354224848179261915075L
+fib.cache_info()  # -> {'seconds': 5, 'hits': 98, 'capacity': 100, 'misses': 101, 'size': 100}
+time.sleep(5)
+fib.cache_info()  # -> {'hits': 98, 'capacity': 100, 'seconds': 5, 'misses': 101, 'size': 0}
 ```

cashed/cache.py

@@ -1,4 +1,5 @@
 from collections import OrderedDict
+from collections import namedtuple
 from functools import wraps
 import time
 
@@ -61,7 +62,7 @@ def timed_get(self, key):
         now = time.time()
         then, val = self.store[key]
         if (now - then) > self.limit:
-            del self.store[key]
+            self.__delitem__(key)
             raise KeyError
         return val
 
@@ -73,7 +74,7 @@ def timed_set(self, key, value, return_dont_set=False):
         self.store[key] = stamped_val
 
     def timed_del(self, key):
-        del self[key]
+        del self.store[key]
 
 
 class TimedCache(Timed):
@@ -89,21 +90,36 @@ def __init__(self, seconds=None):
             raise CacheError("TimedCache expects a single argument: `seconds`")
         self.store = {}
         self.limit = seconds
+        self.size = 0
 
     def __getitem__(self, key):
         return self.timed_get(key)
 
     def __setitem__(self, key, value):
+        if key not in self.store:
+            self.size += 1
         return self.timed_set(key, value)
 
-    def __delitem(self, key):
-        del self.store[key]
+    def __delitem__(self, key):
+        self.size -= 1
+        return self.timed_del(key)
 
     def __repr__(self):
-        return '<TimedCache[{}s]: {}>'.format(self.limit, [(k, self.store[k]) for k in self.store])
+        return '<TimedCache[{}s]>'.format(self.limit)
+
+    def _safe_get(self, k):
+        try:
+            return self[k]
+        except KeyError:
+            return None
 
     def items(self):
-        return self.store.items()
+        keys = list(self.store.keys())
+        return (pair for pair in ((k, self._safe_get(k)) for k in keys)
+                if pair[-1] is not None)
+
+    def clean(self):
+        [_ for _ in self.items()]
 
 
 class SizedCache(Sized):
@@ -132,11 +148,11 @@ def __delitem__(self, key):
         return self.sized_del(key)
 
     def __repr__(self):
-        return '<SizedCache[{}cap : {}size]: {}>'\
-               .format(self.capacity, self.size, [(k, self.store[k]) for k in self.store])
+        return '<SizedCache[{}cap : {}size]>'\
+               .format(self.capacity, self.size)
 
     def items(self):
-        return self.store.items()
+        return ((k, self[k]) for k in self.store)
 
 
 class TimedSizedCache(Timed, Sized):
@@ -157,7 +173,8 @@ def __init__(self, capacity=None, seconds=None):
 
     def __getitem__(self, key):
         _ = self.timed_get(key)
-        return self.sized_get(key)
+        t, value = self.sized_get(key)
+        return value
 
     def __setitem__(self, key, value):
         stamped_val = self.timed_set(key, value, return_dont_set=True)
@@ -167,23 +184,54 @@ def __delitem__(self, key):
         return self.sized_del(key)
 
     def __repr__(self):
-        return '<TimedSizedCache[{}cap, {}size, {}s]: {}>'\
-                .format(self.capacity, self.size, self.limit, [(k, self.store[k]) for k in self.store])
+        return '<TimedSizedCache[{}cap, {}size, {}s]>'\
+                .format(self.capacity, self.size, self.limit)
+
+    def _safe_get(self, k):
+        try:
+            return self[k]
+        except KeyError:
+            return None
 
     def items(self):
-        return self.store.items()
+        keys = list(self.store.keys())
+        return (pair for pair in ((k, self._safe_get(k)) for k in keys)
+                if pair[-1] is not None)
+
+    def clean(self):
+        [_ for _ in self.items()]
+
+
+class CountDict(dict):
+    def __init__(self):
+        self.size = 0
+        super(CountDict, self).__init__()
+
+    def __setitem__(self, key, value):
+        if key not in self:
+            self.size += 1
+        super(CountDict, self).__setitem__(key, value)
+
+    def __delitem__(self, key):
+        self.size -= 1
+        super(CountDict, self).__delitem__(key, value)
 
 
 def cached(capacity=None, seconds=None, debug=False):
     """ Decorator to wrap a function with an optionally sized or timed cache. """
+    info = {'hits': 0, 'misses': 0}
     if capacity is not None and seconds is not None:
         cache = TimedSizedCache(capacity=capacity, seconds=seconds)
+        info['capacity'] = capacity
+        info['seconds'] = seconds
     elif capacity is not None:
         cache = SizedCache(capacity=capacity)
+        info['capacity'] = capacity
     elif seconds is not None:
         cache = TimedCache(seconds=seconds)
+        info['seconds'] = seconds
     else:
-        cache = {}
+        cache = CountDict()
 
     def _cached(func):
         @wraps(func)
@@ -192,16 +240,26 @@ def wrapper(*args, **kwargs):
             try:
                 v = cache[key]
                 was_cached = True
+                info['hits'] += 1
             except TypeError:
                 raise CacheError('Inputs args: {}, kwargs: {} are not cacheable. All arguments must be hashable'\
                                  .format(args, kwargs))
             except KeyError:
                 v = func(*args, **kwargs)
                 cache[key] = v
                 was_cached = False
+                info['misses'] += 1
             if debug:
                 return v, was_cached
             return v
+
+        def _cache_info():
+            if hasattr(cache, 'clean'):
+                cache.clean()
+            info.update({'size': cache.size})
+            return info
+        wrapper.cache_info = _cache_info
+        wrapper.cache_access = cache
         return wrapper
     return _cached
 

examples/simple.py

@@ -22,6 +22,7 @@ def slow_op(name, pet_name=None):
     start = time.time()
     ans = slow_op(name, pet_name=pet)
     print('{} -> {}'.format(time.time()-start, ans))
+print(slow_op.cache_info())
 
 
 ######
@@ -46,4 +47,5 @@ def fib_fast(n):
     for n in range(30):
         v = func(n)
     print(' ** {} -> {}s **'.format(_type, time.time()-start))
+    print(fib_fast.cache_info())
 

setup.py

@@ -2,7 +2,7 @@
 
 setup(
     name="cashed",
-    version="0.1.2",
+    version="0.2.0",
     description="Simple caching using decorators",
     author="James Kominick",
     author_email="[email protected]",

tests/test_simple.py

@@ -26,6 +26,7 @@ def test_basic_cache(self):
         elap2 = time.time() - start
 
         self.assertTrue(elap1 > elap2, "cached op is faster")
+        self.assertTrue(self.cached_op.cache_info()['size'] == 1)
 
 
 class SizedCacheTest(unittest.TestCase):
@@ -37,13 +38,21 @@ def cached_op(k, value=None):
         self.cached_op = cached_op
 
     def test_sized_cache(self):
-        [self.cached_op(n) for n in range(3)]
-        _, was_cached = self.cached_op(2)
+        [self.cached_op(n, value=n) for n in range(3)]
+        ans, was_cached = self.cached_op(2, value=2)
         self.assertTrue(was_cached)
-        _, was_cached = self.cached_op(20)
+        self.assertTrue(ans == 2)
+        ans, was_cached = self.cached_op(20, value=30)
         self.assertFalse(was_cached)
-        _, was_cached = self.cached_op(0)
+        self.assertTrue(ans == 30)
+        ans, was_cached = self.cached_op(0)
         self.assertFalse(was_cached)
+        self.assertTrue(ans is None)
+
+        info = self.cached_op.cache_info()
+        self.assertTrue(info['hits'] == 1)
+        self.assertTrue(info['misses'] == 5)
+        self.assertTrue(info['size'] == 3)
 
 
 class TimedCacheTest(unittest.TestCase):
@@ -56,11 +65,22 @@ def cached_op(n):
 
     def test_timed_cache(self):
         self.cached_op(1)
-        _, was_cached = self.cached_op(1)
+        ans, was_cached = self.cached_op(1)
         self.assertTrue(was_cached)
+        self.assertTrue(ans == 1)
         time.sleep(3)
-        _, was_cached = self.cached_op(1)
+        ans, was_cached = self.cached_op(1)
         self.assertFalse(was_cached)
+        self.assertTrue(ans == 1)
+
+        info = self.cached_op.cache_info()
+        self.assertTrue(info['hits'] == 1)
+        self.assertTrue(info['misses'] == 2)
+        self.assertTrue(info['size'] == 1)
+
+        time.sleep(3)
+        info = self.cached_op.cache_info()
+        self.assertTrue(info['size'] == 0)
 
 
 class TimedSizedCacheTest(unittest.TestCase):
@@ -73,12 +93,15 @@ def cached_op(n):
 
     def test_timedsized_cache(self):
         [self.cached_op(n) for n in range(2)]
-        _, was_cached = self.cached_op(2)
+        ans, was_cached = self.cached_op(2)
         self.assertFalse(was_cached)
-        _, was_cached = self.cached_op(0)
+        self.assertTrue(ans == 2)
+        ans, was_cached = self.cached_op(0)
         self.assertFalse(was_cached)
+        self.assertTrue(ans == 0)
         time.sleep(3)
-        _, was_cached = self.cached_op(2)
+        ans, was_cached = self.cached_op(2)
+        self.assertTrue(ans == 2)
         self.assertFalse(was_cached)