class A(CacheModel): a = Key() b = Key()
class R(CacheModel): k = Key() ref = Reference(C)
class S(CacheModel): k = Key() value = Field() ref = Reference('self')
class P(CacheModel): k = Key() p = PickleField()
class F(CacheModel): a = Key() b = Field()
class E(CacheModel): a = Key() b = Field() def from_miss(self, a): self.b = a + 1
class C(CacheModel): name = Key() value = Field()
class CachedMethod(CacheModel): """Caches the result of a callable based on the arguments it was called with, but also on a list of attributes on the instance the method is called on. :: class Home(object): def __init__(self, address): self.address = address @CachedMethod('address') def geocode(self): return g.geocode(self.address) This example caches each call to ``geocode()`` uniquele for each value of the ``address`` attribute. """ module = Key() classname = Key() method_name = Key() data = Key() args = Key() kwargs = Key() result = Field() @classmethod def cache(cls, key_attrs, expires=None): """Decorates a method to provide cached-memoization using a combination of the positional arguments, keyword argments, and whitelisted instance attributes. """ def decorator(func): @functools.wraps(func) def wrapper(self, *args, **kwargs): module = type(self).__module__ classname = type(self).__name__ method_name = func.__name__ data = {} if isinstance(key_attrs, basestring): _key_attrs = key_attrs.split() else: _key_attrs = key_attrs for key_attr in _key_attrs: key_value = getattr(self, key_attr) if isinstance(key_value, dict): key_value = ('dict', sorted(key_value.items())) elif isinstance(key_value, set): key_value = ('set', sorted(key_value)) else: key_value = (type(key_value).__name__, key_value) data[key_attr] = key_value data = sorted(data.items()) result_cache, new = cls.get_or_create( module=module, classname=classname, method_name=method_name, data=data, args=args, kwargs=sorted(kwargs.items()), ) if new: result_cache.result = func(self, *args, **kwargs) result_cache.save(expires) return result_cache.result return wrapper return decorator