values, and","keys = list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in","``timestamp`` is older than the last region invalidation time. \"\"\" raise NotImplementedError() def","works by setting a current timestamp (using ``time.time()``) to consider all older timestamps","backends # noqa value_version = 1 \"\"\"An integer placed in the :class:`.CachedValue` so","-1. :param should_cache_fn: optional callable function which will receive the value returned by","by dogpile.core:Lock when appropriate ''' def runner(): try: value = creator() cache.set(somekey, value)","and persist the newly generated value in the cache. Whether or not the","last call to :meth:`.invalidate`. :param key: Key to be retrieved. While it's typical","already running a creation function for this key against the cache. When the","This callable will be called whenever the decorated function itself is called, in","to_str=compat.string_type, function_multi_key_generator=None): \"\"\"A function decorator that will cache multiple return values from the",":meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple","to convert to a string. Defaults to ``str()``. If the function accepts non-ascii","% prefix, wrap=config_dict.get( \"%swrap\" % prefix, None), ) @memoized_property def backend(self): raise exception.RegionNotConfigured(","function. See that method for additional behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments`","will overide the expiration time already configured on this :class:`.CacheRegion` if not None.","argument, is tested against the creation time of the retrieved value versus the","values else: self.set_multi( dict(zip(keys, values)) ) return values decorate.set = set_ decorate.invalidate =",":class:`.CacheRegion` itself should construct the invalidator given the region as an argument:: class","current_time = time.time() def value_fn(value): if value is NO_VALUE: return value elif expiration_time","creation time\" for a value. Any retrieved value whose creation time is prior","for the region. This isn't used internally but can be accessed via the","effect of deleting the given sequence of keys using the same mechanism as","mutexes[key] = mutex if expiration_time is None: expiration_time = self.expiration_time if (expiration_time is","its default value of ``False``, the decorated function should return its result as","on this :class:`.CacheRegion` if not None. To set no expiration, use the value",".proxy import ProxyBackend from ..util import compat import time import datetime from numbers","value to be cached. .. versionadded:: 0.4.1 Added ``set()`` method to decorated function.","a backend such as bsddb or dbm under Python 2.x in conjunction with","will cache the return value of the function using a key derived from","backend_values ) ] def get_or_create( self, key, creator, expiration_time=None, should_cache_fn=None): \"\"\"Return a cached","mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled =","else: self.backend = backend_cls(arguments or {}) if not expiration_time or isinstance(expiration_time, Number): self.expiration_time","function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue from .proxy import ProxyBackend from ..util","def value_fn(value): if value is NO_VALUE: return value elif expiration_time is not None","passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string argument which will be established as","expiration_time or isinstance(expiration_time, Number): self.expiration_time = expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time = int(","passed the mutex and is responsible releasing that mutex when finished. This can","normally be passed to the function should follow:: generate_something.set(3, 5, 6) The above","construct the invalidator given the region as an argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self,","based on a sequence of keys. The behavior for generation of values based","= self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload if value is","of ``myapp.tools:one|foo|3 4`` - the name ``self`` is skipped. The ``namespace`` parameter is","the value which all getters will wait for. With \"soft\" invalidation, subsequent getters","skipped. The ``namespace`` parameter is optional, and is used normally to disambiguate two","which may require key mangling before reaching the cache. .. versionadded:: 0.5.0 :param","``set()`` method to decorated function. Similar to ``set()`` is ``refresh()``. This attribute will","return fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable \\ else expiration_time return self.get_or_create(key,","or a callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This function is given a","the invalidation time check. .. versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param","key, safely) .. versionadded:: 0.5.0 \"\"\" if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key),","for a key to be a string, it is ultimately passed directly down","and region is invalidated in soft mode. \"\"\" raise NotImplementedError() def is_invalidated(self, timestamp):","the last call to :meth:`.invalidate`. :param key: Key to be retrieved. While it's","return fn(*[key_lookup[k] for k in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\ else",") @memoized_property def backend(self): raise exception.RegionNotConfigured( \"No backend is configured on this region.\")","_has_value() will return False. return value.payload, 0 else: ct = value.metadata[\"ct\"] if self.region_invalidator.is_soft_invalidated(ct):","method. If a value is present, but its creation time is older than","lock is released and a new value available. If a previous value is","replace_existing_backend=True to replace.\" % self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict(","the given keys. Returns values as a list matching the keys given. E.g.::","list matching the keys given. E.g.:: values = region.get_multi([\"one\", \"two\", \"three\"]) To convert","this time period has passed since the last generation. :param arguments: Optional. The","self.backend.set_multi(dict( (k, v) for k, v in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return","function returns the value of create_value() if the cache is invalid, however if","self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend = backend_cls(arguments or {}) if","one(self, a, b): return a + b The cache key above for ``MyClass().one(3,","= function_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key = key_generator(*arg, **kw)","self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw):","a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`. See that class","self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys)","keys = list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None,","is returned immediately without blocking. If the :meth:`.invalidate` method has been called, and","None def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated and","a non-existent key, safely) .. versionadded:: 0.5.0 \"\"\" if self.key_mangler: keys = list(map(lambda",". import backends # noqa value_version = 1 \"\"\"An integer placed in the","the region. This isn't used internally but can be accessed via the ``.name``","on the given key. If the value is not present, the method returns","to the order of the keys. The method uses the same approach as","keys->values, and the final result of calling the decorated function will also be","backend, before being optionally processed by the key_mangler function, so can be of","'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, } ) Remember that the first","idea is to prevent deadlocks. # though haven't been able to simulate one","period\" and \"cache until a certain date or time passes\". .. versionchanged:: 0.5.0","part of each cache key. :param expiration_time: if not None, will override the","for k, v in zip(keys_to_get, new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict(","return CachedValue( value, { \"ct\": time.time(), \"v\": value_version }) def set(self, key, value):","keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \"\"\"A function decorator","delete(self, key): \"\"\"Remove a value from the cache. This operation is idempotent (can","extra caching possibilities relative to the function. This is a convenience method for","= bool(hard) self._invalidated = time.time() def is_invalidated(self, timestamp): return (self._invalidated is not None","before reaching the cache. .. versionadded:: 0.5.0 :param function_key_generator: a function that will","Optional. Override default invalidation strategy with custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2","for ``MyClass().one(3, 4)`` will again produce the same cache key of ``myapp.tools:one|foo|3 4``","self.__dict__ and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \"This region is already \" \"configured with","return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self):","value is not None value = region.get_or_create(\"some key\", create_value, should_cache_fn=dont_cache_none) Above, the function","def invalidate(self, hard=True): \"\"\"Invalidate this :class:`.CacheRegion`. The default invalidation system works by setting","the cache. When the dogpile lock cannot be acquired, the method will block","self.key_mangler: key = self.key_mangler(key) def get_value(): value = self.backend.get(key) if (value is NO_VALUE","soft invalidation\") if expiration_time == -1: expiration_time = None if self.async_creation_runner: def async_creator(mutex):","of keys derived from the function itself and the arguments passed to it.","from the function itself and its arguments. The decorator internally makes use of","flag, an exception is raised if a backend is already configured. .. versionadded::","- expiration_time - .0001 return value.payload, ct def gen_value(): created_value = creator() value","expiration_time, ignore_expiration): if ignore_expiration: return lambda value: value else: if expiration_time is None:","cache, based on the given key. If the value is not present, the","to recreate the value and persist the newly generated value in the cache.","should follow:: generate_something.set(3, 5, 6) The above example is equivalent to calling ``generate_something(5,","``time.time()``) to consider all older timestamps effectively invalidated. \"\"\" raise NotImplementedError() def is_hard_invalidated(self,","fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key = key_generator(*arg, **kw) @wraps(fn) def creator():","time.time() - expiration_time - .0001 return value.payload, ct def gen_value(): raise NotImplementedError() def","value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration: return lambda value: value else: if","function_key_generator is None: function_key_generator = self.function_key_generator def decorator(fn): if to_str is compat.string_type: #","a function that will produce a list of keys. This function will supersede","directly down to the cache backend, before being optionally processed by the key_mangler","@someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key) for key in keys ] The decorated","present, but its creation time is older than the current invalidation time, the","should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\"ct\"] if expiration_time is None: expiration_time = self.expiration_time","None with Lock( self._mutex(key), gen_value, get_value, expiration_time, async_creator) as value: return value def",":meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a single function signature, one which takes","when appropriate ''' def runner(): try: value = creator() cache.set(somekey, value) finally: mutex.release()","a passthrough to :class:`.CacheRegion`. See that class for constructor arguments. \"\"\" return CacheRegion(*arg,","value unconditionally. The method also interprets the cached value in terms of the","name: Optional, a string name for the region. This isn't used internally but","present in the list are returned as the ``NO_VALUE`` token. ``NO_VALUE`` evaluates to","be asked to generate any subset of the given keys. The list of","were passed a type rather than an instance then # initialize it. if","sequence of keys derived from the function itself and the arguments passed to","function using a key derived from the function itself and its arguments. The","versionadded:: 0.3.0 :param hard: if True, cache values will all require immediate regeneration;","background thread like so:: import threading def async_creation_runner(cache, somekey, creator, mutex): ''' Used","keys to be retrieved. :param creator: function which accepts a sequence of keys","key of ``myapp.tools:one|foo|3 4`` - the name ``self`` is skipped. The ``namespace`` parameter","keys: Sequence of keys to be retrieved. :param creator: function which accepts a","method, which will call the creation function, cache the new values, and return","function should return its result as a list of values, and the final","thread like so:: import threading def async_creation_runner(cache, somekey, creator, mutex): ''' Used by","return True else: return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result","may be optionally passed as a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method as well","value versus the current time (as reported by ``time.time()``). If stale, the cached","will override the normal expiration time. May be passed as an integer or","= self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg,","Added ``refresh()`` method to decorated function. Lastly, the ``get()`` method returns either the","def decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys","or '') def generate_keys(*args): return [namespace + ':' + str(a) for a in","to generate a cache key. Given a function ``one`` inside the module ``myapp.tools``::","return value of the function using a key derived from the function itself","function should return its result as a dictionary of keys->values, and the final","would normally be passed to the function should follow:: generate_something.set(3, 5, 6) The","computation of expensive creator functions to later points in the future by way","be invoked. .. versionadded:: 0.5.1 \"\"\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict, prefix): \"\"\"Configure from","on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" expiration_time_is_callable","'y')) def my_function(a, b, **kw): return my_data() .. seealso:: :func:`.function_key_generator` - default key","structure here is passed directly to the constructor of the :class:`.CacheBackend` in use,","is configured on this region.\") @property def is_configured(self): \"\"\"Return True if the backend","attribute will invoke the decorated function and populate a new value into the","the keys. The method uses the same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to","To convert values to a dictionary, use ``zip()``:: keys = [\"one\", \"two\", \"three\"]","all incoming keys before passing to the backend. Defaults to ``None``, in which","The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside this function,","one is available. Usage of \"soft\" invalidation requires that the region or the","\"old\" value until the new one is available. Usage of \"soft\" invalidation requires","in a background thread like so:: import threading def async_creation_runner(cache, somekey, creator, mutex):","# ... # ... region = CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2","# sort the keys, the idea is to prevent deadlocks. # though haven't","time required \" \"for soft invalidation\") if expiration_time == -1: expiration_time = None","self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands a 0 here as # \"the value is","get_value(): value = self.backend.get(key) if (value is NO_VALUE or value.metadata['v'] != value_version or","mapping: return if self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v)) for k, v in","function result. Example use cases include \"cache the result until the end of","the given creation function may or may not be used to recreate the","given arguments:: values = generate_something.get(\"k1\", \"k2\", \"k3\") .. versionadded:: 0.5.3 Added ``get()`` method","a dictionary, use ``zip()``:: keys = [\"one\", \"two\", \"three\"] values = region.get_multi(keys) dictionary","k in keys] def wrap_cache_fn(value): if value is NO_VALUE: return False elif not","and timestamp < self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return (self._soft_invalidated","type rather than an instance then # initialize it. if type(proxy) == type:","require immediate regeneration; dogpile logic won't be used. If False, the creation time","in zip(gen_keys, keys)) ) def get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg):","self, key, creator, expiration_time=None, should_cache_fn=None): \"\"\"Return a cached value based on the given",".api import NO_VALUE, CachedValue from .proxy import ProxyBackend from ..util import compat import","\"\"\"Place new values in the cache under the given keys. .. versionadded:: 0.5.0","self.backend.delete(key) def delete_multi(self, keys): \"\"\"Remove multiple values from the cache. This operation is","'__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return","value, as well as returning that value:: newvalue = generate_something.refresh(5, 6) .. versionadded::","the value returned by the \"creator\", and will then return True or False,","calling the decorated function will also be a dictionary. If left at its",":return: Boolean. True if region was invalidated in soft mode. \"\"\" raise NotImplementedError()","self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner =","not a number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry =","invalidation options. With \"hard\" invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate regeneration of the","available myconfig = { \"cache.local.backend\":\"dogpile.cache.dbm\", \"cache.local.arguments.filename\":\"/path/to/dbmfile.dbm\", \"cache.memcached.backend\":\"dogpile.cache.pylibmc\", \"cache.memcached.arguments.url\":\"127.0.0.1, 10.0.0.1\", } local_region.configure_from_config(myconfig, \"cache.local.\") memcached_region.configure_from_config(myconfig,","the :meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1 \"\"\" return 'backend' in self.__dict__ def","expiration_time() if expiration_time_is_callable \\ else expiration_time if asdict: def dict_create(*keys): d_values = creator(*keys)","{ \"ct\": time.time(), \"v\": value_version }) def set(self, key, value): \"\"\"Place a new","def one(a, b): return a + b Above, calling ``one(3, 4)`` will produce","= dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k] for k in keys_to_create]) timeout","mapping[key]) for gen_key, key in zip(gen_keys, keys)) ) def get(*arg): keys = key_generator(*arg)","older than the last region invalidation time and region is invalidated in hard","the given key. If the value does not exist or is considered to","is optional, and is used normally to disambiguate two functions of the same","'distributed_lock': True, } ) Remember that the first request for a key with","the cache region unless a new value is needed:: result = generate_something(5, 6)","if self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v)) for k, v in mapping.items()) else:","should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \"\"\"A function decorator that will cache the return value of","reaching the cache. .. versionadded:: 0.5.0 :param function_key_generator: a function that will produce","not consulted outside this function, so in fact can be of any form.","when specified, will be passed to and called by dogpile.lock when there is","depends on if the *dogpile lock* can be acquired or not. If it","of keys to be generated is passed to ``creator()``, and ``creator()`` should return","raise exception.RegionNotConfigured( \"No backend is configured on this region.\") @property def is_configured(self): \"\"\"Return","the cache, based on the given key. If the value is not present,","mutexes: # sort the keys, the idea is to prevent deadlocks. # though","is released to return the new value. .. versionchanged:: 0.3.0 The value is","of the function, the module name for the function, the arguments passed, as","final result of calling the decorated function will also be a list. When","week or time period\" and \"cache until a certain date or time passes\".","not mapping: return if self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v)) for k, v","``self`` or ``cls``, making the decorator suitable (with caveats) for use with instance","has passed since the last generation. :param arguments: Optional. The structure here is","self._mutex(key), gen_value, get_value, expiration_time, async_creator) as value: return value def get_or_create_multi( self, keys,","subset of the given keys. The list of keys to be generated is","fn.__name__ + (namespace or '') def generate_keys(*args): return [namespace + ':' + str(a)","invoked. However, subsequent requests for cached-but-expired values will still return promptly. They will","ct = time.time() - expiration_time - .0001 return value.payload, ct def gen_value(): created_value","def my_function(a, b, **kw): return my_data() .. seealso:: :func:`.function_key_generator` - default key generator","mutexes = {} sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k) for k","value is not available\", e.g. # _has_value() will return False. return value.payload, 0","lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass try: if mutexes: #","self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for k, v in values_w_created.items() if should_cache_fn(v[0]) ))","a new value into the cache with the new value, as well as","each key. It will then consult the cache using the same mechanism as","fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys = arg keys = key_generator(*arg, **kw)","= self.backend.get_mutex(key) if mutex is not None: return mutex else: return self._LockWrapper() def","[self.key_mangler(k) for k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys))","= time.time() self._hard_invalidated = None def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp <","between ``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python class declaration mechanics otherwise prevent the","self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return","declared. :param expiration_time: if not None, will override the normal expiration time. May","a previous, backwards-incompatible version. \"\"\" class RegionInvalidationStrategy(object): \"\"\"Region invalidation strategy interface Implement this","\"\"\"Check timestamp to determine if it was soft invalidated. :return: Boolean. True if","or class methods. Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\"foo\") def one(self, a, b):","the creation time is older than the last call to :meth:`.invalidate`. :param key:","been called, and the retrieved value's timestamp is older than the invalidation timestamp,","specify arguments to pluck from \\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return","but isn't cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" def get_value(key):","timestamp): \"\"\"Check timestamp to determine if it was hard invalidated. :return: Boolean. True","that the ``creator()`` function may be asked to generate any subset of the","returns a sequence of new values. :param expiration_time: optional expiration time which will","creator(): return fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable \\ else expiration_time return","may be needed to disambiguate functions of the same name within the same","be acquired or not. If it can't, it means a different thread or","generate_something.set(3, 5, 6) The above example is equivalent to calling ``generate_something(5, 6)``, if","\"filename\":\"file.dbm\" } ) The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted","as a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method as well as the :meth:`.CacheRegion.cache_on_arguments` decorator","namespace: optional string argument which will be established as part of the cache","= get return decorate return decorator def make_region(*arg, **kw): \"\"\"Instantiate a new :class:`.CacheRegion`.","subsequent getters will return the \"old\" value until the new one is available.","until a certain date or time passes\". .. versionchanged:: 0.5.0 ``expiration_time`` may be","is added to provide extra caching possibilities relative to the function. This is","mangling, set to ``False``. Another typical mangler is the built-in Python function ``str``,","can be acquired or not. If it can't, it means a different thread","the cache using the same mechanism as that of :meth:`.CacheRegion.get_multi` to retrieve all","Any retrieved value whose creation time is prior to this timestamp is considered","expiration_time=None, should_cache_fn=None): \"\"\"Return a cached value based on the given key. If the","}) def set(self, key, value): \"\"\"Place a new value in the cache under","lock is released to return the new value. .. versionchanged:: 0.3.0 The value","creator, mutex): ''' Used by dogpile.core:Lock when appropriate ''' def runner(): try: value","the given keys. .. versionadded:: 0.5.0 \"\"\" if not mapping: return if self.key_mangler:","time and region is invalidated in hard mode. \"\"\" raise NotImplementedError() def is_soft_invalidated(self,","present, the method returns the token ``NO_VALUE``. ``NO_VALUE`` evaluates to False, but is","on a non-existent key, safely) \"\"\" if self.key_mangler: key = self.key_mangler(key) self.backend.delete(key) def","current values; the originally passed keys corresponding to those values which aren't generated","one anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k], self._value(v))","itself and the arguments passed to it. This method is the \"multiple key\"","E.g.:: def dont_cache_none(value): return value is not None value = region.get_or_create(\"some key\", create_value,","expiration_time == -1: expiration_time = None mutexes = {} sorted_unique_keys = sorted(set(keys)) if","and is set to ``None``. .. versionadded:: 0.4.2 added the async_creation_runner feature. \"\"\"","gen_value(): created_value = creator() value = self._value(created_value) if not should_cache_fn or \\ should_cache_fn(created_value):","self._value(created_value) if not should_cache_fn or \\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\"ct\"] if","v is not NO_VALUE) else: result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return","in conjunction with Unicode keys. :param async_creation_runner: A callable that, when specified, will","indicating if the value should actually be cached or not. If it returns","optional namespace and with the string form of each key. It will then","coerce_string_conf from .util import function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue from .proxy","wrap_cache_fn(value): if value is NO_VALUE: return False elif not should_cache_fn: return True else:","wish to have access to the :class:`.CacheRegion` itself should construct the invalidator given","with Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass","you are using a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies values, take note this","configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\"","def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is False","method is the \"multiple key\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def","the creator, and only if it returns True will that value be placed","key): return self._lock_registry.get(key) class _LockWrapper(object): \"\"\"weakref-capable wrapper for threading.Lock\"\"\" def __init__(self): self.lock =","return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp < self._soft_invalidated) The custom","the given arguments:: values = generate_something.get(\"k1\", \"k2\", \"k3\") .. versionadded:: 0.5.3 Added ``get()``","should_cache_fn) return result def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys =","that modifies values, take note this function invokes ``.set_multi()`` for newly generated values","or Unicode keys to bytestrings, which is needed when using a backend such","True, } ) Remember that the first request for a key with no","PluginLoader(\"dogpile.cache\") register_backend = _backend_loader.register from . import backends # noqa value_version = 1","dogpile.lock when there is a stale value present in the cache. It will","if True, the existing cache backend will be replaced. Without this flag, an","else value for value in ( _unexpired_value_fn(value) for value in backend_values ) ]","0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function using a decorator.","the generated values as a sequence corresponding to the order of the keys.","on keys corresponds to that of :meth:`.Region.get_or_create`, with the exception that the ``creator()``","to_str=compat.string_type, function_key_generator=None): \"\"\"A function decorator that will cache the return value of the","needed:: result = generate_something(5, 6) The function is also given an attribute ``invalidate()``,","decorated function should return its result as a dictionary of keys->values, and the","already configured on this :class:`.CacheRegion` if not None. To set no expiration, use","the function returns the value of create_value() if the cache is invalid, however","keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the decorated function is also provided with a","config_dict[\"%sbackend\" % prefix], expiration_time=config_dict.get( \"%sexpiration_time\" % prefix, None), _config_argument_dict=config_dict, _config_prefix=\"%sarguments.\" % prefix, wrap=config_dict.get(","given keys. The list of keys to be generated is passed to ``creator()``,","until the end of the day, week or time period\" and \"cache until","value decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get","have access to the :class:`.CacheRegion` itself should construct the invalidator given the region","check. .. versionadded:: 0.5.0 \"\"\" if not keys: return [] if self.key_mangler: keys","retrieved value's timestamp is older than the invalidation timestamp, the value is unconditionally","6) .. versionadded:: 0.5.0 Added ``refresh()`` method to decorated function. Lastly, the ``get()``","should actually be cached or not. If it returns False, the value is","= None self._invalidated = None def invalidate(self, hard=True): self._is_hard_invalidated = bool(hard) self._invalidated =",":meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside this function, so in fact can be of","is being declared. :param expiration_time: if not None, will override the normal expiration","namespace: optional string argument which will be established as part of each cache","\\ else expiration_time if asdict: def dict_create(*keys): d_values = creator(*keys) return [ d_values.get(key_lookup[k],","class RegionInvalidationStrategy(object): \"\"\"Region invalidation strategy interface Implement this interface and pass implementation instance","gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in zip(gen_keys, keys)) )","against the cache. When the dogpile lock cannot be acquired, the method will","for configuring a region from a config file. :param function_key_generator: Optional. A function","= NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator:","regardless of configured expiration times or whether or not :meth:`.invalidate` was called. ..","it returns False, the value is still returned, but isn't cached. .. versionadded::","when using the :meth:`.CacheRegion.cache_on_arguments` method. The structure of this function should be two","as an optional \"namespace\" parameter in order to generate a cache key. Given","to decorated function. Lastly, the ``get()`` method returns either the value cached for","= set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get decorate.original =","that also uses keyword arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but","be called normally. The decorator will produce a list of cache keys using","as those associated with classes - note that the decorator itself can't see","to :func:`.function_key_generator`. :param namespace: optional string argument which will be established as part","self._is_hard_invalidated = bool(hard) self._invalidated = time.time() def is_invalidated(self, timestamp): return (self._invalidated is not","time, rather than returning the value unconditionally. The method also interprets the cached","\"This region is already \" \"configured with backend: %s. \" \"Specify replace_existing_backend=True to","which accepts a sequence of keys and returns a sequence of new values.","\\ else expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key =","(orig_to_mangled[k], self._value(v)) for k, v in zip(keys_to_get, new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created)","in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \"\"\"Remove a value from the cache. This","refresh(*arg, **kw): key = key_generator(*arg, **kw) value = fn(*arg, **kw) self.set(key, value) return","invalidate decorate.refresh = refresh decorate.get = get decorate.original = fn return decorate return","with a single function signature, one which takes a simple list of keys","using the :meth:`.CacheRegion.cache_on_arguments` method. The structure of this function should be two levels:","to that of :meth:`.Region.get_or_create`, with the exception that the ``creator()`` function may be","a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of the function","may or may not be used to recreate the value and persist the","async_creation_runner callable implements. By default the async_creation_runner is disabled and is set to","since the last generation. :param arguments: Optional. The structure here is passed directly",".. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator","each of which will be applied in a chain to ultimately wrap the","of the :meth:`.CacheRegion.get_or_create_multi` method to access the cache and conditionally call the function.","is a passthrough to :class:`.CacheRegion`. See that class for constructor arguments. \"\"\" return","def get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values","system like Celery. For a specific example using async_creation_runner, new values can be","expiration_time = self.expiration_time current_time = time.time() def value_fn(value): if value is NO_VALUE: return","return list of keys. For example:: def my_multi_key_generator(namespace, fn, **kw): namespace = fn.__name__","key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys = list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key])","interface and pass implementation instance to :meth:`.CacheRegion.configure` to override default region invalidation. Example::","of the current \"invalidation\" time as set by the :meth:`.invalidate` method. If a","key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None, arguments=None,","timestamp < self._soft_invalidated) The custom implementation is injected into a :class:`.CacheRegion` at configure","and is resolved by loading the class from the ``dogpile.cache`` entrypoint. :param expiration_time:","If a value is present, but its creation time is older than the","\" \"configured with backend: %s. \" \"Specify replace_existing_backend=True to replace.\" % self.backend) backend_cls","timestamp): return (self._hard_invalidated and timestamp < self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self,","for a key with no associated value will always block; async_creator will not","0.3.0 \"\"\" if self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key) value = self._unexpired_value_fn(","given keys. Returns values as a list matching the keys given. E.g.:: values","but isn't cached. E.g.:: def dont_cache_none(value): return value is not None value =","the method is given a non-None expiration time. .. versionadded:: 0.3.0 :param hard:","if \"backend\" in self.__dict__ and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \"This region is already","Python class declaration mechanics otherwise prevent the decorator from having awareness of the","which here accepts a mapping of keys and values to set in the","each cache key. :param expiration_time: if not None, will override the normal expiration","value def get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \"\"\"Return a sequence of cached","keys: return [] if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) backend_values =","sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys] else: mangled_keys =","value should actually be cached or not. If it returns False, the value","new argument list, and the decorated function is then called with that subset","function_multi_key_generator: a function that will produce a list of keys. This function will","region unless a new value is needed:: result = generate_something(5, 6) The function",".. versionadded:: 0.5.0 :param function_multi_key_generator: a function that will produce a list of","A correct implementation of ``.set_multi()`` will not modify values in-place on the submitted","method, which has the effect of deleting the given sequence of keys using","expiration time. .. versionadded:: 0.3.0 :param hard: if True, cache values will all","the cache and conditionally call the function. See that method for additional behavioral","key = key_generator(*arg, **kw) self.set(key, value) def get(*arg, **kw): key = key_generator(*arg, **kw)","be a dictionary. If left at its default value of ``False``, the decorated","to ``set()`` is ``refresh()``. This attribute will invoke the decorated function and populate","available, until the lock is released and a new value available. If a","or time period\" and \"cache until a certain date or time passes\". ..","or process is already running a creation function for this key against the","**kw): key = key_generator(*arg, **kw) return self.get(key) def refresh(*arg, **kw): key = key_generator(*arg,","and conditionally call the function. See that method for additional behavioral details. E.g.::","override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated = None self._hard_invalidated","to replace.\" % self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict,","Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`. See that class for constructor arguments.","when config is available myconfig = { \"cache.local.backend\":\"dogpile.cache.dbm\", \"cache.local.arguments.filename\":\"/path/to/dbmfile.dbm\", \"cache.memcached.backend\":\"dogpile.cache.pylibmc\", \"cache.memcached.arguments.url\":\"127.0.0.1, 10.0.0.1\", }","= compat.callable(expiration_time) if function_key_generator is None: function_key_generator = self.function_key_generator def decorator(fn): if to_str","multiple key/value version \"\"\" orig_key = key if self.key_mangler: key = self.key_mangler(key) def","\"ct\": time.time(), \"v\": value_version }) def set(self, key, value): \"\"\"Place a new value","without calling the decorated function. The value to be cached is passed as","value = self._value(created_value) if not should_cache_fn or \\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload,","into a SHA1 hash, so that the string length is fixed. To disable","@region.cache_on_arguments(namespace=\"foo\") def one(a, b): return a + b Above, calling ``one(3, 4)`` will","pass to the function itself to represent a particular value:: generate_something.invalidate(5, 6) Another","the function itself and the arguments passed to it. This method is the","and timestamp < self._soft_invalidated) or (self._hard_invalidated and timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return","as bsddb or dbm under Python 2.x in conjunction with Unicode keys. :param","older than the invalidation timestamp, the value is unconditionally prevented from being returned.","dictionary returned by the decorated function is missing keys, those keys will not","**kw) self.delete(key) def set_(value, *arg, **kw): key = key_generator(*arg, **kw) self.set(key, value) def","which all getters will wait for. With \"soft\" invalidation, subsequent getters will return","``ignore_expiration=True`` bypasses the expiration time check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks the","if the function were to produce the value ``3`` as the value to","This may be needed to disambiguate functions of the same name within the","arguments to pluck from \\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return \":\".join(","keys, expiration_time=None, ignore_expiration=False): \"\"\"Return multiple values from the cache, based on the given","local to this instance of :class:`.CacheRegion`. Once set, the invalidation time is honored","is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is False def","is a list:: result = generate_something(\"key1\", \"key2\", \"key3\") The decorator internally makes use","function is given a value as returned by the creator, and only if","the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" expiration_time_is_callable =","which will return values based on the given arguments:: values = generate_something.get(\"k1\", \"k2\",","cache:: generate_something.set({\"k1\": \"value1\", \"k2\": \"value2\", \"k3\": \"value3\"}) ...an ``invalidate()`` method, which has the","list of keys to be generated is passed to ``creator()``, and ``creator()`` should","= make_region( function_key_generator = my_key_generator ).configure( \"dogpile.cache.dbm\", expiration_time=300, arguments={ \"filename\":\"file.dbm\" } ) The","**kw): return \":\".join( [kw[k] for k in namespace] + [str(x) for x in","backend. Defaults to ``None``, in which case the key mangling function recommended by","default, the configured expiration time of the :class:`.CacheRegion`, or alternatively the expiration time","def creator(): return fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable \\ else expiration_time","return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\"ct\"]): return NO_VALUE else: return value return value_fn def","a list. When ``asdict==True`` if the dictionary returned by the decorated function is","a sequence corresponding to the order of the keys. The method uses the","Where the decorator might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw):","be called multiple times, or on a non-existent key, safely) \"\"\" if self.key_mangler:","return generate_key Where the decorator might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a,","Passing the flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionadded:: 0.5.0 \"\"\"","key = key_generator(*arg, **kw) return self.get(key) def refresh(*arg, **kw): key = key_generator(*arg, **kw)","self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping): \"\"\"Place new values in the cache under","return values decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get =","type recognized by the backend or by the key_mangler function, if present. :param","of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \"\"\" if \"backend\" in self.__dict__ and not replace_existing_backend:","the flag ``ignore_expiration=True`` bypasses the invalidation time check. .. versionadded:: 0.3.0 Support for","the originally passed keys corresponding to those values which aren't generated or need","is then called with that subset of arguments. The returned result is a",":meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable, will","s in arg) return generate_key region = make_region( function_key_generator = my_key_generator ).configure( \"dogpile.cache.dbm\",","to the dogpile system. May be passed as an integer number of seconds,","a specific example using async_creation_runner, new values can be created in a background","# though haven't been able to simulate one anyway. keys_to_get = sorted(mutexes) new_values","string length is fixed. To disable all key mangling, set to ``False``. Another","is the built-in Python function ``str``, which can be used to convert non-string","an initial argument of ``self`` or ``cls``, making the decorator suitable (with caveats)","b The cache key above for ``MyClass().one(3, 4)`` will again produce the same","somemethod(self, x, y): \"\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y): \"\" Above,","a + b The cache key above for ``MyClass().one(3, 4)`` will again produce","is set to ``None``. .. versionadded:: 0.4.2 added the async_creation_runner feature. \"\"\" def","__init__(self): self.lock = threading.Lock() def acquire(self, wait=True): return self.lock.acquire(wait) def release(self): self.lock.release() def","is_soft_invalidated(self, timestamp): \"\"\"Check timestamp to determine if it was soft invalidated. :return: Boolean.","lock cannot be acquired, the method will block if no previous value is","acquired or not. If it can't, it means a different thread or process","invalidated in soft mode. :return: Boolean. True if region was invalidated in soft","should_cache_fn: return True else: return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn)","was called. .. versionadded:: 0.3.0 \"\"\" if self.key_mangler: key = self.key_mangler(key) value =","honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports both \"hard\"","\"v\": value_version }) def set(self, key, value): \"\"\"Place a new value in the",") def get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg)","value. Pass to ``invalidate()`` the same arguments you'd pass to the function itself","= dict((k, self._value(v)) for k, v in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \"\"\"Remove","the dictionary returned by the decorated function is missing keys, those keys will","a valid ProxyBackend\" % type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self, key): return self._lock_registry.get(key)","time is older than the current invalidation time, the ``NO_VALUE`` token is returned.","_config_prefix=\"%sarguments.\" % prefix, wrap=config_dict.get( \"%swrap\" % prefix, None), ) @memoized_property def backend(self): raise","\"invalidation\" time as set by the :meth:`.invalidate` method. If a value is present,","Boolean. True if region was invalidated in hard mode. \"\"\" raise NotImplementedError() class",".. versionadded:: 0.3.0 \"\"\" if self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key) value","to calling ``generate_something(5, 6)``, if the function were to produce the value ``3``","the decorator itself can't see the parent class on a function as the","using a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of the","the function accepts non-ascii unicode arguments on Python 2.x, the ``unicode()`` builtin can","key. If the value does not exist or is considered to be expired","*dynamic* expiration time for the cached function result. Example use cases include \"cache","region as an argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self, region): self.region = region #","default invalidation system works by setting a current timestamp (using ``time.time()``) to consider","See that method for additional behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x, y): return","than the last region invalidation time and region is invalidated in soft mode.","\"backend\" in self.__dict__ and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \"This region is already \"","a string name for the region. This isn't used internally but can be","a backend is already configured. .. versionadded:: 0.5.7 :param region_invalidator: Optional. Override default","be stale. It does not affect the data in the cache in any","expiration time value which will supersede that configured on the :class:`.CacheRegion` itself. ..","created_value = creator() value = self._value(created_value) if not should_cache_fn or \\ should_cache_fn(created_value): self.backend.set(key,","v) for k, v in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for","from the cache. This operation is idempotent (can be called multiple times, or","requires that the region or the method is given a non-None expiration time.","declaration mechanics otherwise prevent the decorator from having awareness of the ``MyClass`` and","``get()`` method to decorated function. Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning","\"cache key\". This function will supersede the one configured on the :class:`.CacheRegion` itself.",":meth:`.CacheRegion.cache_on_arguments`, combining the name of the function with the optional namespace and with","Example use cases include \"cache the result until the end of the day,","a new value. :param expiration_time: optional expiration time which will overide the expiration","time.time() self._hard_invalidated = None def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated)","\"_\" + fname + \"_\".join(str(s) for s in arg) return generate_key region =","for the function, the arguments passed, as well as an optional \"namespace\" parameter","decorate.get = get decorate.original = fn return decorate return decorator def cache_multi_on_arguments( self,","backend. If you are using a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies values, take","of the function with the optional namespace and with the string form of","self._invalidated = time.time() def is_invalidated(self, timestamp): return (self._invalidated is not None and timestamp","by the key_mangler function, if present. :param expiration_time: Optional expiration time value which","is returned from the cache if present, regardless of configured expiration times or",".. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function using","will ignore an initial argument of ``self`` or ``cls``, making the decorator suitable","method) will call upon the value creation function after this time period has","method to decorated function. Similar to ``set()`` is ``refresh()``. This attribute will invoke","calling ``one(3, 4)`` will produce a cache key as follows:: myapp.tools:one|foo|3 4 The","generation of values based on keys corresponds to that of :meth:`.Region.get_or_create`, with the","returning that value:: newvalue = generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added ``refresh()`` method","flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks","decorator internally makes use of the :meth:`.CacheRegion.get_or_create` method to access the cache and","creator, timeout, should_cache_fn) return result def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def set_(mapping):","the cached value is ignored and the ``NO_VALUE`` token is returned. Passing the","the :meth:`.invalidate` method has been called, and the retrieved value's timestamp is older","generate_keys(*args): return [namespace + ':' + str(a) for a in args] return generate_keys","so:: import threading def async_creation_runner(cache, somekey, creator, mutex): ''' Used by dogpile.core:Lock when","same mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\"k1\", \"k2\", \"k3\") ...a ``refresh()`` method, which","returned. :param backend: Required. This is the name of the :class:`.CacheBackend` to use,","on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \"\"\" expiration_time_is_callable",":func:`.make_region` and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`. :param namespace: optional string argument which","from .. import Lock, NeedRegenerationException from ..util import NameRegistry from . import exception","return [namespace + ':' + str(a) for a in args] return generate_keys :param",".0001 return value.payload, ct def gen_value(): raise NotImplementedError() def async_creator(key, mutex): mutexes[key] =","to have access to the :class:`.CacheRegion` itself should construct the invalidator given the","None self._invalidated = None def invalidate(self, hard=True): self._is_hard_invalidated = bool(hard) self._invalidated = time.time()","implements. By default the async_creation_runner is disabled and is set to ``None``. ..","the string form of each key. It will then consult the cache using","the value does not exist or is considered to be expired based on","constructor of the :class:`.CacheBackend` in use, though is typically a dictionary. :param wrap:","int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time is not a number or timedelta.') if","this :class:`.CacheRegion`. The default invalidation system works by setting a current timestamp (using","already configured. .. versionadded:: 0.5.7 :param region_invalidator: Optional. Override default invalidation strategy with",":param ignore_expiration: if ``True``, the value is returned from the cache if present,","k, v in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \"\"\"Remove a value from the","NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated = None self._invalidated = None def invalidate(self,","based on the given key. If the value is not present, the method","its creation time is older than the current invalidation time, the ``NO_VALUE`` token","for :meth:`.CacheRegion.set` which will store a given value directly without calling the decorated","This attribute will invoke the decorated function and populate a new value into","self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \"\"\"A function decorator that will cache","those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string argument which will be established","\":\".join( [kw[k] for k in namespace] + [str(x) for x in arg] )","value, or will wait until the lock is released to return the new","The decorated function can then be called normally, where data will be pulled",":meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable, will be called on each function","function, so in fact can be of any form. For example, it can","data in the cache in any way, and is also local to this","use the name of the function, the module name for the function, the","If it can't, it means a different thread or process is already running","sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys] else:","will not be cached. :param to_str: callable, will be called on each function","\"\"\"Construct a new :class:`.CacheRegion`.\"\"\" self.name = name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator","now checks the value's creation time against the expiration time, rather than returning","in soft mode. \"\"\" raise NotImplementedError() def is_invalidated(self, timestamp): \"\"\"Check timestamp to determine","values based on keys corresponds to that of :meth:`.Region.get_or_create`, with the exception that","decorated function and populate a new value into the cache with the new","string argument which will be established as part of each cache key. :param","of keys. This function will supersede the one configured on the :class:`.CacheRegion` itself.","to the function itself to represent a particular value:: generate_something.invalidate(5, 6) Another attribute","the module name for the function, the arguments passed, as well as an","to pluck from \\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return \":\".join( [kw[k]","as a sequence corresponding to the order of the keys. The method uses","expiration time passed to the dogpile system. May be passed as an integer","without blocking. If the :meth:`.invalidate` method has been called, and the retrieved value's","then # initialize it. if type(proxy) == type: proxy = proxy() if not","if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\"ct\"])): raise NeedRegenerationException()","``NO_VALUE`` evaluates to False, but is separate from ``None`` to distinguish between a","default the async_creation_runner is disabled and is set to ``None``. .. versionadded:: 0.4.2","can be called normally. The decorator will produce a list of cache keys","value.payload, value.metadata[\"ct\"] if expiration_time is None: expiration_time = self.expiration_time if (expiration_time is None","like so:: import threading def async_creation_runner(cache, somekey, creator, mutex): ''' Used by dogpile.core:Lock","for k in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\ else expiration_time if","if a backend is already configured. .. versionadded:: 0.5.7 :param region_invalidator: Optional. Override","will return the \"old\" value until the new one is available. Usage of","cached for the given key, or the token ``NO_VALUE`` if no such key","key mangling before reaching the cache. .. versionadded:: 0.5.0 :param function_multi_key_generator: a function","is not NO_VALUE) else: result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result","a different thread or process is already running a creation function for this","def generate_something(*keys): return [ somedatabase.query(key) for key in keys ] The decorated function","value.metadata[\"ct\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time - .0001 return value.payload, ct","values which aren't generated or need regeneration will be assembled into a new","NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands a 0","pulled from the cache region unless a new value is needed:: result =","fn(*arg, **kw) self.set(key, value) return value decorate.set = set_ decorate.invalidate = invalidate decorate.refresh","used as the ``expiration_time``. This callable will be called whenever the decorated function","dict. :param keys: Sequence of keys to be retrieved. :param creator: function which","given a value as returned by the creator, and only if it returns","and pass implementation instance to :meth:`.CacheRegion.configure` to override default region invalidation. Example:: class","self.key_mangler: mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled","given creation function may or may not be used to recreate the value","and populate a new value into the cache with the new value, as",".. versionchanged:: 0.3.0 The value is unconditionally regenerated if the creation time is","= region.get_or_create(\"some key\", create_value, should_cache_fn=dont_cache_none) Above, the function returns the value of create_value()","is prior to this timestamp is considered to be stale. It does not","be cached. .. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any","an instance method. The function key generation can be entirely replaced on a","be cached is passed as the first argument, and the arguments which would","``None``. By default, the configured expiration time of the :class:`.CacheRegion`, or alternatively the","the region was invalidated in soft mode. :return: Boolean. True if region was","async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None,","else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for","ignore_expiration)(value) return value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration: return lambda value: value","delete_multi(self, keys): \"\"\"Remove multiple values from the cache. This operation is idempotent (can","instance to :meth:`.CacheRegion.configure` to override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self):","\\ current_time - value.metadata[\"ct\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\"ct\"]): return NO_VALUE","somedatabase.query(x, y) The decorated function can then be called normally, where data will","passed to the dogpile system. May be passed as an integer number of","will be established as part of each cache key. :param expiration_time: if not","if hard: self._soft_invalidated = None self._hard_invalidated = time.time() else: self._soft_invalidated = time.time() self._hard_invalidated","to specify arguments to pluck from \\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw):","to the function should follow:: generate_something.set(3, 5, 6) The above example is equivalent","cache is invalid, however if the return value is None, it won't be","self, orig_key, creator, mutex) else: async_creator = None with Lock( self._mutex(key), gen_value, get_value,","generate_something.get(5, 6) .. versionadded:: 0.5.3 Added ``get()`` method to decorated function. The default","return decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \"\"\"A function","already \" \"configured with backend: %s. \" \"Specify replace_existing_backend=True to replace.\" % self.backend)","generator :func:`.kwarg_function_key_generator` - optional gen that also uses keyword arguments :param function_multi_key_generator: Optional.","value = region.get_or_create(\"some key\", create_value, should_cache_fn=dont_cache_none) Above, the function returns the value of","generate any subset of the given keys. The list of keys to be","self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration: return lambda","Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key) for key in keys ] The","call the function. See that method for additional behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments`","values decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get","returned. Passing the flag ``ignore_expiration=True`` bypasses the invalidation time check. .. versionadded:: 0.3.0","from ..util import PluginLoader, memoized_property, coerce_string_conf from .util import function_key_generator, function_multi_key_generator from .api","function that generates the key based on the given arguments. Such as:: def","generated values as a sequence corresponding to the order of the keys. The","decorated function is then called with that subset of arguments. The returned result","when finished. This can be used to defer the computation of expensive creator","string argument which will be established as part of the cache key. This","``None``. .. versionadded:: 0.4.2 added the async_creation_runner feature. \"\"\" def __init__( self, name=None,","SHA1 hash, so that the string length is fixed. To disable all key",")) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k in keys] finally: for mutex in mutexes.values():","configured on this region.\") @property def is_configured(self): \"\"\"Return True if the backend has","operation is idempotent (can be called multiple times, or on a non-existent key,","as a list matching the keys given. E.g.:: values = region.get_multi([\"one\", \"two\", \"three\"])","configuration dictionary and a prefix. Example:: local_region = make_region() memcached_region = make_region() #","value.payload, 0 else: ct = value.metadata[\"ct\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time","token ``NO_VALUE``. ``NO_VALUE`` evaluates to False, but is separate from ``None`` to distinguish","\"three\"]) To convert values to a dictionary, use ``zip()``:: keys = [\"one\", \"two\",","used normally to disambiguate two functions of the same name within the same","conditionally call the function. See that method for additional behavioral details. E.g.:: @someregion.cache_on_arguments()","the region was invalidated in hard mode. :return: Boolean. True if region was","-1: expiration_time = None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self, orig_key, creator,","thread.start() region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True,","keys, the idea is to prevent deadlocks. # though haven't been able to","is not None and timestamp < self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is True","module, as can occur when decorating instance or class methods as below:: class","self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False,","region.\") @property def is_configured(self): \"\"\"Return True if the backend has been configured via","wrap=None, replace_existing_backend=False, region_invalidator=None ): \"\"\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned. :param","soft mode. :return: Boolean. True if region was invalidated in soft mode. \"\"\"","implementation is injected into a :class:`.CacheRegion` at configure time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter::","callable will be called whenever the decorated function itself is called, in caching","method to access the cache and conditionally call the function. See that method","argument, and the arguments which would normally be passed to the function should","of :class:`.CacheRegion`. Once set, the invalidation time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi`","= function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys = arg keys","% type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self, key): return self._lock_registry.get(key) class _LockWrapper(object): \"\"\"weakref-capable","the arguments passed, as well as an optional \"namespace\" parameter in order to",":meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\"k1\", \"k2\", \"k3\") ...a ``refresh()`` method, which will call the creation function,","invalidation time and region is invalidated in hard mode. \"\"\" raise NotImplementedError() def",".. versionadded:: 0.5.0 Added ``refresh()`` method to decorated function. Lastly, the ``get()`` method","given a non-None expiration time. .. versionadded:: 0.3.0 :param hard: if True, cache","which takes a simple list of keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the decorated","a callable, taking no arguments, that returns a value to be used as","\"k3\") ...and a ``get()`` method, which will return values based on the given","None, will override the normal expiration time. May be passed as an integer","replaced. Without this flag, an exception is raised if a backend is already","returned result is a list:: result = generate_something(\"key1\", \"key2\", \"key3\") The decorator internally","values from the cache. This operation is idempotent (can be called multiple times,","region was invalidated in hard mode. \"\"\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self):","the expiration time check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks the value's creation","of any type recognized by the backend or by the key_mangler function, if","value, { \"ct\": time.time(), \"v\": value_version }) def set(self, key, value): \"\"\"Place a","attached backend. ''' # if we were passed a type rather than an","same source file, such as those associated with classes - note that the","invalidation of the value. Pass to ``invalidate()`` the same arguments you'd pass to",".. versionchanged:: 0.5.0 ``expiration_time`` may be passed as a callable to :meth:`.CacheRegion.cache_on_arguments`. :param","which aren't present in the list are returned as the ``NO_VALUE`` token. ``NO_VALUE``","generate_something(\"key1\", \"key2\", \"key3\") The decorator internally makes use of the :meth:`.CacheRegion.get_or_create_multi` method to","builtin can be substituted, but note this will produce unicode cache keys which","typical mangler is the SHA1 mangler found at :func:`.sha1_mangle_key` which coerces keys into","will return False. return value.payload, 0 else: ct = value.metadata[\"ct\"] if self.region_invalidator.is_soft_invalidated(ct): ct","based on the given key. If the value does not exist or is","def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \"\"\"Construct a new :class:`.CacheRegion`.\"\"\"","values.get(key, NO_VALUE) if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])):","called, in caching or retrieving. Thus, this can be used to determine a","class _LockWrapper(object): \"\"\"weakref-capable wrapper for threading.Lock\"\"\" def __init__(self): self.lock = threading.Lock() def acquire(self,","the future by way of, for example, a background thread, a long-running queue,","= set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get return decorate","key. It will then consult the cache using the same mechanism as that","interface Implement this interface and pass implementation instance to :meth:`.CacheRegion.configure` to override default","if expiration_time is None: expiration_time = self.expiration_time current_time = time.time() def value_fn(value): if","the calling function. A correct implementation of ``.set_multi()`` will not modify values in-place","a value to be used as the ``expiration_time``. This callable will be called","dogpile.core understands a 0 here as # \"the value is not available\", e.g.","local_region = make_region() memcached_region = make_region() # regions are ready to use for","NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\"ct\"]): return NO_VALUE else: return value return value_fn def get_multi(self,","elif self.region_invalidator.is_invalidated( value.metadata[\"ct\"]): return NO_VALUE else: return value return value_fn def get_multi(self, keys,","function invokes ``.set_multi()`` for newly generated values using the same values it returns","new value. .. versionchanged:: 0.3.0 The value is unconditionally regenerated if the creation","k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values =","should_cache_fn or \\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\"ct\"] if expiration_time is None:","which will receive the value returned by the \"creator\", and will then return","def async_creator(key, mutex): mutexes[key] = mutex if expiration_time is None: expiration_time = self.expiration_time","sorted(mutexes) new_values = creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k], self._value(v)) for k, v in","key_generator(*arg, **kw) self.set(key, value) def get(*arg, **kw): key = key_generator(*arg, **kw) return self.get(key)","getters will return the \"old\" value until the new one is available. Usage","prefix, wrap=config_dict.get( \"%swrap\" % prefix, None), ) @memoized_property def backend(self): raise exception.RegionNotConfigured( \"No","self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key) value = self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return","expiration_time is not None and \\ current_time - value.metadata[\"ct\"] > expiration_time: return NO_VALUE","orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in orig_to_mangled.items():","is_configured(self): \"\"\"Return True if the backend has been configured via the :meth:`.CacheRegion.configure` method","generate_something.refresh(\"k1\", \"k2\", \"k3\") ...and a ``get()`` method, which will return values based on","5, 6) The above example is equivalent to calling ``generate_something(5, 6)``, if the","same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string argument which","called by dogpile.lock when there is a stale value present in the cache.","0.5.0 ``expiration_time`` may be optionally passed as a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method","(self._hard_invalidated and timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return","2.x in conjunction with Unicode keys. :param async_creation_runner: A callable that, when specified,","value's timestamp is older than the invalidation timestamp, the value is unconditionally prevented","\"\"\"Indicate the region was invalidated in hard mode. :return: Boolean. True if region","all older timestamps effectively invalidated. \"\"\" raise NotImplementedError() def is_hard_invalidated(self, timestamp): \"\"\"Check timestamp","the SHA1 mangler found at :func:`.sha1_mangle_key` which coerces keys into a SHA1 hash,","= None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self, orig_key, creator, mutex) else:","the decorator before it becomes an instance method. The function key generation can","passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param","is ignored and the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses","``str``, which can be used to convert non-string or Unicode keys to bytestrings,","function should follow:: generate_something.set(3, 5, 6) The above example is equivalent to calling","return [ somedatabase.query(key) for key in keys ] The decorated function can be","is None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str)","be substituted, but note this will produce unicode cache keys which may require","import with_statement from .. import Lock, NeedRegenerationException from ..util import NameRegistry from .","under Python 2.x in conjunction with Unicode keys. :param async_creation_runner: A callable that,","function is used depends on if the *dogpile lock* can be acquired or","key_mangler function, if present. :param expiration_time: Optional expiration time value which will supersede","``mapping`` dict. :param keys: Sequence of keys to be retrieved. :param creator: function","self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for wrapper in","be passed to the function should follow:: generate_something.set(3, 5, 6) The above example","creator functions to later points in the future by way of, for example,","not None, will override the normal expiration time. May be passed as an","= expiration_time() if expiration_time_is_callable \\ else expiration_time if asdict: def dict_create(*keys): d_values =","and is used normally to disambiguate two functions of the same name within","issubclass(type(proxy), ProxyBackend): raise TypeError(\"Type %s is not a valid ProxyBackend\" % type(proxy)) self.backend","False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \"\"\"A front end","non-string or Unicode keys to bytestrings, which is needed when using a backend","default key generator :func:`.kwarg_function_key_generator` - optional gen that also uses keyword arguments :param","in the cache. :param asdict: if ``True``, the decorated function should return its","``time.time()``). If stale, the cached value is ignored and the ``NO_VALUE`` token is",":meth:`.CacheRegion.get` now checks the value's creation time against the expiration time, rather than","versionchanged:: 0.5.0 ``expiration_time`` may be passed as a callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn:","gen_value, get_value, expiration_time, async_creator) as value: return value def get_or_create_multi( self, keys, creator,","def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return \":\".join( [kw[k] for k in namespace]","in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k in keys] finally:",":paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that wish to","passed as a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method as well as the :meth:`.CacheRegion.cache_on_arguments`","end of the day, week or time period\" and \"cache until a certain","to those values which aren't generated or need regeneration will be assembled into","``set()`` method, which here accepts a mapping of keys and values to set","values = generate_something.refresh(\"k1\", \"k2\", \"k3\") ...and a ``get()`` method, which will return values","used to specify arguments to pluck from \\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg,","and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated()","keyword arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but it's used in","current timestamp (using ``time.time()``) to consider all older timestamps effectively invalidated. \"\"\" raise",":meth:`.CacheRegion.get_or_create` will force an immediate regeneration of the value which all getters will","\"cache until a certain date or time passes\". .. versionchanged:: 0.5.0 ``expiration_time`` may","passed as a tuple, used to specify arguments to pluck from \\**kw:: def","and ``MyOtherClass`` names, as the function is received by the decorator before it","parameter in order to generate a cache key. Given a function ``one`` inside","using the ``function_key_generator`` argument present on :func:`.make_region` and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`.",".. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \"\"\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator","flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionadded:: 0.5.0 \"\"\" if not","= creator() value = self._value(created_value) if not should_cache_fn or \\ should_cache_fn(created_value): self.backend.set(key, value)",":class:`.CacheRegion` propagated call. The default invalidation system works by setting a current timestamp","for k in keys] def wrap_cache_fn(value): if value is NO_VALUE: return False elif","as a callable, taking no arguments, that returns a value to be used","to ``invalidate()`` the same arguments you'd pass to the function itself to represent","the creation time of the retrieved value versus the current time (as reported","fn): def generate_key(*arg, **kw): return \":\".join( [kw[k] for k in namespace] + [str(x)","for k in keys] finally: for mutex in mutexes.values(): mutex.release() def _value(self, value):","\"%swrap\" % prefix, None), ) @memoized_property def backend(self): raise exception.RegionNotConfigured( \"No backend is","time.time() else: self._soft_invalidated = time.time() self._hard_invalidated = None def is_invalidated(self, timestamp): return ((self._soft_invalidated","invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate regeneration of the value which all getters","timestamp): \"\"\"Check timestamp to determine if it was invalidated. :return: Boolean. True if","Unicode keys. :param async_creation_runner: A callable that, when specified, will be passed to","is also local to this instance of :class:`.CacheRegion`. Once set, the invalidation time","decorate.original = fn return decorate return decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None,","time is older than the last call to :meth:`.invalidate`. :param key: Key to","the same cache key of ``myapp.tools:one|foo|3 4`` - the name ``self`` is skipped.","the lock is released and a new value available. If a previous value","import wraps import threading _backend_loader = PluginLoader(\"dogpile.cache\") register_backend = _backend_loader.register from . import","self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper)","received by the decorator before it becomes an instance method. The function key","returned by the decorated function is missing keys, those keys will not be",") return values decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get","function which will receive each value returned by the \"creator\", and will then","function, if present. :param expiration_time: Optional expiration time value which will supersede that","be passed the mutex and is responsible releasing that mutex when finished. This","cache. It will be passed the mutex and is responsible releasing that mutex","cache backend, before being optionally processed by the key_mangler function, so can be","- applies :meth:`.get_or_create` to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value","= dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in orig_to_mangled.items(): with","get(self, key, expiration_time=None, ignore_expiration=False): \"\"\"Return a value from the cache, based on the","values in the cache under the given keys. .. versionadded:: 0.5.0 \"\"\" if","else: return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result = dict(","will produce unicode cache keys which may require key mangling before reaching the","def was_hard_invalidated(self): return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp)","from .api import NO_VALUE, CachedValue from .proxy import ProxyBackend from ..util import compat","result of calling the decorated function will also be a dictionary. If left","region is invalidated in hard mode. \"\"\" raise NotImplementedError() def is_soft_invalidated(self, timestamp): \"\"\"Check","whatever asynchronous means the provided async_creation_runner callable implements. By default the async_creation_runner is","value for value in ( _unexpired_value_fn(value) for value in backend_values ) ] def","self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \"\"\"A function decorator that will cache the","as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \"\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC')","\"\"\"Remove multiple values from the cache. This operation is idempotent (can be called","result until the end of the day, week or time period\" and \"cache","The default invalidation system works by setting a current timestamp (using ``time.time()``) to","dogpile lock cannot be acquired, the method will block if no previous value","ignored and the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses the","result = generate_something(5, 6) The function is also given an attribute ``invalidate()``, which","function using a sequence of keys derived from the function itself and the","of each cache key. :param expiration_time: if not None, will override the normal","zip(cache_keys, result) if v is not NO_VALUE) else: result = self.get_or_create_multi( keys, creator,","the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that wish","to access the cache and conditionally call the function. See that method for","for use with instance or class methods. Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\"foo\")","use of the :meth:`.CacheRegion.get_or_create_multi` method to access the cache and conditionally call the","sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys)))","a :class:`.CacheRegion` at configure time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region","note: **not** the :meth:`.CacheRegion.get` method) will call upon the value creation function after","To disable all key mangling, set to ``False``. Another typical mangler is the","number of seconds, or as a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time`` may","\"k2\", \"k3\") ...and a ``get()`` method, which will return values based on the",":meth:`.CacheRegion.get_multi` to retrieve all current values; the originally passed keys corresponding to those","last region invalidation time and region is invalidated in hard mode. \"\"\" raise","the class from the ``dogpile.cache`` entrypoint. :param expiration_time: Optional. The expiration time passed","proxy): ''' Takes a ProxyBackend instance or class and wraps the attached backend.","@memoized_property def backend(self): raise exception.RegionNotConfigured( \"No backend is configured on this region.\") @property","If the value is not present, the method returns the token ``NO_VALUE``. ``NO_VALUE``","is_invalidated(self, timestamp): \"\"\"Check timestamp to determine if it was invalidated. :return: Boolean. True","be invoked. However, subsequent requests for cached-but-expired values will still return promptly. They","optionally processed by the key_mangler function, so can be of any type recognized","that value is returned immediately without blocking. If the :meth:`.invalidate` method has been","self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend,","thread = threading.Thread(target=runner) thread.start() region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url':","name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner","the given keys. The list of keys to be generated is passed to","relative to the function. This is a convenience method for :meth:`.CacheRegion.set` which will","to the constructor of the :class:`.CacheBackend` in use, though is typically a dictionary.","invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated = None self._hard_invalidated = None def","but is separate from ``None`` to distinguish between a cached value of ``None``.","in-place on the submitted ``mapping`` dict. :param keys: Sequence of keys to be","acquire the dogpile lock to generate a new value, or will wait until","sequence of cached values based on a sequence of keys. The behavior for","module ``myapp.tools``:: @region.cache_on_arguments(namespace=\"foo\") def one(a, b): return a + b Above, calling ``one(3,","makes use of the :meth:`.CacheRegion.get_or_create` method to access the cache and conditionally call","True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is","will produce a \"cache key\" given a data creation function and arguments, when","be used to convert non-string or Unicode keys to bytestrings, which is needed","of the cache key. This may be needed to disambiguate functions of the","the ``expiration_time``. This callable will be called whenever the decorated function itself is","async_creation_runner: A callable that, when specified, will be passed to and called by","than the last region invalidation time. \"\"\" raise NotImplementedError() def was_soft_invalidated(self): \"\"\"Indicate the","= fn.__name__ + (namespace or '') def generate_keys(*args): return [namespace + ':' +","generate a new value, or will wait until the lock is released to","process is already running a creation function for this key against the cache.","value. .. versionchanged:: 0.3.0 The value is unconditionally regenerated if the creation time","return namespace + \"_\" + fname + \"_\".join(str(s) for s in arg) return","be acquired, the method will block if no previous value is available, until","Optional. A list of :class:`.ProxyBackend` classes and/or instances, each of which will be","isn't cached. E.g.:: def dont_cache_none(value): return value is not None value = region.get_or_create(\"some","is to prevent deadlocks. # though haven't been able to simulate one anyway.","Pass to ``invalidate()`` the same arguments you'd pass to the function itself to","file, such as those associated with classes - note that the decorator itself","be established as part of each cache key. :param expiration_time: if not None,","same mechanism as that of :meth:`.CacheRegion.get_multi` to retrieve all current values; the originally","(namespace or '') def generate_keys(*args): return [namespace + ':' + str(a) for a","import Number from functools import wraps import threading _backend_loader = PluginLoader(\"dogpile.cache\") register_backend =","... region = CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator`","self.key_mangler(key) value = self.backend.get(key) value = self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload def _unexpired_value_fn(self,","finally: for mutex in mutexes.values(): mutex.release() def _value(self, value): \"\"\"Return a :class:`.CachedValue` given","a creation function for this key against the cache. When the dogpile lock","to be expired based on its creation time, the given creation function may","of calling the decorated function will also be a list. When ``asdict==True`` if","None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn)","Optional. Similar to ``function_key_generator`` parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should","way of, for example, a background thread, a long-running queue, or a task","make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, } ) Remember","value of ``None``. By default, the configured expiration time of the :class:`.CacheRegion`, or","sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in","the invalidator given the region as an argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self, region):","Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated = None self._hard_invalidated = None def invalidate(self,","key derived from the function itself and its arguments. The decorator internally makes","function should return list of keys. For example:: def my_multi_key_generator(namespace, fn, **kw): namespace","return [] if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys)","This operation is idempotent (can be called multiple times, or on a non-existent","is_hard_invalidated(self, timestamp): \"\"\"Check timestamp to determine if it was hard invalidated. :return: Boolean.","passed a type rather than an instance then # initialize it. if type(proxy)","backend is configured on this region.\") @property def is_configured(self): \"\"\"Return True if the","can be created in a background thread like so:: import threading def async_creation_runner(cache,","async_creator(mutex): return self.async_creation_runner( self, orig_key, creator, mutex) else: async_creator = None with Lock(","Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a single function signature, one","for the cached function result. Example use cases include \"cache the result until","\"cache.local.\") memcached_region.configure_from_config(myconfig, \"cache.memcached.\") \"\"\" config_dict = coerce_string_conf(config_dict) return self.configure( config_dict[\"%sbackend\" % prefix], expiration_time=config_dict.get(","0.5.3 Added ``get()`` method to decorated function. The default key generation will use","if ``timestamp`` is older than the last region invalidation time and region is",".. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" def get_value(key): value = values.get(key,","conjunction with Unicode keys. :param async_creation_runner: A callable that, when specified, will be","invalidated in hard mode. \"\"\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated =","that wish to have access to the :class:`.CacheRegion` itself should construct the invalidator","on the submitted ``mapping`` dict. :param keys: Sequence of keys to be retrieved.","such as bsddb or dbm under Python 2.x in conjunction with Unicode keys.","str(a) for a in args] return generate_keys :param key_mangler: Function which will be","class and wraps the attached backend. ''' # if we were passed a","to :meth:`.invalidate`. :param key: Key to be retrieved. While it's typical for a","creator: function which creates a new value. :param expiration_time: optional expiration time which","as an integer number of seconds, or as a ``datetime.timedelta`` value. .. versionadded","= None with Lock( self._mutex(key), gen_value, get_value, expiration_time, async_creator) as value: return value","for k, v in mapping.items()) else: mapping = dict((k, self._value(v)) for k, v","expiration time for the cached function result. Example use cases include \"cache the","if the cache is invalid, however if the return value is None, it","and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \"Non-None expiration time required \" \"for soft invalidation\") if","NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\"ct\"])): raise NeedRegenerationException() ct = value.metadata[\"ct\"]","of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\"k1\", \"k2\", \"k3\") ...a ``refresh()`` method, which will call the creation","However, subsequent requests for cached-but-expired values will still return promptly. They will be","represent a particular value:: generate_something.invalidate(5, 6) Another attribute ``set()`` is added to provide","callable that, when specified, will be passed to and called by dogpile.lock when","key to be a string, it is ultimately passed directly down to the","\"multiple key\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [","values, and the final result of calling the decorated function will also be","'backend' in self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False): \"\"\"Return a value from the","that configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.3.0 :param ignore_expiration: if ``True``,","% self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix )","If a previous value is available, that value is returned immediately without blocking.","True if the backend has been configured via the :meth:`.CacheRegion.configure` method already. ..","function is received by the decorator before it becomes an instance method. The","unless a new value is needed:: result = generate_something(5, 6) The function is","function_key_generator=None): \"\"\"A function decorator that will cache the return value of the function","function accepts non-ascii unicode arguments on Python 2.x, the ``unicode()`` builtin can be","async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass try: if mutexes: # sort the keys,","cache the new values, and return them:: values = generate_something.refresh(\"k1\", \"k2\", \"k3\") ...and","a chain to ultimately wrap the original backend, so that custom functionality augmentation","the :meth:`.CacheRegion.get_or_create` method to access the cache and conditionally call the function. See","replace_existing_backend: raise exception.RegionAlreadyConfigured( \"This region is already \" \"configured with backend: %s. \"","else: mapping = dict((k, self._value(v)) for k, v in mapping.items()) self.backend.set_multi(mapping) def delete(self,","expiration_time() if expiration_time_is_callable \\ else expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg,","exception.RegionNotConfigured( \"No backend is configured on this region.\") @property def is_configured(self): \"\"\"Return True","time supplied by the ``expiration_time`` argument, is tested against the creation time of","timestamp): return (self._invalidated is not None and timestamp < self._invalidated) def was_hard_invalidated(self): return","should_cache_fn: optional callable function which will receive the value returned by the \"creator\",",":class:`.CacheRegion` at configure time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region =",":meth:`.CacheRegion.get` method) will call upon the value creation function after this time period","# dogpile.core understands a 0 here as # \"the value is not available\",","the retrieved value's timestamp is older than the invalidation timestamp, the value is","a convenience method for :meth:`.CacheRegion.set` which will store a given value directly without","``MyOtherClass``. Python class declaration mechanics otherwise prevent the decorator from having awareness of","= backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend = backend_cls(arguments or {}) if not","``namespace`` parameter disambiguates between ``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python class declaration mechanics","def creator(*keys_to_create): return fn(*[key_lookup[k] for k in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable",":meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and set values from the backend. If you","not should_cache_fn: return True else: return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout,","for invalidation of the value. Pass to ``invalidate()`` the same arguments you'd pass","return its result as a list of values, and the final result of","ready to use for function # decorators, but not yet for actual caching","to the calling function. A correct implementation of ``.set_multi()`` will not modify values","should_cache_fn: optional callable function which will receive each value returned by the \"creator\",","a sequence of keys and returns a sequence of new values. :param expiration_time:","time passed to the dogpile system. May be passed as an integer number","of :class:`.ProxyBackend` classes and/or instances, each of which will be applied in a","them:: values = generate_something.refresh(\"k1\", \"k2\", \"k3\") ...and a ``get()`` method, which will return","{} sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys]","that method for additional behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x, y): return somedatabase.query(x,",":meth:`.CacheRegion.configure` to override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated =","was invalidated in soft mode. :return: Boolean. True if region was invalidated in","0.3.0 :param ignore_expiration: if ``True``, the value is returned from the cache if","it was hard invalidated. :return: Boolean. True if ``timestamp`` is older than the","if region was invalidated in hard mode. \"\"\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def","or {}) if not expiration_time or isinstance(expiration_time, Number): self.expiration_time = expiration_time elif isinstance(expiration_time,","= threading.Lock() def acquire(self, wait=True): return self.lock.acquire(wait) def release(self): self.lock.release() def _create_mutex(self, key):","returned. Passing the flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionchanged:: 0.3.0","the ``function_key_generator`` argument present on :func:`.make_region` and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`. :param","not NO_VALUE else value for value in ( _unexpired_value_fn(value) for value in backend_values",":meth:`.invalidate`. :param key: Key to be retrieved. While it's typical for a key","is idempotent (can be called multiple times, or on a non-existent key, safely)","exception is raised if a backend is already configured. .. versionadded:: 0.5.7 :param","from the ``dogpile.cache`` entrypoint. :param expiration_time: Optional. The expiration time passed to the","for threading.Lock\"\"\" def __init__(self): self.lock = threading.Lock() def acquire(self, wait=True): return self.lock.acquire(wait) def","list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None):","argument list, and the decorated function is then called with that subset of","in zip(keys_to_get, new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for","function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def","applied. .. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True, the existing","region is already \" \"configured with backend: %s. \" \"Specify replace_existing_backend=True to replace.\"","callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str:","that, when specified, will be passed to and called by dogpile.lock when there","be created in a background thread like so:: import threading def async_creation_runner(cache, somekey,","the configured expiration time of the :class:`.CacheRegion`, or alternatively the expiration time supplied","y): return somedatabase.query(x, y) The decorated function can then be called normally, where","key generation will use the name of the function, the module name for","specified, will be passed to and called by dogpile.lock when there is a","\"configured with backend: %s. \" \"Specify replace_existing_backend=True to replace.\" % self.backend) backend_cls =","itself should construct the invalidator given the region as an argument:: class MyInvalidator(RegionInvalidationStrategy):","pluck from \\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return \":\".join( [kw[k] for","store a given value directly without calling the decorated function. The value to","value directly without calling the decorated function. The value to be cached is","regeneration; dogpile logic won't be used. If False, the creation time of existing","a value.\"\"\" return CachedValue( value, { \"ct\": time.time(), \"v\": value_version }) def set(self,","value. Any retrieved value whose creation time is prior to this timestamp is","function key generation can be entirely replaced on a per-region basis using the","value in ( _unexpired_value_fn(value) for value in backend_values ) ] def get_or_create( self,","lambda value: value else: if expiration_time is None: expiration_time = self.expiration_time current_time =","alternatively the expiration time supplied by the ``expiration_time`` argument, is tested against the","call the creation function, cache the new values, and return them:: values =","to later points in the future by way of, for example, a background","optional string argument which will be established as part of each cache key.","of :meth:`.CacheRegion.get_multi` to retrieve all current values; the originally passed keys corresponding to","the key_mangler function, if present. :param expiration_time: Optional expiration time value which will","itself is called, in caching or retrieving. Thus, this can be used to","first argument, and the arguments which would normally be passed to the function","\"\"\"Region invalidation. :class:`.CacheRegion` propagated call. The default invalidation system works by setting a","in the cache under the given keys. .. versionadded:: 0.5.0 \"\"\" if not","self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \"\"\"Remove multiple values from the cache. This operation","should_cache_fn=None): \"\"\"Return a sequence of cached values based on a sequence of keys.","**kw): key = key_generator(*arg, **kw) value = fn(*arg, **kw) self.set(key, value) return value","existing values will be pushed back before the expiration time so that a","None and \\ current_time - value.metadata[\"ct\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\"ct\"]):","prior to this timestamp is considered to be stale. It does not affect","prefix, None), ) @memoized_property def backend(self): raise exception.RegionNotConfigured( \"No backend is configured on","new :class:`.CacheRegion`.\"\"\" self.name = name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler =","value in backend_values ) ] def get_or_create( self, key, creator, expiration_time=None, should_cache_fn=None): \"\"\"Return","as the first argument, and the arguments which would normally be passed to","the backend or by the key_mangler function, if present. :param creator: function which","at its default value of ``False``, the decorated function should return its result","the normal expiration time. May be specified as a callable, taking no arguments,","getattr(wrap, '__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator","not a valid ProxyBackend\" % type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self, key): return","function can then be called normally, where data will be pulled from the","by dogpile.lock when there is a stale value present in the cache. It","or False, indicating if the value should actually be cached or not. If","be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw): return my_data() .. seealso::","use the value -1. :param should_cache_fn: optional callable function which will receive each","invokes ``.set_multi()`` for newly generated values using the same values it returns to","dict( (k, v) for k, v in zip(cache_keys, result) if v is not","returns False, the value is still returned, but isn't cached. .. versionadded:: 0.5.0","invalidate(self, hard=True): \"\"\"Region invalidation. :class:`.CacheRegion` propagated call. The default invalidation system works by",".. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi`","in any way, and is also local to this instance of :class:`.CacheRegion`. Once","a current timestamp (using ``time.time()``) representing the \"minimum creation time\" for a value.",":param should_cache_fn: optional callable function which will receive the value returned by the","or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands a 0 here","keys before passing to the backend. Defaults to ``None``, in which case the","mutex = self.backend.get_mutex(key) if mutex is not None: return mutex else: return self._LockWrapper()","long-running queue, or a task manager system like Celery. For a specific example","dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in orig_to_mangled.items(): with Lock(","expiration time. May be specified as a callable, taking no arguments, that returns","keys = key_generator(*arg, **kw) key_lookup = dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k]","creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key) def set_(value,","def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys = list(mapping) gen_keys =","\"namespace\" parameter in order to generate a cache key. Given a function ``one``","dict(zip(keys, values)) Keys which aren't present in the list are returned as the","is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp < self._soft_invalidated) The custom implementation is injected","function decorator that will cache multiple return values from the function using a","= self.expiration_time current_time = time.time() def value_fn(value): if value is NO_VALUE: return value","..util import PluginLoader, memoized_property, coerce_string_conf from .util import function_key_generator, function_multi_key_generator from .api import",":param replace_existing_backend: if True, the existing cache backend will be replaced. Without this","name for the region. This isn't used internally but can be accessed via","keys to bytestrings, which is needed when using a backend such as bsddb","'expiration_time is not a number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler","the value should actually be cached or not. If it returns False, the","and a prefix. Example:: local_region = make_region() memcached_region = make_region() # regions are","If you are using a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies values, take note","time.time() - expiration_time - .0001 return value.payload, ct def gen_value(): created_value = creator()","is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated","from \\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return \":\".join( [kw[k] for k","value is still returned, but isn't cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments`","return the generated values as a sequence corresponding to the order of the","def delete_multi(self, keys): \"\"\"Remove multiple values from the cache. This operation is idempotent","awareness of the ``MyClass`` and ``MyOtherClass`` names, as the function is received by","cached-but-expired values will still return promptly. They will be refreshed by whatever asynchronous",".. seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` - optional gen that also","keys into a SHA1 hash, so that the string length is fixed. To","the ``creator()`` function may be asked to generate any subset of the given","but note this will produce unicode cache keys which may require key mangling","function is also given an attribute ``invalidate()``, which provides for invalidation of the","expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key = key_generator(*arg, **kw)","normal expiration time. May be passed as an integer or a callable. :param","hash, so that the string length is fixed. To disable all key mangling,","= region.get_multi(keys) dictionary = dict(zip(keys, values)) Keys which aren't present in the list","return values based on the given arguments:: values = generate_something.get(\"k1\", \"k2\", \"k3\") ..","feature. \"\"\" def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \"\"\"Construct a","existing cache backend will be replaced. Without this flag, an exception is raised","_config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend = backend_cls(arguments or {})","not. If it returns False, the value is still returned, but isn't cached.","value.metadata[\"ct\"])): raise NeedRegenerationException() ct = value.metadata[\"ct\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time","function with the optional namespace and with the string form of each key.","is already configured. .. versionadded:: 0.5.7 :param region_invalidator: Optional. Override default invalidation strategy","works only with a single function signature, one which takes a simple list","value) return value.payload, value.metadata[\"ct\"] if expiration_time is None: expiration_time = self.expiration_time if (expiration_time","= arg keys = key_generator(*arg, **kw) key_lookup = dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create):","self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator =","function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function","needed when using a backend such as bsddb or dbm under Python 2.x","later, when config is available myconfig = { \"cache.local.backend\":\"dogpile.cache.dbm\", \"cache.local.arguments.filename\":\"/path/to/dbmfile.dbm\", \"cache.memcached.backend\":\"dogpile.cache.pylibmc\", \"cache.memcached.arguments.url\":\"127.0.0.1, 10.0.0.1\",","check. .. versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param key: Key to","\"for soft invalidation\") if expiration_time == -1: expiration_time = None if self.async_creation_runner: def","# initialize it. if type(proxy) == type: proxy = proxy() if not issubclass(type(proxy),","given an attribute ``invalidate()``, which provides for invalidation of the value. Pass to","within the same source file, such as those associated with classes - note","d_values = creator(*keys) return [ d_values.get(key_lookup[k], NO_VALUE) for k in keys] def wrap_cache_fn(value):","the same values it returns to the calling function. A correct implementation of","async_creation_runner feature. \"\"\" def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \"\"\"Construct","generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added ``refresh()`` method to decorated function. Lastly, the","in the cache in any way, and is also local to this instance","key. :param expiration_time: if not None, will override the normal expiration time. May","same cache key of ``myapp.tools:one|foo|3 4`` - the name ``self`` is skipped. The","one which takes a simple list of keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the","keys to be generated is passed to ``creator()``, and ``creator()`` should return the","for a in args] return generate_keys :param key_mangler: Function which will be used","replace.\" % self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix","reaching the cache. .. versionadded:: 0.5.0 :param function_multi_key_generator: a function that will produce","terms of the current \"invalidation\" time as set by the :meth:`.invalidate` method. If","calling the decorated function. The value to be cached is passed as the","``unicode()`` builtin can be substituted, but note this will produce unicode cache keys","a number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex)","time as set by the :meth:`.invalidate` method. If a value is present, but","the first request for a key with no associated value will always block;","= _backend_loader.register from . import backends # noqa value_version = 1 \"\"\"An integer","using a backend such as bsddb or dbm under Python 2.x in conjunction","'url': '127.0.0.1:11211', 'distributed_lock': True, } ) Remember that the first request for a","typically a dictionary. :param wrap: Optional. A list of :class:`.ProxyBackend` classes and/or instances,","local_region.configure_from_config(myconfig, \"cache.local.\") memcached_region.configure_from_config(myconfig, \"cache.memcached.\") \"\"\" config_dict = coerce_string_conf(config_dict) return self.configure( config_dict[\"%sbackend\" % prefix],","called. .. versionadded:: 0.3.0 \"\"\" if self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key)","will force an immediate regeneration of the value which all getters will wait","when there is a stale value present in the cache. It will be","the dogpile lock cannot be acquired, the method will block if no previous","function using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \"\"\" orig_key = key","able to simulate one anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get) values_w_created =","self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \"\"\"A","decorator suitable (with caveats) for use with instance or class methods. Given the","release(self): self.lock.release() def _create_mutex(self, key): mutex = self.backend.get_mutex(key) if mutex is not None:","left at its default value of ``False``, the decorated function should return its","tuple, used to specify arguments to pluck from \\**kw:: def my_key_generator(namespace, fn): def","here is passed directly to the constructor of the :class:`.CacheBackend` in use, though","passed directly to the constructor of the :class:`.CacheBackend` in use, though is typically","dictionary = dict(zip(keys, values)) Keys which aren't present in the list are returned","this :class:`.CacheRegion` if not None. To set no expiration, use the value -1.","== -1: expiration_time = None mutexes = {} sorted_unique_keys = sorted(set(keys)) if self.key_mangler:","(can be called multiple times, or on a non-existent key, safely) \"\"\" if","arguments. The decorator internally makes use of the :meth:`.CacheRegion.get_or_create` method to access the","which would normally be passed to the function should follow:: generate_something.set(3, 5, 6)","should_cache_fn) def invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw):","dict(zip(keys, [values[a] for a in arg])) ) return values else: self.set_multi( dict(zip(keys, values))","to be retrieved. :param creator: function which accepts a sequence of keys and","string, it is ultimately passed directly down to the cache backend, before being","the decorated function should return its result as a list of values, and","region. This isn't used internally but can be accessed via the ``.name`` parameter,","def decorate(*arg, **kw): cache_keys = arg keys = key_generator(*arg, **kw) key_lookup = dict(zip(keys,","is received by the decorator before it becomes an instance method. The function","6) The function is also given an attribute ``invalidate()``, which provides for invalidation","as part of each cache key. :param expiration_time: if not None, will override","the :meth:`.invalidate` method. If a value is present, but its creation time is","value's creation time against the expiration time, rather than returning the value unconditionally.","being returned. The method will attempt to acquire the dogpile lock to generate","in ( _unexpired_value_fn(value) for value in backend_values ) ] def get_or_create( self, key,","= self.function_key_generator def decorator(fn): if to_str is compat.string_type: # backwards compatible key_generator =","If the value does not exist or is considered to be expired based","and timestamp < self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp):","outside this function, so in fact can be of any form. For example,","structure of this function should be two levels: given the data creation function,","timestamp): return (self._soft_invalidated and timestamp < self._soft_invalidated) The custom implementation is injected into","in args] return generate_keys :param key_mangler: Function which will be used on all","expiration_time = None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self, orig_key, creator, mutex)","generate_something.get(\"k1\", \"k2\", \"k3\") .. versionadded:: 0.5.3 Added ``get()`` method to decorated function. Parameters","should_cache_fn=dont_cache_none) Above, the function returns the value of create_value() if the cache is","arguments you'd pass to the function itself to represent a particular value:: generate_something.invalidate(5,","versionchanged:: 0.3.0 The value is unconditionally regenerated if the creation time is older","value whose creation time is prior to this timestamp is considered to be","current \"invalidation\" time as set by the :meth:`.invalidate` method. If a value is","Lastly, the ``get()`` method returns either the value cached for the given key,",":param key: Key to be retrieved. While it's typical for a key to","return value.payload, ct def gen_value(): created_value = creator() value = self._value(created_value) if not","keys and returns a sequence of new values. :param expiration_time: optional expiration time","functionality augmentation can be applied. .. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend:",":func:`.make_region` is a passthrough to :class:`.CacheRegion`. See that class for constructor arguments. \"\"\"","multiple values from the cache, based on the given keys. Returns values as","two functions of the same name within the same module, as can occur",":meth:`.get_or_create` to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \"\"\"","time check. .. versionadded:: 0.5.0 \"\"\" if not keys: return [] if self.key_mangler:","accepts a mapping of keys and values to set in the cache:: generate_something.set({\"k1\":","if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend = backend_cls(arguments or","= self.expiration_time if (expiration_time is None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \"Non-None expiration time","custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \"\"\" if \"backend\" in self.__dict__ and","actual caching # later, when config is available myconfig = { \"cache.local.backend\":\"dogpile.cache.dbm\", \"cache.local.arguments.filename\":\"/path/to/dbmfile.dbm\",","\"k3\") .. versionadded:: 0.5.3 Added ``get()`` method to decorated function. Parameters passed to","if not None, will override the normal expiration time. May be passed as","+ fname + \"_\".join(str(s) for s in arg) return generate_key region = make_region(","block if no previous value is available, until the lock is released and","to the backend. Defaults to ``None``, in which case the key mangling function","0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is None:","and the decorated function is then called with that subset of arguments. The","self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload","if v is not NO_VALUE) else: result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn)","also provided with a ``set()`` method, which here accepts a mapping of keys","new one is available. Usage of \"soft\" invalidation requires that the region or","internally but can be accessed via the ``.name`` parameter, helpful for configuring a","than returning the value unconditionally. The method also interprets the cached value in","can be used to defer the computation of expensive creator functions to later","is released and a new value available. If a previous value is available,","implementation instance to :meth:`.CacheRegion.configure` to override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def","invalidated in soft mode. \"\"\" raise NotImplementedError() def is_invalidated(self, timestamp): \"\"\"Check timestamp to","False. return value.payload, 0 else: ct = value.metadata[\"ct\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time()","cache region unless a new value is needed:: result = generate_something(5, 6) The","NotImplementedError() def is_soft_invalidated(self, timestamp): \"\"\"Check timestamp to determine if it was soft invalidated.","the same mechanism as that of :meth:`.CacheRegion.get_multi` to retrieve all current values; the","its result as a list of values, and the final result of calling","by the cache backend will be used. A typical mangler is the SHA1","and \"soft\" invalidation options. With \"hard\" invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate regeneration","value = self.backend.get(key) if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated(","key mangling function recommended by the cache backend will be used. A typical","sequence of keys. The behavior for generation of values based on keys corresponds","method for additional behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with","with the optional namespace and with the string form of each key. It","method to decorated function. Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as","= creator() cache.set(somekey, value) finally: mutex.release() thread = threading.Thread(target=runner) thread.start() region = make_region(","= self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload if value is not NO_VALUE else","value:: newvalue = generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added ``refresh()`` method to decorated","value elif expiration_time is not None and \\ current_time - value.metadata[\"ct\"] > expiration_time:",".. versionadded:: 0.5.3 Added ``get()`` method to decorated function. The default key generation","return ((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated and timestamp < self._hard_invalidated)) def","value is available, until the lock is released and a new value available.","value.metadata['v'])): # dogpile.core understands a 0 here as # \"the value is not","region invalidation time and region is invalidated in soft mode. \"\"\" raise NotImplementedError()","here as # \"the value is not available\", e.g. # _has_value() will return","values from the cache, based on the given keys. Returns values as a","key based on the given arguments. Such as:: def my_key_generator(namespace, fn, **kw): fname","modify values in-place on the submitted ``mapping`` dict. :param keys: Sequence of keys","decorated function itself is called, in caching or retrieving. Thus, this can be","value is NO_VALUE: return False elif not should_cache_fn: return True else: return should_cache_fn(value)","method already. .. versionadded:: 0.5.1 \"\"\" return 'backend' in self.__dict__ def get(self, key,","that the first request for a key with no associated value will always","**kw): key = key_generator(*arg, **kw) @wraps(fn) def creator(): return fn(*arg, **kw) timeout =","versionadded:: 0.5.0 :param function_multi_key_generator: a function that will produce a list of keys.","def gen_value(): raise NotImplementedError() def async_creator(key, mutex): mutexes[key] = mutex if expiration_time is","default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated = None self._hard_invalidated =","return self._LockWrapper() def invalidate(self, hard=True): \"\"\"Invalidate this :class:`.CacheRegion`. The default invalidation system works","from ..util import compat import time import datetime from numbers import Number from","region_invalidator: self.region_invalidator = region_invalidator return self def wrap(self, proxy): ''' Takes a ProxyBackend","using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that","such key exists:: value = generate_something.get(5, 6) .. versionadded:: 0.5.3 Added ``get()`` method","to simulate one anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get) values_w_created = dict(","**kw) key_lookup = dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k] for k in","prevented from being returned. The method will attempt to acquire the dogpile lock","if expiration_time is None: expiration_time = self.expiration_time if (expiration_time is None and self.region_invalidator.was_soft_invalidated()):","in mapping.items()) else: mapping = dict((k, self._value(v)) for k, v in mapping.items()) self.backend.set_multi(mapping)","is tested against the creation time of the retrieved value versus the current","Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`.","the :meth:`.CacheRegion.invalidate` method. :param key: Key to be retrieved. While it's typical for","versionadded:: 0.3.0 :param ignore_expiration: if ``True``, the value is returned from the cache","for actual caching # later, when config is available myconfig = { \"cache.local.backend\":\"dogpile.cache.dbm\",","not None and \\ current_time - value.metadata[\"ct\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated(",") return values else: self.set_multi( dict(zip(keys, values)) ) return values decorate.set = set_","this flag, an exception is raised if a backend is already configured. ..","of ``self`` or ``cls``, making the decorator suitable (with caveats) for use with","disambiguate two functions of the same name within the same module, as can","class methods as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \"\" class","compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time is not a number or timedelta.') if not","from . import backends # noqa value_version = 1 \"\"\"An integer placed in","function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator","the decorated function is then called with that subset of arguments. The returned","into the cache with the new value, as well as returning that value::","\"\"\"Configure from a configuration dictionary and a prefix. Example:: local_region = make_region() memcached_region","function_multi_key_generator=None): \"\"\"A function decorator that will cache multiple return values from the function","== type: proxy = proxy() if not issubclass(type(proxy), ProxyBackend): raise TypeError(\"Type %s is",":meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key) for key in keys","than the invalidation timestamp, the value is unconditionally prevented from being returned. The","optional, and is used normally to disambiguate two functions of the same name","will produce a \"cache key\". This function will supersede the one configured on","NO_VALUE: return value elif expiration_time is not None and \\ current_time - value.metadata[\"ct\"]","is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports both","should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result = dict( (k, v)","optional gen that also uses keyword arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator``","``None``, in which case the key mangling function recommended by the cache backend","which coerces keys into a SHA1 hash, so that the string length is","if (expiration_time is None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \"Non-None expiration time required \"","invalidation time, the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses the",":meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \"\"\" orig_key = key if self.key_mangler: key =","cache. .. versionadded:: 0.5.0 :param function_multi_key_generator: a function that will produce a list","= creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k], self._value(v)) for k, v in zip(keys_to_get, new_values)","cached. .. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function","return generate_keys :param key_mangler: Function which will be used on all incoming keys","..util import NameRegistry from . import exception from ..util import PluginLoader, memoized_property, coerce_string_conf","to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside this function, so in fact can be","bytestrings, which is needed when using a backend such as bsddb or dbm","unconditionally regenerated if the creation time is older than the last call to","return mutex else: return self._LockWrapper() def invalidate(self, hard=True): \"\"\"Invalidate this :class:`.CacheRegion`. The default","and :meth:`.Region.set_multi` to get and set values from the backend. If you are","implementation of ``.set_multi()`` will not modify values in-place on the submitted ``mapping`` dict.","if the backend has been configured via the :meth:`.CacheRegion.configure` method already. .. versionadded::","calling ``generate_something(5, 6)``, if the function were to produce the value ``3`` as","NeedRegenerationException from ..util import NameRegistry from . import exception from ..util import PluginLoader,","key\". This function will supersede the one configured on the :class:`.CacheRegion` itself. ..",".. versionadded:: 0.4.2 added the async_creation_runner feature. \"\"\" def __init__( self, name=None, function_key_generator=function_key_generator,","expiration_time=config_dict.get( \"%sexpiration_time\" % prefix, None), _config_argument_dict=config_dict, _config_prefix=\"%sarguments.\" % prefix, wrap=config_dict.get( \"%swrap\" % prefix,","ignore_expiration=False): \"\"\"Return a value from the cache, based on the given key. If","is given a non-None expiration time. .. versionadded:: 0.3.0 :param hard: if True,","interprets the cached value in terms of the current \"invalidation\" time as set","subsequent requests for cached-but-expired values will still return promptly. They will be refreshed","somedatabase.query(key) for key in keys ] The decorated function can be called normally.","exist or is considered to be expired based on its creation time, the","the ``.name`` parameter, helpful for configuring a region from a config file. :param","typical mangler is the built-in Python function ``str``, which can be used to","for additional behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x, y): return somedatabase.query(x, y) The","raise exception.RegionAlreadyConfigured( \"This region is already \" \"configured with backend: %s. \" \"Specify",":meth:`.invalidate` method has been called, and the retrieved value's timestamp is older than","will be passed to and called by dogpile.lock when there is a stale","a key derived from the function itself and its arguments. The decorator internally","chain to ultimately wrap the original backend, so that custom functionality augmentation can","a new value, or will wait until the lock is released to return","the key_mangler function, so can be of any type recognized by the backend","hard mode. :return: Boolean. True if region was invalidated in hard mode. \"\"\"","function. The value to be cached is passed as the first argument, and","times, or on a non-existent key, safely) .. versionadded:: 0.5.0 \"\"\" if self.key_mangler:","in self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False): \"\"\"Return a value from the cache,","invalid, however if the return value is None, it won't be cached. ..","key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in zip(gen_keys, keys)) ) def get(*arg):","yet for actual caching # later, when config is available myconfig = {","which aren't generated or need regeneration will be assembled into a new argument","``invalidate()`` method, which has the effect of deleting the given sequence of keys","of the :class:`.CacheBackend` to use, and is resolved by loading the class from","keys. .. versionadded:: 0.5.0 \"\"\" if not mapping: return if self.key_mangler: mapping =","functions of the same name within the same module, as can occur when","the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a single function signature, one which","with backend: %s. \" \"Specify replace_existing_backend=True to replace.\" % self.backend) backend_cls = _backend_loader.load(backend)","produce a cache key as follows:: myapp.tools:one|foo|3 4 The key generator will ignore","a value is present, but its creation time is older than the current","for k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values","return value_fn def get_multi(self, keys, expiration_time=None, ignore_expiration=False): \"\"\"Return multiple values from the cache,","result = generate_something(\"key1\", \"key2\", \"key3\") The decorator internally makes use of the :meth:`.CacheRegion.get_or_create_multi`","make_region(*arg, **kw): \"\"\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`.","= time.time() def is_invalidated(self, timestamp): return (self._invalidated is not None and timestamp <","you'd pass to the function itself to represent a particular value:: generate_something.invalidate(5, 6)","those associated with classes - note that the decorator itself can't see the","def is_hard_invalidated(self, timestamp): \"\"\"Check timestamp to determine if it was hard invalidated. :return:","key in zip(gen_keys, keys)) ) def get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def","an optional \"namespace\" parameter in order to generate a cache key. Given a","then consult the cache using the same mechanism as that of :meth:`.CacheRegion.get_multi` to","so in fact can be of any form. For example, it can be","Python 2.x, the ``unicode()`` builtin can be substituted, but note this will produce","creator, expiration_time=None, should_cache_fn=None): \"\"\"Return a sequence of cached values based on a sequence","def set_(mapping): keys = list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key,","method will block if no previous value is available, until the lock is","normal expiration time. May be specified as a callable, taking no arguments, that","\\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\"ct\"] if expiration_time is None: expiration_time =","< self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return (self._hard_invalidated and timestamp","Example:: local_region = make_region() memcached_region = make_region() # regions are ready to use","regenerated if the creation time is older than the last call to :meth:`.invalidate`.","set no expiration, use the value -1. :param should_cache_fn: optional callable function which","+ \"_\" + fname + \"_\".join(str(s) for s in arg) return generate_key region",".. versionadded 0.5.0 ``expiration_time`` may be optionally passed as a ``datetime.timedelta`` value. The","else: return value return value_fn def get_multi(self, keys, expiration_time=None, ignore_expiration=False): \"\"\"Return multiple values","keys, creator, expiration_time=None, should_cache_fn=None): \"\"\"Return a sequence of cached values based on a","provides for invalidation of the value. Pass to ``invalidate()`` the same arguments you'd","``True``, the value is returned from the cache if present, regardless of configured","decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \"\"\"A function decorator","to determine if it was soft invalidated. :return: Boolean. True if ``timestamp`` is","the cache. .. versionadded:: 0.5.0 :param function_key_generator: a function that will produce a","Returns values as a list matching the keys given. E.g.:: values = region.get_multi([\"one\",","passed keys corresponding to those values which aren't generated or need regeneration will","not None: return mutex else: return self._LockWrapper() def invalidate(self, hard=True): \"\"\"Invalidate this :class:`.CacheRegion`.","aren't present in the list are returned as the ``NO_VALUE`` token. ``NO_VALUE`` evaluates","values will be pushed back before the expiration time so that a return+regen","_backend_loader = PluginLoader(\"dogpile.cache\") register_backend = _backend_loader.register from . import backends # noqa value_version","NotImplementedError() def async_creator(key, mutex): mutexes[key] = mutex if expiration_time is None: expiration_time =","for x in arg] ) return generate_key Where the decorator might be used","(value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\"ct\"])): raise NeedRegenerationException() ct","= self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result def invalidate(*arg): keys = key_generator(*arg)","\"\"\"Region invalidation strategy interface Implement this interface and pass implementation instance to :meth:`.CacheRegion.configure`","timestamp (using ``time.time()``) to consider all older timestamps effectively invalidated. \"\"\" raise NotImplementedError()","``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\"foo\") def one(a, b): return a + b","of keys using the same mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\"k1\", \"k2\", \"k3\")","key = key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw): key = key_generator(*arg, **kw)","takes a simple list of keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the decorated function","_config_prefix ) else: self.backend = backend_cls(arguments or {}) if not expiration_time or isinstance(expiration_time,","generates the key based on the given arguments. Such as:: def my_key_generator(namespace, fn,","new value in the cache under the given key.\"\"\" if self.key_mangler: key =","helpful for configuring a region from a config file. :param function_key_generator: Optional. A","A callable that, when specified, will be passed to and called by dogpile.lock","Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\"foo\") def one(self, a, b): return a +","the decorated function is also provided with a ``set()`` method, which here accepts","the exception that the ``creator()`` function may be asked to generate any subset","It will be passed the mutex and is responsible releasing that mutex when","def invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw): key","the same source file, such as those associated with classes - note that","``get()`` method, which will return values based on the given arguments:: values =","backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend","region_invalidator=None ): \"\"\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned. :param backend: Required.",":param function_key_generator: Optional. A function that will produce a \"cache key\" given a","keys given. E.g.:: values = region.get_multi([\"one\", \"two\", \"three\"]) To convert values to a","self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in zip(gen_keys, keys)) ) def get(*arg): keys","is injected into a :class:`.CacheRegion` at configure time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region","to be a string, it is ultimately passed directly down to the cache","time. .. versionadded:: 0.3.0 :param hard: if True, cache values will all require","mangler is the SHA1 mangler found at :func:`.sha1_mangle_key` which coerces keys into a","Usage of \"soft\" invalidation requires that the region or the method is given","self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload if value is not","be two levels: given the data creation function, return a new function that",":class:`.CacheRegion`.\"\"\" self.name = name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler","a non-None expiration time. .. versionadded:: 0.3.0 :param hard: if True, cache values","mutex.release() def _value(self, value): \"\"\"Return a :class:`.CachedValue` given a value.\"\"\" return CachedValue( value,","cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" def get_value(key): value =","force an immediate regeneration of the value which all getters will wait for.","built-in Python function ``str``, which can be used to convert non-string or Unicode","= name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler","the value is returned from the cache if present, regardless of configured expiration","was invalidated in soft mode. \"\"\" raise NotImplementedError() def was_hard_invalidated(self): \"\"\"Indicate the region","the value is unconditionally prevented from being returned. The method will attempt to","an integer or a callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This function is","SHA1 mangler found at :func:`.sha1_mangle_key` which coerces keys into a SHA1 hash, so","be replaced. Without this flag, an exception is raised if a backend is","a function ``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\"foo\") def one(a, b): return a","this will produce unicode cache keys which may require key mangling before reaching","set values from the backend. If you are using a :class:`.CacheBackend` or :class:`.ProxyBackend`","multiple return values from the function using a sequence of keys derived from","the final result of calling the decorated function will also be a list.","callable implements. By default the async_creation_runner is disabled and is set to ``None``.","on the given arguments:: values = generate_something.get(\"k1\", \"k2\", \"k3\") .. versionadded:: 0.5.3 Added","\"\"\" if \"backend\" in self.__dict__ and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \"This region is","versions of dogpile.cache can detect cached values from a previous, backwards-incompatible version. \"\"\"",":meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports both \"hard\" and \"soft\" invalidation","passed directly down to the cache backend, before being optionally processed by the","an exception is raised if a backend is already configured. .. versionadded:: 0.5.7","expensive creator functions to later points in the future by way of, for","passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable, will be called on","not the function is used depends on if the *dogpile lock* can be","@region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \"\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y):","returned as the ``NO_VALUE`` token. ``NO_VALUE`` evaluates to False, but is separate from","def was_soft_invalidated(self): \"\"\"Indicate the region was invalidated in soft mode. :return: Boolean. True","will be called on each function argument in order to convert to a","be called whenever the decorated function itself is called, in caching or retrieving.","for cached-but-expired values will still return promptly. They will be refreshed by whatever","a single function signature, one which takes a simple list of keys as","the cache:: generate_something.set({\"k1\": \"value1\", \"k2\": \"value2\", \"k3\": \"value3\"}) ...an ``invalidate()`` method, which has",":param expiration_time: Optional. The expiration time passed to the dogpile system. May be","but not yet for actual caching # later, when config is available myconfig","0.4.2 added the async_creation_runner feature. \"\"\" def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None,","current_time - value.metadata[\"ct\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\"ct\"]): return NO_VALUE else:","multiple values from the cache. This operation is idempotent (can be called multiple","(can be called multiple times, or on a non-existent key, safely) .. versionadded::","new value, as well as returning that value:: newvalue = generate_something.refresh(5, 6) ..","is already \" \"configured with backend: %s. \" \"Specify replace_existing_backend=True to replace.\" %","if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for k, v in values_w_created.items()","with Unicode keys. :param async_creation_runner: A callable that, when specified, will be passed","as the value to be cached. .. versionadded:: 0.4.1 Added ``set()`` method to","of the ``MyClass`` and ``MyOtherClass`` names, as the function is received by the","(gen_key, mapping[key]) for gen_key, key in zip(gen_keys, keys)) ) def get(*arg): keys =","it. if type(proxy) == type: proxy = proxy() if not issubclass(type(proxy), ProxyBackend): raise","''' Takes a ProxyBackend instance or class and wraps the attached backend. '''","or not :meth:`.invalidate` was called. .. versionadded:: 0.3.0 \"\"\" if self.key_mangler: key =","argument in order to convert to a string. Defaults to ``str()``. If the","of cached values based on a sequence of keys. The behavior for generation","a key with no associated value will always block; async_creator will not be","def set(self, key, value): \"\"\"Place a new value in the cache under the","responsible releasing that mutex when finished. This can be used to defer the","value will always block; async_creator will not be invoked. However, subsequent requests for","for newly generated values using the same values it returns to the calling",":param should_cache_fn: optional callable function which will receive each value returned by the","time\" for a value. Any retrieved value whose creation time is prior to","value ``3`` as the value to be cached. .. versionadded:: 0.4.1 Added ``set()``","equivalent to calling ``generate_something(5, 6)``, if the function were to produce the value","the function is received by the decorator before it becomes an instance method.","The decorator internally makes use of the :meth:`.CacheRegion.get_or_create_multi` method to access the cache","pass try: if mutexes: # sort the keys, the idea is to prevent","values = generate_something.get(\"k1\", \"k2\", \"k3\") .. versionadded:: 0.5.3 Added ``get()`` method to decorated","otherwise prevent the decorator from having awareness of the ``MyClass`` and ``MyOtherClass`` names,","be placed in the cache. :param asdict: if ``True``, the decorated function should",".. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \"\"\" def invalidate(self, hard=True): \"\"\"Region invalidation. :class:`.CacheRegion` propagated call. The","any type recognized by the backend or by the key_mangler function, if present.","the value creation function after this time period has passed since the last","same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and set values from the","[] if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn","corresponding to those values which aren't generated or need regeneration will be assembled","= generate_something.refresh(\"k1\", \"k2\", \"k3\") ...and a ``get()`` method, which will return values based","by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports both \"hard\" and","evaluates to False, but is separate from ``None`` to distinguish between a cached","a callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param","as returned by the creator, and only if it returns True will that","requests for cached-but-expired values will still return promptly. They will be refreshed by","attempt to acquire the dogpile lock to generate a new value, or will","wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return self def wrap(self,","return value elif expiration_time is not None and \\ current_time - value.metadata[\"ct\"] >","behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a single function","a list of values, and the final result of calling the decorated function","is still returned, but isn't cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create`","return False. return value.payload, 0 else: ct = value.metadata[\"ct\"] if self.region_invalidator.is_soft_invalidated(ct): ct =","if self.key_mangler: mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys","each value returned by the \"creator\", and will then return True or False,","before the expiration time so that a return+regen will be invoked. .. versionadded::","seconds, or as a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time`` may be optionally","with a ``set()`` method, which here accepts a mapping of keys and values","invalidated in hard mode. \"\"\" raise NotImplementedError() def is_soft_invalidated(self, timestamp): \"\"\"Check timestamp to","the cache if present, regardless of configured expiration times or whether or not","is unconditionally prevented from being returned. The method will attempt to acquire the","is still returned, but isn't cached. E.g.:: def dont_cache_none(value): return value is not","to be used as the ``expiration_time``. This callable will be called whenever the","values using the same values it returns to the calling function. A correct","region_invalidator: Optional. Override default invalidation strategy with custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded::","this key against the cache. When the dogpile lock cannot be acquired, the","use cases include \"cache the result until the end of the day, week","signature, one which takes a simple list of keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`,","the same mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\"k1\", \"k2\", \"k3\") ...a ``refresh()`` method,","arguments on Python 2.x, the ``unicode()`` builtin can be substituted, but note this","but can be accessed via the ``.name`` parameter, helpful for configuring a region","import PluginLoader, memoized_property, coerce_string_conf from .util import function_key_generator, function_multi_key_generator from .api import NO_VALUE,","- value.metadata[\"ct\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\"ct\"]): return NO_VALUE else: return","namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \"\"\"A function decorator that will cache multiple","version \"\"\" orig_key = key if self.key_mangler: key = self.key_mangler(key) def get_value(): value","``invalidate()`` the same arguments you'd pass to the function itself to represent a","fname + \"_\".join(str(s) for s in arg) return generate_key region = make_region( function_key_generator","key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw): key = key_generator(*arg, **kw) self.set(key, value)","self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and","a ProxyBackend instance or class and wraps the attached backend. ''' # if","is not None: return mutex else: return self._LockWrapper() def invalidate(self, hard=True): \"\"\"Invalidate this","Passing the flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get`","will override the normal expiration time. May be specified as a callable, taking","mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of the function with","soft mode. \"\"\" raise NotImplementedError() def was_hard_invalidated(self): \"\"\"Indicate the region was invalidated in","backend. :param name: Optional, a string name for the region. This isn't used","means the provided async_creation_runner callable implements. By default the async_creation_runner is disabled and","detect cached values from a previous, backwards-incompatible version. \"\"\" class RegionInvalidationStrategy(object): \"\"\"Region invalidation","= self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for wrapper in reversed(wrap):","ignore_expiration: if ``True``, the value is returned from the cache if present, regardless","6) The above example is equivalent to calling ``generate_something(5, 6)``, if the function","optional string argument which will be established as part of the cache key.","keys will not be cached. :param to_str: callable, will be called on each","cache backend will be replaced. Without this flag, an exception is raised if","called on each function argument in order to convert to a string. Defaults","list of keys. For example:: def my_multi_key_generator(namespace, fn, **kw): namespace = fn.__name__ +","in keys] finally: for mutex in mutexes.values(): mutex.release() def _value(self, value): \"\"\"Return a","v in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \"\"\"Remove a value from the cache.","using a key derived from the function itself and its arguments. The decorator","backwards compatible key_generator = function_key_generator(namespace, fn) else: key_generator = function_key_generator( namespace, fn, to_str=to_str)","region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, }","system works by setting a current timestamp (using ``time.time()``) representing the \"minimum creation","the constructor of the :class:`.CacheBackend` in use, though is typically a dictionary. :param","is needed when using a backend such as bsddb or dbm under Python","simulate one anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k],","on the given arguments. Such as:: def my_key_generator(namespace, fn, **kw): fname = fn.__name__","is passed to ``creator()``, and ``creator()`` should return the generated values as a","making the decorator suitable (with caveats) for use with instance or class methods.","callable function which will receive each value returned by the \"creator\", and will","instances, each of which will be applied in a chain to ultimately wrap","``NO_VALUE``. ``NO_VALUE`` evaluates to False, but is separate from ``None`` to distinguish between","None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self, orig_key, creator, mutex) else: async_creator","for function # decorators, but not yet for actual caching # later, when","method. The structure of this function should be two levels: given the data","mode. \"\"\" raise NotImplementedError() def was_hard_invalidated(self): \"\"\"Indicate the region was invalidated in hard","callable, taking no arguments, that returns a value to be used as the","returned, but isn't cached. E.g.:: def dont_cache_none(value): return value is not None value","from __future__ import with_statement from .. import Lock, NeedRegenerationException from ..util import NameRegistry","the name of the :class:`.CacheBackend` to use, and is resolved by loading the","[values[orig_to_mangled[k]].payload for k in keys] finally: for mutex in mutexes.values(): mutex.release() def _value(self,","that value:: newvalue = generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added ``refresh()`` method to","async_creation_runner, new values can be created in a background thread like so:: import",".. versionadded:: 0.5.0 \"\"\" if not mapping: return if self.key_mangler: mapping = dict((",":meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string argument which will be established as part of","my_multi_key_generator(namespace, fn, **kw): namespace = fn.__name__ + (namespace or '') def generate_keys(*args): return","= coerce_string_conf(config_dict) return self.configure( config_dict[\"%sbackend\" % prefix], expiration_time=config_dict.get( \"%sexpiration_time\" % prefix, None), _config_argument_dict=config_dict,","Similar to ``set()`` is ``refresh()``. This attribute will invoke the decorated function and","unconditionally. The method also interprets the cached value in terms of the current","region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \"\"\" def invalidate(self, hard=True):","``None`` to distinguish between a cached value of ``None``. By default, the configured","it's typical for a key to be a string, it is ultimately passed","\"\"\"Return multiple values from the cache, based on the given keys. Returns values","keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload if","import compat import time import datetime from numbers import Number from functools import","on a sequence of keys. The behavior for generation of values based on","keys, those keys will not be cached. :param to_str: callable, will be called","in hard mode. :return: Boolean. True if region was invalidated in hard mode.",".util import function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue from .proxy import ProxyBackend","there is a stale value present in the cache. It will be passed","'') def generate_keys(*args): return [namespace + ':' + str(a) for a in args]","particular cache backend. :param name: Optional, a string name for the region. This","generate_something(*keys): return [ somedatabase.query(key) for key in keys ] The decorated function can","Used by dogpile.core:Lock when appropriate ''' def runner(): try: value = creator() cache.set(somekey,","= region_invalidator return self def wrap(self, proxy): ''' Takes a ProxyBackend instance or","should return list of keys. For example:: def my_multi_key_generator(namespace, fn, **kw): namespace =","value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\"ct\"])): raise NeedRegenerationException() ct = value.metadata[\"ct\"] if self.region_invalidator.is_soft_invalidated(ct):","method also interprets the cached value in terms of the current \"invalidation\" time","value_fn(value): if value is NO_VALUE: return value elif expiration_time is not None and","if ``True``, the decorated function should return its result as a dictionary of","given a data creation function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method. The","\"two\", \"three\"]) To convert values to a dictionary, use ``zip()``:: keys = [\"one\",","in order to convert to a string. Defaults to ``str()``. If the function","\"\"\"A function decorator that will cache multiple return values from the function using","def invalidate(self, hard=True): \"\"\"Region invalidation. :class:`.CacheRegion` propagated call. The default invalidation system works","can't, it means a different thread or process is already running a creation","is also provided with a ``set()`` method, which here accepts a mapping of","return generate_key region = make_region( function_key_generator = my_key_generator ).configure( \"dogpile.cache.dbm\", expiration_time=300, arguments={ \"filename\":\"file.dbm\"","= self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \"\"\"Remove multiple values from the cache. This","from the cache, based on the given key. If the value is not","function itself and its arguments. The decorator internally makes use of the :meth:`.CacheRegion.get_or_create`","= key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values = fn(*arg) if","should be two levels: given the data creation function, return a new function","to :meth:`.CacheRegion.configure` to override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated","self.delete_multi(keys) def set_(mapping): keys = list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for","the string length is fixed. To disable all key mangling, set to ``False``.","was invalidated. :return: Boolean. True if ``timestamp`` is older than the last region","While it's typical for a key to be a string, it is ultimately","0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" def get_value(key): value = values.get(key, NO_VALUE) if","called whenever the decorated function itself is called, in caching or retrieving. Thus,","to use, and is resolved by loading the class from the ``dogpile.cache`` entrypoint.","async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, } ) Remember that","which provides for invalidation of the value. Pass to ``invalidate()`` the same arguments","my_data() .. seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` - optional gen that","key\" given a data creation function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method.","time. May be specified as a callable, taking no arguments, that returns a","keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\ else expiration_time if asdict: def dict_create(*keys):","versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \"\"\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is","of this function should be two levels: given the data creation function, return","None: return mutex else: return self._LockWrapper() def invalidate(self, hard=True): \"\"\"Invalidate this :class:`.CacheRegion`. The","False, the value is still returned, but isn't cached. E.g.:: def dont_cache_none(value): return","mutex and is responsible releasing that mutex when finished. This can be used","the retrieved value versus the current time (as reported by ``time.time()``). If stale,","namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \"\"\"A function decorator that will cache the return","may not be used to recreate the value and persist the newly generated","%s. \" \"Specify replace_existing_backend=True to replace.\" % self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict:","fn return decorate return decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type,","\"hard\" and \"soft\" invalidation options. With \"hard\" invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate","region was invalidated in hard mode. :return: Boolean. True if region was invalidated","if not keys: return [] if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys))","exception from ..util import PluginLoader, memoized_property, coerce_string_conf from .util import function_key_generator, function_multi_key_generator from","to determine if it was invalidated. :return: Boolean. True if ``timestamp`` is older","the value ``3`` as the value to be cached. .. versionadded:: 0.4.1 Added","value.metadata[\"ct\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\"ct\"]): return NO_VALUE else: return value","method, which will return values based on the given arguments:: values = generate_something.get(\"k1\",","is a convenience method for :meth:`.CacheRegion.set` which will store a given value directly","the decorated function is missing keys, those keys will not be cached. :param","similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of the function with the","value is not present, the method returns the token ``NO_VALUE``. ``NO_VALUE`` evaluates to","key_generator(*arg, **kw) return self.get(key) def refresh(*arg, **kw): key = key_generator(*arg, **kw) value =","a sequence of cached values based on a sequence of keys. The behavior","the :meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not** the :meth:`.CacheRegion.get` method) will call upon the","a cached value based on the given key. If the value does not","if not None. To set no expiration, use the value -1. :param should_cache_fn:","safely) .. versionadded:: 0.5.0 \"\"\" if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys))","decorator will produce a list of cache keys using a mechanism similar to","it was invalidated. :return: Boolean. True if ``timestamp`` is older than the last",":class:`.CacheBackend` to use, and is resolved by loading the class from the ``dogpile.cache``","wraps import threading _backend_loader = PluginLoader(\"dogpile.cache\") register_backend = _backend_loader.register from . import backends","a long-running queue, or a task manager system like Celery. For a specific","invalidation strategy with custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \"\"\" if \"backend\"","same arguments you'd pass to the function itself to represent a particular value::","from functools import wraps import threading _backend_loader = PluginLoader(\"dogpile.cache\") register_backend = _backend_loader.register from","class methods. Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\"foo\") def one(self, a, b): return","decorate return decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \"\"\"A","config file. :param function_key_generator: Optional. A function that will produce a \"cache key\"","determine if it was soft invalidated. :return: Boolean. True if ``timestamp`` is older","generate_keys :param key_mangler: Function which will be used on all incoming keys before","previous, backwards-incompatible version. \"\"\" class RegionInvalidationStrategy(object): \"\"\"Region invalidation strategy interface Implement this interface","thread, a long-running queue, or a task manager system like Celery. For a","for key in keys ] The decorated function can be called normally. The","def release(self): self.lock.release() def _create_mutex(self, key): mutex = self.backend.get_mutex(key) if mutex is not","later points in the future by way of, for example, a background thread,","this can be used to determine a *dynamic* expiration time for the cached","The method supports both \"hard\" and \"soft\" invalidation options. With \"hard\" invalidation, :meth:`.CacheRegion.get_or_create`","else: self._soft_invalidated = time.time() self._hard_invalidated = None def is_invalidated(self, timestamp): return ((self._soft_invalidated and","considered to be expired based on its creation time, the given creation function","when using a backend such as bsddb or dbm under Python 2.x in","retrieved value versus the current time (as reported by ``time.time()``). If stale, the","backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload if value","The above example is equivalent to calling ``generate_something(5, 6)``, if the function were","this timestamp is considered to be stale. It does not affect the data","and the arguments passed to it. This method is the \"multiple key\" analogue","a value as returned by the creator, and only if it returns True","separate from ``None`` to distinguish between a cached value of ``None``. By default,","region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \"\"\" def invalidate(self, hard=True): \"\"\"Region invalidation.","A list of :class:`.ProxyBackend` classes and/or instances, each of which will be applied","keys. :param async_creation_runner: A callable that, when specified, will be passed to and","creation function for this key against the cache. When the dogpile lock cannot","as part of the cache key. This may be needed to disambiguate functions","as:: def my_key_generator(namespace, fn, **kw): fname = fn.__name__ def generate_key(*arg): return namespace +","numbers import Number from functools import wraps import threading _backend_loader = PluginLoader(\"dogpile.cache\") register_backend","by ``time.time()``). If stale, the cached value is ignored and the ``NO_VALUE`` token","string name for the region. This isn't used internally but can be accessed","of ``False``, the decorated function should return its result as a list of",".. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \"\"\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is None: function_multi_key_generator","previous value is available, that value is returned immediately without blocking. If the","NeedRegenerationException() ct = value.metadata[\"ct\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time - .0001","use of the :meth:`.CacheRegion.get_or_create` method to access the cache and conditionally call the","on if the *dogpile lock* can be acquired or not. If it can't,","invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw): key =","stale, the cached value is ignored and the ``NO_VALUE`` token is returned. Passing","invalidate(self, hard=None): if hard: self._soft_invalidated = None self._hard_invalidated = time.time() else: self._soft_invalidated =","\"cache.memcached.backend\":\"dogpile.cache.pylibmc\", \"cache.memcached.arguments.url\":\"127.0.0.1, 10.0.0.1\", } local_region.configure_from_config(myconfig, \"cache.local.\") memcached_region.configure_from_config(myconfig, \"cache.memcached.\") \"\"\" config_dict = coerce_string_conf(config_dict) return","is the SHA1 mangler found at :func:`.sha1_mangle_key` which coerces keys into a SHA1","invalidation time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method","accessed via the ``.name`` parameter, helpful for configuring a region from a config","value is available, that value is returned immediately without blocking. If the :meth:`.invalidate`","the result until the end of the day, week or time period\" and","(as reported by ``time.time()``). If stale, the cached value is ignored and the","versionadded:: 0.3.0 \"\"\" if self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key) value =","expiration_time=None, ignore_expiration=False): \"\"\"Return a value from the cache, based on the given key.","set by the :meth:`.invalidate` method. If a value is present, but its creation","result as a list of values, and the final result of calling the","\"\"\"Check timestamp to determine if it was hard invalidated. :return: Boolean. True if","not None value = region.get_or_create(\"some key\", create_value, should_cache_fn=dont_cache_none) Above, the function returns the","prefix): \"\"\"Configure from a configuration dictionary and a prefix. Example:: local_region = make_region()","value:: generate_something.invalidate(5, 6) Another attribute ``set()`` is added to provide extra caching possibilities","self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \"\"\"A front end to a particular cache backend.","args] return generate_keys :param key_mangler: Function which will be used on all incoming","self.key_mangler: key = self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \"\"\"Remove multiple values from the","= self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result = dict( (k, v) for k,","that the string length is fixed. To disable all key mangling, set to","def __init__(self, region): self.region = region # ... # ... region = CacheRegion()","value else: if expiration_time is None: expiration_time = self.expiration_time current_time = time.time() def","different thread or process is already running a creation function for this key","as a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time`` may be optionally passed as","that will cache multiple return values from the function using a sequence of","override the normal expiration time. May be passed as an integer or a","cache key above for ``MyClass().one(3, 4)`` will again produce the same cache key","It's not consulted outside this function, so in fact can be of any","also be a list. When ``asdict==True`` if the dictionary returned by the decorated","will be called whenever the decorated function itself is called, in caching or","generate_key(*arg): return namespace + \"_\" + fname + \"_\".join(str(s) for s in arg)","be of any form. For example, it can be passed as a tuple,","Celery. For a specific example using async_creation_runner, new values can be created in",") The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside this","my_function(a, b, **kw): return my_data() .. seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator`","available, that value is returned immediately without blocking. If the :meth:`.invalidate` method has","supersede that configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.3.0 :param ignore_expiration: if","ignore_expiration) return [ value.payload if value is not NO_VALUE else value for value","if ignore_expiration: return lambda value: value else: if expiration_time is None: expiration_time =","arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`.","called with that subset of arguments. The returned result is a list:: result","the \"creator\", and will then return True or False, indicating if the value","\"\"\"Remove a value from the cache. This operation is idempotent (can be called","the token ``NO_VALUE``. ``NO_VALUE`` evaluates to False, but is separate from ``None`` to","the same name within the same module, as can occur when decorating instance","for orig_key, mangled_key in orig_to_mangled.items(): with Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda","decorator that will cache the return value of the function using a key","to generate a new value, or will wait until the lock is released","versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks the value's creation time against the expiration time,","value.metadata[\"ct\"]): return NO_VALUE else: return value return value_fn def get_multi(self, keys, expiration_time=None, ignore_expiration=False):","so that the string length is fixed. To disable all key mangling, set","corresponds to that of :meth:`.Region.get_or_create`, with the exception that the ``creator()`` function may","optional callable function which will receive each value returned by the \"creator\", and","a particular value:: generate_something.invalidate(5, 6) Another attribute ``set()`` is added to provide extra","caveats) for use with instance or class methods. Given the example:: class MyClass(object):","provided async_creation_runner callable implements. By default the async_creation_runner is disabled and is set","to represent a particular value:: generate_something.invalidate(5, 6) Another attribute ``set()`` is added to","the final result of calling the decorated function will also be a dictionary.","Optional. The structure here is passed directly to the constructor of the :class:`.CacheBackend`","of the same name within the same module, as can occur when decorating","for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return self def","value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands a 0 here as # \"the","is used normally to disambiguate two functions of the same name within the","part of the cache key. This may be needed to disambiguate functions of","region.get_multi([\"one\", \"two\", \"three\"]) To convert values to a dictionary, use ``zip()``:: keys =",":return: Boolean. True if ``timestamp`` is older than the last region invalidation time","under the given key.\"\"\" if self.key_mangler: key = self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self,","mapping): \"\"\"Place new values in the cache under the given keys. .. versionadded::","key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \"\"\"A","= generate_something(\"key1\", \"key2\", \"key3\") The decorator internally makes use of the :meth:`.CacheRegion.get_or_create_multi` method","was_soft_invalidated(self): \"\"\"Indicate the region was invalidated in soft mode. :return: Boolean. True if","\"k2\", \"k3\") .. versionadded:: 0.5.3 Added ``get()`` method to decorated function. Parameters passed","This isn't used internally but can be accessed via the ``.name`` parameter, helpful","means a different thread or process is already running a creation function for","self._soft_invalidated = None self._hard_invalidated = time.time() else: self._soft_invalidated = time.time() self._hard_invalidated = None","established as part of each cache key. :param expiration_time: if not None, will","and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \"This region is already \" \"configured with backend:","should_cache_fn=None): \"\"\"Return a cached value based on the given key. If the value","cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \"\"\"A function decorator that will cache","If left at its default value of ``False``, the decorated function should return","not exist or is considered to be expired based on its creation time,","mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \"\"\"Remove a value from the cache. This operation","that subset of arguments. The returned result is a list:: result = generate_something(\"key1\",","to be cached is passed as the first argument, and the arguments which","self._soft_invalidated) or (self._hard_invalidated and timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self,","in soft mode. \"\"\" raise NotImplementedError() def was_hard_invalidated(self): \"\"\"Indicate the region was invalidated","self._LockWrapper() def invalidate(self, hard=True): \"\"\"Invalidate this :class:`.CacheRegion`. The default invalidation system works by","versionadded:: 0.5.0 \"\"\" if not keys: return [] if self.key_mangler: keys = list(map(lambda","it can be passed as a tuple, used to specify arguments to pluck","return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values = fn(*arg) if asdict: self.set_multi(","(with caveats) for use with instance or class methods. Given the example:: class","decorator def make_region(*arg, **kw): \"\"\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough","the expiration time already configured on this :class:`.CacheRegion` if not None. To set","no previous value is available, until the lock is released and a new","for. With \"soft\" invalidation, subsequent getters will return the \"old\" value until the","used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw): return my_data() .. seealso:: :func:`.function_key_generator`","invalidate(self, hard=True): \"\"\"Invalidate this :class:`.CacheRegion`. The default invalidation system works by setting a","0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \"\"\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is None:","refresh decorate.get = get decorate.original = fn return decorate return decorator def cache_multi_on_arguments(","function which accepts a sequence of keys and returns a sequence of new","False, indicating if the value should actually be cached or not. If it","will produce a cache key as follows:: myapp.tools:one|foo|3 4 The key generator will","The structure of this function should be two levels: given the data creation","method returns the token ``NO_VALUE``. ``NO_VALUE`` evaluates to False, but is separate from","time already configured on this :class:`.CacheRegion` if not None. To set no expiration,","returns False, the value is still returned, but isn't cached. E.g.:: def dont_cache_none(value):","def get_multi(self, keys, expiration_time=None, ignore_expiration=False): \"\"\"Return multiple values from the cache, based on","being declared. :param expiration_time: if not None, will override the normal expiration time.","is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \"\"\"A front","the value to be cached. .. versionadded:: 0.4.1 Added ``set()`` method to decorated","versionadded:: 0.4.3 :param to_str: callable, will be called on each function argument in","@wraps(fn) def decorate(*arg, **kw): key = key_generator(*arg, **kw) @wraps(fn) def creator(): return fn(*arg,","\"value1\", \"k2\": \"value2\", \"k3\": \"value3\"}) ...an ``invalidate()`` method, which has the effect of","key, creator, expiration_time=None, should_cache_fn=None): \"\"\"Return a cached value based on the given key.","on the :class:`.CacheRegion` itself. .. versionadded:: 0.3.0 :param ignore_expiration: if ``True``, the value","timestamp to determine if it was invalidated. :return: Boolean. True if ``timestamp`` is","return its result as a dictionary of keys->values, and the final result of","affect the data in the cache in any way, and is also local","no arguments, that returns a value to be used as the ``expiration_time``. This","creator(*keys_to_create): return fn(*[key_lookup[k] for k in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\","ProxyBackend\" % type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self, key): return self._lock_registry.get(key) class _LockWrapper(object):","..util import compat import time import datetime from numbers import Number from functools","The behavior for generation of values based on keys corresponds to that of",":func:`.function_key_generator`. :param namespace: optional string argument which will be established as part of","replaced on a per-region basis using the ``function_key_generator`` argument present on :func:`.make_region` and",":param async_creation_runner: A callable that, when specified, will be passed to and called","that a return+regen will be invoked. .. versionadded:: 0.5.1 \"\"\" self.region_invalidator.invalidate(hard) def configure_from_config(self,","no associated value will always block; async_creator will not be invoked. However, subsequent","the name of the function, the module name for the function, the arguments","value does not exist or is considered to be expired based on its","will be used on all incoming keys before passing to the backend. Defaults","with the exception that the ``creator()`` function may be asked to generate any","to disambiguate functions of the same name within the same source file, such","k, v in zip(keys_to_get, new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k,","@region.cache_on_arguments(namespace=\"foo\") def one(self, a, b): return a + b The cache key above","front end to a particular cache backend. :param name: Optional, a string name","if the dictionary returned by the decorated function is missing keys, those keys","k in namespace] + [str(x) for x in arg] ) return generate_key Where","is invalidated in soft mode. \"\"\" raise NotImplementedError() def is_invalidated(self, timestamp): \"\"\"Check timestamp","value to be used as the ``expiration_time``. This callable will be called whenever","argument present on :func:`.make_region` and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`. :param namespace: optional","such as those associated with classes - note that the decorator itself can't","retrieving. Thus, this can be used to determine a *dynamic* expiration time for","if value is not NO_VALUE else value for value in ( _unexpired_value_fn(value) for","of values based on keys corresponds to that of :meth:`.Region.get_or_create`, with the exception","or alternatively the expiration time supplied by the ``expiration_time`` argument, is tested against","timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \"\"\"A front end to a particular","values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k in keys] finally: for","the same arguments you'd pass to the function itself to represent a particular","namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys = arg keys = key_generator(*arg,","refresh decorate.get = get return decorate return decorator def make_region(*arg, **kw): \"\"\"Instantiate a","lock to generate a new value, or will wait until the lock is","if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self, orig_key, creator, mutex) else: async_creator =","if present. :param creator: function which creates a new value. :param expiration_time: optional","get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass try: if mutexes: # sort","value from the cache, based on the given key. If the value is","Whether or not the function is used depends on if the *dogpile lock*","decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys =","time.time() def is_invalidated(self, timestamp): return (self._invalidated is not None and timestamp < self._invalidated)","= None mutexes = {} sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k)","``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python class declaration mechanics otherwise prevent the decorator","decorator itself can't see the parent class on a function as the class","def dict_create(*keys): d_values = creator(*keys) return [ d_values.get(key_lookup[k], NO_VALUE) for k in keys]","= make_region() # regions are ready to use for function # decorators, but","if ``True``, the value is returned from the cache if present, regardless of","hard: if True, cache values will all require immediate regeneration; dogpile logic won't","value) def get(*arg, **kw): key = key_generator(*arg, **kw) return self.get(key) def refresh(*arg, **kw):",":meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not** the :meth:`.CacheRegion.get` method) will call upon the value","setting a current timestamp (using ``time.time()``) representing the \"minimum creation time\" for a","the last generation. :param arguments: Optional. The structure here is passed directly to","= make_region() memcached_region = make_region() # regions are ready to use for function","used to recreate the value and persist the newly generated value in the","and conditionally call the function. See that method for additional behavioral details. Unlike","time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies","parameter, helpful for configuring a region from a config file. :param function_key_generator: Optional.","returned immediately without blocking. If the :meth:`.invalidate` method has been called, and the",".. versionadded:: 0.4.3 :param to_str: callable, will be called on each function argument",":meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list of keys. For example:: def my_multi_key_generator(namespace, fn,","region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that wish to have access to the :class:`.CacheRegion` itself should","in orig_to_mangled.items(): with Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex)","token is returned. Passing the flag ``ignore_expiration=True`` bypasses the expiration time check. ..","a config file. :param function_key_generator: Optional. A function that will produce a \"cache","timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__',","{ \"cache.local.backend\":\"dogpile.cache.dbm\", \"cache.local.arguments.filename\":\"/path/to/dbmfile.dbm\", \"cache.memcached.backend\":\"dogpile.cache.pylibmc\", \"cache.memcached.arguments.url\":\"127.0.0.1, 10.0.0.1\", } local_region.configure_from_config(myconfig, \"cache.local.\") memcached_region.configure_from_config(myconfig, \"cache.memcached.\") \"\"\" config_dict","Defaults to ``None``, in which case the key mangling function recommended by the","Support for the :meth:`.CacheRegion.invalidate` method. :param key: Key to be retrieved. While it's","be of any type recognized by the backend or by the key_mangler function,","value) finally: mutex.release() thread = threading.Thread(target=runner) thread.start() region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached',","name ``self`` is skipped. The ``namespace`` parameter is optional, and is used normally","value. :param expiration_time: optional expiration time which will overide the expiration time already","Boolean. True if ``timestamp`` is older than the last region invalidation time and","expiration time supplied by the ``expiration_time`` argument, is tested against the creation time","mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in orig_to_mangled.items(): with Lock( self._mutex(mangled_key),","pass implementation instance to :meth:`.CacheRegion.configure` to override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy):","the key_mangler function, if present. :param creator: function which creates a new value.","return self.get(key) def refresh(*arg, **kw): key = key_generator(*arg, **kw) value = fn(*arg, **kw)","if self.key_mangler: key = self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \"\"\"Remove multiple values from","a function as the class is being declared. :param expiration_time: if not None,","the cached value in terms of the current \"invalidation\" time as set by","key = self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \"\"\"Remove multiple values from the cache.","get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values =","values)) ) return values decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh","timestamp is considered to be stale. It does not affect the data in","``NO_VALUE`` token. ``NO_VALUE`` evaluates to False, but is separate from ``None`` to distinguish","**kw) value = fn(*arg, **kw) self.set(key, value) return value decorate.set = set_ decorate.invalidate","_config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \"\"\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is","return value def get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \"\"\"Return a sequence of","``generate_something(5, 6)``, if the function were to produce the value ``3`` as the","is the name of the :class:`.CacheBackend` to use, and is resolved by loading","was invalidated in hard mode. :return: Boolean. True if region was invalidated in","= key_generator(*arg, **kw) self.set(key, value) def get(*arg, **kw): key = key_generator(*arg, **kw) return","to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key) for key","``ignore_expiration=True`` bypasses the expiration time check. .. versionadded:: 0.5.0 \"\"\" if not keys:","for generation of values based on keys corresponds to that of :meth:`.Region.get_or_create`, with","Boolean. True if region was invalidated in soft mode. \"\"\" raise NotImplementedError() def","ProxyBackend): raise TypeError(\"Type %s is not a valid ProxyBackend\" % type(proxy)) self.backend =","E.g.:: values = region.get_multi([\"one\", \"two\", \"three\"]) To convert values to a dictionary, use","} ) The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside","if expiration_time == -1: expiration_time = None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner(","deleting the given sequence of keys using the same mechanism as that of","to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable,","which will supersede that configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.3.0 :param","be used to determine a *dynamic* expiration time for the cached function result.","itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" expiration_time_is_callable = compat.callable(expiration_time) if","region was invalidated in soft mode. \"\"\" raise NotImplementedError() def was_hard_invalidated(self): \"\"\"Indicate the","new_values = creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k], self._value(v)) for k, v in zip(keys_to_get,","timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated and timestamp < self._hard_invalidated))","time so that a return+regen will be invoked. .. versionadded:: 0.5.1 \"\"\" self.region_invalidator.invalidate(hard)","cache the return value of the function using a key derived from the","and :meth:`.CacheRegion.get` methods. The method supports both \"hard\" and \"soft\" invalidation options. With","timestamp < self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return","May be specified as a callable, taking no arguments, that returns a value","decorate.refresh = refresh decorate.get = get return decorate return decorator def make_region(*arg, **kw):","function will also be a dictionary. If left at its default value of","key_generator(*arg) values = fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for a in arg]))","set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get return decorate return","in backend_values ) ] def get_or_create( self, key, creator, expiration_time=None, should_cache_fn=None): \"\"\"Return a","self._lock_registry.get(key) class _LockWrapper(object): \"\"\"weakref-capable wrapper for threading.Lock\"\"\" def __init__(self): self.lock = threading.Lock() def","is None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \"Non-None expiration time required \" \"for soft","generated or need regeneration will be assembled into a new argument list, and","on all incoming keys before passing to the backend. Defaults to ``None``, in","specific example using async_creation_runner, new values can be created in a background thread","\"\"\" def get_value(key): value = values.get(key, NO_VALUE) if (value is NO_VALUE or value.metadata['v']","function will supersede the one configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5","receive each value returned by the \"creator\", and will then return True or","will receive the value returned by the \"creator\", and will then return True","expiration_time if asdict: def dict_create(*keys): d_values = creator(*keys) return [ d_values.get(key_lookup[k], NO_VALUE) for","< self._soft_invalidated) or (self._hard_invalidated and timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def","last region invalidation time and region is invalidated in soft mode. \"\"\" raise","NotImplementedError() def was_hard_invalidated(self): \"\"\"Indicate the region was invalidated in hard mode. :return: Boolean.","return self.lock.acquire(wait) def release(self): self.lock.release() def _create_mutex(self, key): mutex = self.backend.get_mutex(key) if mutex","on this region.\") @property def is_configured(self): \"\"\"Return True if the backend has been","the backend has been configured via the :meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1","all getters will wait for. With \"soft\" invalidation, subsequent getters will return the","be generated is passed to ``creator()``, and ``creator()`` should return the generated values","as well as the :meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not** the :meth:`.CacheRegion.get` method) will","won't be used. If False, the creation time of existing values will be","override the normal expiration time. May be specified as a callable, taking no","the parent class on a function as the class is being declared. :param","expiration_time_is_callable \\ else expiration_time if asdict: def dict_create(*keys): d_values = creator(*keys) return [","(self._hard_invalidated and timestamp < self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return","NO_VALUE: return False elif not should_cache_fn: return True else: return should_cache_fn(value) result =","It will then consult the cache using the same mechanism as that of","(self._soft_invalidated and timestamp < self._soft_invalidated) The custom implementation is injected into a :class:`.CacheRegion`","Once set, the invalidation time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get`","timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is False def is_soft_invalidated(self,","\"\"\" if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self,","require key mangling before reaching the cache. .. versionadded:: 0.5.0 :param function_key_generator: a","invalidation. :class:`.CacheRegion` propagated call. The default invalidation system works by setting a current","keys = list(map(lambda key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time,","use for function # decorators, but not yet for actual caching # later,",":param asdict: if ``True``, the decorated function should return its result as a","and is responsible releasing that mutex when finished. This can be used to","should return its result as a list of values, and the final result","is skipped. The ``namespace`` parameter is optional, and is used normally to disambiguate","name of the function with the optional namespace and with the string form","use the value -1. :param should_cache_fn: optional callable function which will receive the","if not should_cache_fn or \\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\"ct\"] if expiration_time",":meth:`.Region.set_multi` to get and set values from the backend. If you are using","to prevent deadlocks. # though haven't been able to simulate one anyway. keys_to_get","haven't been able to simulate one anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get)","not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for k, v in values_w_created.items() if","be passed as an integer number of seconds, or as a ``datetime.timedelta`` value.","0.5.1 \"\"\" return 'backend' in self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False): \"\"\"Return a","it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list of keys. For example::","the value is not present, the method returns the token ``NO_VALUE``. ``NO_VALUE`` evaluates","its creation time, the given creation function may or may not be used","prefix], expiration_time=config_dict.get( \"%sexpiration_time\" % prefix, None), _config_argument_dict=config_dict, _config_prefix=\"%sarguments.\" % prefix, wrap=config_dict.get( \"%swrap\" %","before being optionally processed by the key_mangler function, so can be of any","If the :meth:`.invalidate` method has been called, and the retrieved value's timestamp is","note this will produce unicode cache keys which may require key mangling before","itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \"\"\" expiration_time_is_callable = compat.callable(expiration_time) if","the cache with the new value, as well as returning that value:: newvalue","= compat.callable(expiration_time) if function_multi_key_generator is None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator =","refresh(*arg): keys = key_generator(*arg) values = fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for","my_key_generator ).configure( \"dogpile.cache.dbm\", expiration_time=300, arguments={ \"filename\":\"file.dbm\" } ) The ``namespace`` is that passed","mechanics otherwise prevent the decorator from having awareness of the ``MyClass`` and ``MyOtherClass``","if not issubclass(type(proxy), ProxyBackend): raise TypeError(\"Type %s is not a valid ProxyBackend\" %","arg])) ) return values else: self.set_multi( dict(zip(keys, values)) ) return values decorate.set =","\"\"\"Return a value from the cache, based on the given key. If the","is None: expiration_time = self.expiration_time current_time = time.time() def value_fn(value): if value is","will call upon the value creation function after this time period has passed","``expiration_time`` may be passed as a callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to","will be pulled from the cache region unless a new value is needed::","= key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None,","a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time`` may be optionally passed as a","versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param key: Key to be retrieved.","return value.payload, 0 else: ct = value.metadata[\"ct\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() -","substituted, but note this will produce unicode cache keys which may require key","is available, that value is returned immediately without blocking. If the :meth:`.invalidate` method","new values can be created in a background thread like so:: import threading","self.key_mangler(k), self._value(v)) for k, v in mapping.items()) else: mapping = dict((k, self._value(v)) for","\"value2\", \"k3\": \"value3\"}) ...an ``invalidate()`` method, which has the effect of deleting the","self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return self def wrap(self, proxy): ''' Takes","else: result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result def invalidate(*arg): keys","receive the value returned by the \"creator\", and will then return True or","``False``. Another typical mangler is the built-in Python function ``str``, which can be","\"\"\" if not mapping: return if self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v)) for",":func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` - optional gen that also uses keyword","NotImplementedError() def was_soft_invalidated(self): \"\"\"Indicate the region was invalidated in soft mode. :return: Boolean.","backend. ''' # if we were passed a type rather than an instance","from the cache region unless a new value is needed:: result = generate_something(5,","e.g. # _has_value() will return False. return value.payload, 0 else: ct = value.metadata[\"ct\"]","self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \"\"\"Configure a :class:`.CacheRegion`.","needed to disambiguate functions of the same name within the same source file,","or timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap,","``asdict==True`` if the dictionary returned by the decorated function is missing keys, those","the function itself to represent a particular value:: generate_something.invalidate(5, 6) Another attribute ``set()``","same name within the same source file, such as those associated with classes","that of :meth:`.CacheRegion.get_multi` to retrieve all current values; the originally passed keys corresponding",") if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for k, v in","as the function is received by the decorator before it becomes an instance","with the string form of each key. It will then consult the cache","> expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\"ct\"]): return NO_VALUE else: return value return","else: key_generator = function_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key =","timestamp (using ``time.time()``) representing the \"minimum creation time\" for a value. Any retrieved","time value which will supersede that configured on the :class:`.CacheRegion` itself. .. versionadded::","\" \"for soft invalidation\") if expiration_time == -1: expiration_time = None mutexes =","return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return (self._hard_invalidated and timestamp < self._hard_invalidated) def was_soft_invalidated(self):","a new value available. If a previous value is available, that value is","with instance or class methods. Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\"foo\") def one(self,","(k, v) for k, v in zip(cache_keys, result) if v is not NO_VALUE)","or as a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time`` may be optionally passed","last region invalidation time. \"\"\" raise NotImplementedError() def was_soft_invalidated(self): \"\"\"Indicate the region was","previous value is available, until the lock is released and a new value","passed as the first argument, and the arguments which would normally be passed","time.time() def value_fn(value): if value is NO_VALUE: return value elif expiration_time is not","regeneration will be assembled into a new argument list, and the decorated function","using async_creation_runner, new values can be created in a background thread like so::","the ``expiration_time`` argument, is tested against the creation time of the retrieved value","a ``set()`` method, which here accepts a mapping of keys and values to","the data creation function, return a new function that generates the key based","backend has been configured via the :meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1 \"\"\"","= function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner","values can be created in a background thread like so:: import threading def","backend: %s. \" \"Specify replace_existing_backend=True to replace.\" % self.backend) backend_cls = _backend_loader.load(backend) if","time. May be passed as an integer or a callable. :param should_cache_fn: passed","values it returns to the calling function. A correct implementation of ``.set_multi()`` will","None mutexes = {} sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k) for","y) The decorated function can then be called normally, where data will be","value is unconditionally prevented from being returned. The method will attempt to acquire","The ``namespace`` parameter is optional, and is used normally to disambiguate two functions","for a value. Any retrieved value whose creation time is prior to this","the :class:`.CacheRegion` itself should construct the invalidator given the region as an argument::","for k, v in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k","b, **kw): return my_data() .. seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` -","hard=True): self._is_hard_invalidated = bool(hard) self._invalidated = time.time() def is_invalidated(self, timestamp): return (self._invalidated is","creates a new value. :param expiration_time: optional expiration time which will overide the","before it becomes an instance method. The function key generation can be entirely","the function, the arguments passed, as well as an optional \"namespace\" parameter in","be assembled into a new argument list, and the decorated function is then","def was_soft_invalidated(self): return self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp)","a configuration dictionary and a prefix. Example:: local_region = make_region() memcached_region = make_region()","will again produce the same cache key of ``myapp.tools:one|foo|3 4`` - the name","time, the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses the invalidation","= proxy.wrap(self.backend) def _mutex(self, key): return self._lock_registry.get(key) class _LockWrapper(object): \"\"\"weakref-capable wrapper for threading.Lock\"\"\"","attribute ``set()`` is added to provide extra caching possibilities relative to the function.","entirely replaced on a per-region basis using the ``function_key_generator`` argument present on :func:`.make_region`","instance or class and wraps the attached backend. ''' # if we were","def configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \"\"\"Configure","def was_hard_invalidated(self): \"\"\"Indicate the region was invalidated in hard mode. :return: Boolean. True","present, regardless of configured expiration times or whether or not :meth:`.invalidate` was called.","= dict(zip(keys, values)) Keys which aren't present in the list are returned as","invalidation system works by setting a current timestamp (using ``time.time()``) to consider all","self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \"\"\"A function","0.5.0 Added ``refresh()`` method to decorated function. Lastly, the ``get()`` method returns either","4`` - the name ``self`` is skipped. The ``namespace`` parameter is optional, and","get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \"\"\"Return a sequence of cached values based","will be used. A typical mangler is the SHA1 mangler found at :func:`.sha1_mangle_key`","key_generator(*arg, **kw) @wraps(fn) def creator(): return fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable","will block if no previous value is available, until the lock is released","cached value based on the given key. If the value does not exist","from the backend. If you are using a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies","to determine if it was hard invalidated. :return: Boolean. True if ``timestamp`` is","dictionary of keys->values, and the final result of calling the decorated function will","versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function using a","function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \"\"\"Construct a new :class:`.CacheRegion`.\"\"\" self.name = name self.function_key_generator =","may require key mangling before reaching the cache. .. versionadded:: 0.5.0 :param function_multi_key_generator:","self.key_mangler: key = self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping): \"\"\"Place new values in","__init__(self): self._soft_invalidated = None self._hard_invalidated = None def invalidate(self, hard=None): if hard: self._soft_invalidated","__init__(self): self._is_hard_invalidated = None self._invalidated = None def invalidate(self, hard=True): self._is_hard_invalidated = bool(hard)","def one(self, a, b): return a + b The cache key above for","None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \"Non-None expiration time required \" \"for soft invalidation\")","determine if it was hard invalidated. :return: Boolean. True if ``timestamp`` is older","called normally. The decorator will produce a list of cache keys using a","functools import wraps import threading _backend_loader = PluginLoader(\"dogpile.cache\") register_backend = _backend_loader.register from .","= self.key_mangler(key) value = self.backend.get(key) value = self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload def","initial argument of ``self`` or ``cls``, making the decorator suitable (with caveats) for","expiration_time: if not None, will override the normal expiration time. May be passed",".. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is None: function_key_generator","expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator","keys = key_generator(*arg) values = fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for a","``.set_multi()`` for newly generated values using the same values it returns to the","decorated function can be called normally. The decorator will produce a list of","time. \"\"\" raise NotImplementedError() def was_soft_invalidated(self): \"\"\"Indicate the region was invalidated in soft","the invalidation time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The","instance or class methods as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y):","MyInvalidator(RegionInvalidationStrategy): def __init__(self, region): self.region = region # ... # ... region =","is not a number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry","decorator might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw): return my_data()","datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time is not a number","value. .. versionadded 0.5.0 ``expiration_time`` may be optionally passed as a ``datetime.timedelta`` value.","strategies that wish to have access to the :class:`.CacheRegion` itself should construct the","by the decorated function is missing keys, those keys will not be cached.","key): mutex = self.backend.get_mutex(key) if mutex is not None: return mutex else: return","form of each key. It will then consult the cache using the same","**kw) return self.get(key) def refresh(*arg, **kw): key = key_generator(*arg, **kw) value = fn(*arg,","times or whether or not :meth:`.invalidate` was called. .. versionadded:: 0.3.0 \"\"\" if","fact can be of any form. For example, it can be passed as","0.5.7 :param region_invalidator: Optional. Override default invalidation strategy with custom implementation of :class:`.RegionInvalidationStrategy`.","passed to :meth:`.CacheRegion.get_or_create_multi`. This function is given a value as returned by the","releasing that mutex when finished. This can be used to defer the computation","the function should follow:: generate_something.set(3, 5, 6) The above example is equivalent to","seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi` -","a type rather than an instance then # initialize it. if type(proxy) ==","not yet for actual caching # later, when config is available myconfig =","above example is equivalent to calling ``generate_something(5, 6)``, if the function were to","new value available. If a previous value is available, that value is returned","not None and timestamp < self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is True def","[ d_values.get(key_lookup[k], NO_VALUE) for k in keys] def wrap_cache_fn(value): if value is NO_VALUE:","behavior for generation of values based on keys corresponds to that of :meth:`.Region.get_or_create`,",":param keys: Sequence of keys to be retrieved. :param creator: function which accepts","Defaults to ``str()``. If the function accepts non-ascii unicode arguments on Python 2.x,","= None def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated","but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list of keys. For","result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result = dict( (k, v) for","\"\"\"Place a new value in the cache under the given key.\"\"\" if self.key_mangler:","set_(mapping): keys = list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key","arguments:: values = generate_something.get(\"k1\", \"k2\", \"k3\") .. versionadded:: 0.5.3 Added ``get()`` method to","be cached or not. If it returns False, the value is still returned,","on a non-existent key, safely) .. versionadded:: 0.5.0 \"\"\" if self.key_mangler: keys =","mode. :return: Boolean. True if region was invalidated in soft mode. \"\"\" raise","to a particular cache backend. :param name: Optional, a string name for the","cached. .. versionadded:: 0.4.1 Added ``set()`` method to decorated function. Similar to ``set()``","key_generator(*arg, **kw) value = fn(*arg, **kw) self.set(key, value) return value decorate.set = set_","as value: return value def get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \"\"\"Return a","key with no associated value will always block; async_creator will not be invoked.","not. If it can't, it means a different thread or process is already","Python function ``str``, which can be used to convert non-string or Unicode keys","self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure(","CachedValue from .proxy import ProxyBackend from ..util import compat import time import datetime","be applied in a chain to ultimately wrap the original backend, so that","**kw): return my_data() .. seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` - optional","non-ascii unicode arguments on Python 2.x, the ``unicode()`` builtin can be substituted, but","value is None, it won't be cached. .. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments`","): \"\"\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned. :param backend: Required. This","get_multi(self, keys, expiration_time=None, ignore_expiration=False): \"\"\"Return multiple values from the cache, based on the","to acquire the dogpile lock to generate a new value, or will wait","the function. See that method for additional behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x,",":class:`.CacheRegion`. Once set, the invalidation time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and","where data will be pulled from the cache region unless a new value","**kw) self.set(key, value) def get(*arg, **kw): key = key_generator(*arg, **kw) return self.get(key) def","key_generator = function_key_generator(namespace, fn) else: key_generator = function_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def","return my_data() .. seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` - optional gen","value of the function using a key derived from the function itself and","function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def","use, and is resolved by loading the class from the ``dogpile.cache`` entrypoint. :param",":meth:`.CacheRegion.get_or_create` \"\"\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is None: function_key_generator = self.function_key_generator def","a callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This function is given a value","the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports both \"hard\" and \"soft\"","back before the expiration time so that a return+regen will be invoked. ..","True else: return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result =","arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method. The structure of this function should be",":param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable, will be","See that method for additional behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works","= key_generator(*arg) values = fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for a in","\" \"for soft invalidation\") if expiration_time == -1: expiration_time = None if self.async_creation_runner:","def set_(value, *arg, **kw): key = key_generator(*arg, **kw) self.set(key, value) def get(*arg, **kw):","import function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue from .proxy import ProxyBackend from","__init__(self, region): self.region = region # ... # ... region = CacheRegion() region","invalidated in soft mode. \"\"\" raise NotImplementedError() def was_hard_invalidated(self): \"\"\"Indicate the region was","0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True, the existing cache backend will","expiration_time is None: expiration_time = self.expiration_time if (expiration_time is None and self.region_invalidator.was_soft_invalidated()): raise","versionadded:: 0.5.1 \"\"\" return 'backend' in self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False): \"\"\"Return","used on all incoming keys before passing to the backend. Defaults to ``None``,","be retrieved. :param creator: function which accepts a sequence of keys and returns","else: if expiration_time is None: expiration_time = self.expiration_time current_time = time.time() def value_fn(value):","function. The default key generation will use the name of the function, the","logic won't be used. If False, the creation time of existing values will","0.5.0 :param function_multi_key_generator: a function that will produce a list of keys. This","timeout, wrap_cache_fn) result = dict( (k, v) for k, v in zip(cache_keys, result)","a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies values, take note this function invokes ``.set_multi()``","For a specific example using async_creation_runner, new values can be created in a","compat.string_type: # backwards compatible key_generator = function_key_generator(namespace, fn) else: key_generator = function_key_generator( namespace,","is returned. :param backend: Required. This is the name of the :class:`.CacheBackend` to","Optional. The expiration time passed to the dogpile system. May be passed as","proxy = proxy() if not issubclass(type(proxy), ProxyBackend): raise TypeError(\"Type %s is not a","if asdict: self.set_multi( dict(zip(keys, [values[a] for a in arg])) ) return values else:","soft mode. \"\"\" raise NotImplementedError() def is_invalidated(self, timestamp): \"\"\"Check timestamp to determine if","returned, but isn't cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" def","\"\"\"A function decorator that will cache the return value of the function using","expiration time check. .. versionadded:: 0.5.0 \"\"\" if not keys: return [] if","region_invalidator return self def wrap(self, proxy): ''' Takes a ProxyBackend instance or class","name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \"\"\"Construct a new :class:`.CacheRegion`.\"\"\" self.name = name","function # decorators, but not yet for actual caching # later, when config","method for additional behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x, y): return somedatabase.query(x, y)","\"soft\" invalidation, subsequent getters will return the \"old\" value until the new one","a function that will produce a \"cache key\". This function will supersede the","sort the keys, the idea is to prevent deadlocks. # though haven't been","retrieved. :param creator: function which accepts a sequence of keys and returns a","the cache. This operation is idempotent (can be called multiple times, or on","keys using a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of","used. If False, the creation time of existing values will be pushed back","keys)) ) def get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys =","finally: mutex.release() thread = threading.Thread(target=runner) thread.start() region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5,","pushed back before the expiration time so that a return+regen will be invoked.","this function should be two levels: given the data creation function, return a","invalidated. :return: Boolean. True if ``timestamp`` is older than the last region invalidation","fn, **kw): fname = fn.__name__ def generate_key(*arg): return namespace + \"_\" + fname","a task manager system like Celery. For a specific example using async_creation_runner, new","augmentation can be applied. .. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if","6) Another attribute ``set()`` is added to provide extra caching possibilities relative to","specified as a callable, taking no arguments, that returns a value to be","backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \"\"\"Configure a :class:`.CacheRegion`. The","key if self.key_mangler: key = self.key_mangler(key) def get_value(): value = self.backend.get(key) if (value","a cache key. Given a function ``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\"foo\") def","the new value, as well as returning that value:: newvalue = generate_something.refresh(5, 6)","on each function argument in order to convert to a string. Defaults to","function_multi_key_generator is None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace, fn,","the *dogpile lock* can be acquired or not. If it can't, it means","was_hard_invalidated(self): return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def","Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass try:","will store a given value directly without calling the decorated function. The value","cache and conditionally call the function. See that method for additional behavioral details.","callable function which will receive the value returned by the \"creator\", and will","the effect of deleting the given sequence of keys using the same mechanism","but its creation time is older than the current invalidation time, the ``NO_VALUE``","a mapping of keys and values to set in the cache:: generate_something.set({\"k1\": \"value1\",","cache. This operation is idempotent (can be called multiple times, or on a","coerce_string_conf(config_dict) return self.configure( config_dict[\"%sbackend\" % prefix], expiration_time=config_dict.get( \"%sexpiration_time\" % prefix, None), _config_argument_dict=config_dict, _config_prefix=\"%sarguments.\"","key. If the value is not present, the method returns the token ``NO_VALUE``.","class declaration mechanics otherwise prevent the decorator from having awareness of the ``MyClass``","also interprets the cached value in terms of the current \"invalidation\" time as","current invalidation time, the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses","supports both \"hard\" and \"soft\" invalidation options. With \"hard\" invalidation, :meth:`.CacheRegion.get_or_create` will force","self._value(value)) def set_multi(self, mapping): \"\"\"Place new values in the cache under the given","returns either the value cached for the given key, or the token ``NO_VALUE``","cache keys using a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name","from . import exception from ..util import PluginLoader, memoized_property, coerce_string_conf from .util import","\"two\", \"three\"] values = region.get_multi(keys) dictionary = dict(zip(keys, values)) Keys which aren't present","self.delete(key) def set_(value, *arg, **kw): key = key_generator(*arg, **kw) self.set(key, value) def get(*arg,","two levels: given the data creation function, return a new function that generates","however if the return value is None, it won't be cached. .. versionadded::","= key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw): key = key_generator(*arg, **kw) self.set(key,","older than the last call to :meth:`.invalidate`. :param key: Key to be retrieved.","return lambda value: value else: if expiration_time is None: expiration_time = self.expiration_time current_time","matching the keys given. E.g.:: values = region.get_multi([\"one\", \"two\", \"three\"]) To convert values","the value of create_value() if the cache is invalid, however if the return","\"Specify replace_existing_backend=True to replace.\" % self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend =","can be accessed via the ``.name`` parameter, helpful for configuring a region from","added to provide extra caching possibilities relative to the function. This is a","to ``function_key_generator`` parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list","NO_VALUE) else: result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result def invalidate(*arg):","\"cache.local.backend\":\"dogpile.cache.dbm\", \"cache.local.arguments.filename\":\"/path/to/dbmfile.dbm\", \"cache.memcached.backend\":\"dogpile.cache.pylibmc\", \"cache.memcached.arguments.url\":\"127.0.0.1, 10.0.0.1\", } local_region.configure_from_config(myconfig, \"cache.local.\") memcached_region.configure_from_config(myconfig, \"cache.memcached.\") \"\"\" config_dict =","of the value. Pass to ``invalidate()`` the same arguments you'd pass to the","Remember that the first request for a key with no associated value will","to decorated function. Similar to ``set()`` is ``refresh()``. This attribute will invoke the","wrap: Optional. A list of :class:`.ProxyBackend` classes and/or instances, each of which will","and is also local to this instance of :class:`.CacheRegion`. Once set, the invalidation","value is returned from the cache if present, regardless of configured expiration times","0.5.0 \"\"\" if not keys: return [] if self.key_mangler: keys = list(map(lambda key:","the method will block if no previous value is available, until the lock","no expiration, use the value -1. :param should_cache_fn: optional callable function which will","expiration_time=300, arguments={ \"filename\":\"file.dbm\" } ) The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's","new values in the cache under the given keys. .. versionadded:: 0.5.0 \"\"\"","compatible key_generator = function_key_generator(namespace, fn) else: key_generator = function_key_generator( namespace, fn, to_str=to_str) @wraps(fn)","[ value.payload if value is not NO_VALUE else value for value in (","- .0001 return value.payload, ct def gen_value(): raise NotImplementedError() def async_creator(key, mutex): mutexes[key]","keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values = fn(*arg)","not NO_VALUE) else: result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result def","integer placed in the :class:`.CachedValue` so that new versions of dogpile.cache can detect","in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys,","within the same module, as can occur when decorating instance or class methods","unicode cache keys which may require key mangling before reaching the cache. ..","to ``str()``. If the function accepts non-ascii unicode arguments on Python 2.x, the","\"\"\" if self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key) value = self._unexpired_value_fn( expiration_time,","in mutexes.values(): mutex.release() def _value(self, value): \"\"\"Return a :class:`.CachedValue` given a value.\"\"\" return","= fn.__name__ def generate_key(*arg): return namespace + \"_\" + fname + \"_\".join(str(s) for","called normally, where data will be pulled from the cache region unless a","the function is used depends on if the *dogpile lock* can be acquired","If it returns False, the value is still returned, but isn't cached. ..","it returns True will that value be placed in the cache. :param asdict:","register_backend = _backend_loader.register from . import backends # noqa value_version = 1 \"\"\"An","that will produce a list of keys. This function will supersede the one","datetime from numbers import Number from functools import wraps import threading _backend_loader =","bsddb or dbm under Python 2.x in conjunction with Unicode keys. :param async_creation_runner:","based on the given keys. Returns values as a list matching the keys","which creates a new value. :param expiration_time: optional expiration time which will overide","asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \"\"\"A function decorator that will cache multiple return values from","try: value = creator() cache.set(somekey, value) finally: mutex.release() thread = threading.Thread(target=runner) thread.start() region","to and called by dogpile.lock when there is a stale value present in","name of the function, the module name for the function, the arguments passed,","With \"soft\" invalidation, subsequent getters will return the \"old\" value until the new","if present, regardless of configured expiration times or whether or not :meth:`.invalidate` was","key in keys ] The decorated function can be called normally. The decorator","by the \"creator\", and will then return True or False, indicating if the","not be invoked. However, subsequent requests for cached-but-expired values will still return promptly.","or class methods as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \"\"","reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return self def wrap(self, proxy): '''","self.region_invalidator.is_invalidated( value.metadata[\"ct\"]): return NO_VALUE else: return value return value_fn def get_multi(self, keys, expiration_time=None,","caching possibilities relative to the function. This is a convenience method for :meth:`.CacheRegion.set`","to the :class:`.CacheRegion` itself should construct the invalidator given the region as an","type(proxy) == type: proxy = proxy() if not issubclass(type(proxy), ProxyBackend): raise TypeError(\"Type %s","ProxyBackend from ..util import compat import time import datetime from numbers import Number","in arg) return generate_key region = make_region( function_key_generator = my_key_generator ).configure( \"dogpile.cache.dbm\", expiration_time=300,","classes and/or instances, each of which will be applied in a chain to","in terms of the current \"invalidation\" time as set by the :meth:`.invalidate` method.","key = self.key_mangler(key) def get_value(): value = self.backend.get(key) if (value is NO_VALUE or","The value to be cached is passed as the first argument, and the","\"\"\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`. See that","new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`. See that class for","def is_invalidated(self, timestamp): \"\"\"Check timestamp to determine if it was invalidated. :return: Boolean.","True if ``timestamp`` is older than the last region invalidation time. \"\"\" raise","mode. \"\"\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated = None self._invalidated =","< self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated()","by loading the class from the ``dogpile.cache`` entrypoint. :param expiration_time: Optional. The expiration","get_value, expiration_time, async_creator) as value: return value def get_or_create_multi( self, keys, creator, expiration_time=None,","if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core","will receive each value returned by the \"creator\", and will then return True","value in the cache under the given key.\"\"\" if self.key_mangler: key = self.key_mangler(key)","self.function_key_generator def decorator(fn): if to_str is compat.string_type: # backwards compatible key_generator = function_key_generator(namespace,",".0001 return value.payload, ct def gen_value(): created_value = creator() value = self._value(created_value) if","was hard invalidated. :return: Boolean. True if ``timestamp`` is older than the last","if region_invalidator: self.region_invalidator = region_invalidator return self def wrap(self, proxy): ''' Takes a","to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace:","@wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k] for k in keys_to_create]) timeout = expiration_time() if","system works by setting a current timestamp (using ``time.time()``) to consider all older","Above, the function returns the value of create_value() if the cache is invalid,","``refresh()``. This attribute will invoke the decorated function and populate a new value","or a task manager system like Celery. For a specific example using async_creation_runner,","persist the newly generated value in the cache. Whether or not the function","or on a non-existent key, safely) .. versionadded:: 0.5.0 \"\"\" if self.key_mangler: keys",":meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional","from ..util import NameRegistry from . import exception from ..util import PluginLoader, memoized_property,","finished. This can be used to defer the computation of expensive creator functions","or isinstance(expiration_time, Number): self.expiration_time = expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time))","than an instance then # initialize it. if type(proxy) == type: proxy =","the ``NO_VALUE`` token. ``NO_VALUE`` evaluates to False, but is separate from ``None`` to","mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key,","mapping = dict(( self.key_mangler(k), self._value(v)) for k, v in mapping.items()) else: mapping =","sequence of keys using the same mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\"k1\", \"k2\",","if function_multi_key_generator is None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace,","< self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp","calling the decorated function will also be a list. When ``asdict==True`` if the","backend(self): raise exception.RegionNotConfigured( \"No backend is configured on this region.\") @property def is_configured(self):","creator() value = self._value(created_value) if not should_cache_fn or \\ should_cache_fn(created_value): self.backend.set(key, value) return","cache with the new value, as well as returning that value:: newvalue =","v in mapping.items()) else: mapping = dict((k, self._value(v)) for k, v in mapping.items())","0.3.0 :param hard: if True, cache values will all require immediate regeneration; dogpile","\"\"\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict, prefix): \"\"\"Configure from a configuration dictionary and a","- .0001 return value.payload, ct def gen_value(): created_value = creator() value = self._value(created_value)","expiration_time == -1: expiration_time = None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self,","False, the creation time of existing values will be pushed back before the","key\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key)","The cache key above for ``MyClass().one(3, 4)`` will again produce the same cache","given the region as an argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self, region): self.region =","which will be established as part of each cache key. :param expiration_time: if","def get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \"\"\"Return a sequence of cached values","the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses the expiration time","to be stale. It does not affect the data in the cache in","an immediate regeneration of the value which all getters will wait for. With","``one(3, 4)`` will produce a cache key as follows:: myapp.tools:one|foo|3 4 The key","decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \"\"\" orig_key = key if self.key_mangler: key","orig_key = key if self.key_mangler: key = self.key_mangler(key) def get_value(): value = self.backend.get(key)",":meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports both \"hard\" and \"soft\" invalidation options.","cannot be acquired, the method will block if no previous value is available,","is older than the last call to :meth:`.invalidate`. :param key: Key to be","key = self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping): \"\"\"Place new values in the","of each key. It will then consult the cache using the same mechanism","the decorator from having awareness of the ``MyClass`` and ``MyOtherClass`` names, as the","expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is None: function_key_generator = self.function_key_generator def decorator(fn): if","a new :class:`.CacheRegion`.\"\"\" self.name = name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler","from being returned. The method will attempt to acquire the dogpile lock to","self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn(","by setting a current timestamp (using ``time.time()``) representing the \"minimum creation time\" for","any form. For example, it can be passed as a tuple, used to","value.metadata[\"ct\"] if expiration_time is None: expiration_time = self.expiration_time if (expiration_time is None and","= time.time() - expiration_time - .0001 return value.payload, ct def gen_value(): raise NotImplementedError()","uses the same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and set values",":param creator: function which accepts a sequence of keys and returns a sequence","can then be called normally, where data will be pulled from the cache","for the given key, or the token ``NO_VALUE`` if no such key exists::","set in the cache:: generate_something.set({\"k1\": \"value1\", \"k2\": \"value2\", \"k3\": \"value3\"}) ...an ``invalidate()`` method,","in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return self def wrap(self, proxy):","cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \"\"\"A function decorator that will","before reaching the cache. .. versionadded:: 0.5.0 :param function_multi_key_generator: a function that will","value.payload if value is not NO_VALUE else value for value in ( _unexpired_value_fn(value)","Number from functools import wraps import threading _backend_loader = PluginLoader(\"dogpile.cache\") register_backend = _backend_loader.register","prevent deadlocks. # though haven't been able to simulate one anyway. keys_to_get =","single function signature, one which takes a simple list of keys as arguments.",":func:`.kwarg_function_key_generator` - optional gen that also uses keyword arguments :param function_multi_key_generator: Optional. Similar","bypasses the expiration time check. .. versionadded:: 0.5.0 \"\"\" if not keys: return","\"soft\" invalidation options. With \"hard\" invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate regeneration of","def is_invalidated(self, timestamp): return (self._invalidated is not None and timestamp < self._invalidated) def","this function invokes ``.set_multi()`` for newly generated values using the same values it","set_multi(self, mapping): \"\"\"Place new values in the cache under the given keys. ..","of configured expiration times or whether or not :meth:`.invalidate` was called. .. versionadded::",".. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" def get_value(key): value = values.get(key, NO_VALUE) if (value","expiration_time=None, should_cache_fn=None): \"\"\"Return a sequence of cached values based on a sequence of","def decorator(fn): if to_str is compat.string_type: # backwards compatible key_generator = function_key_generator(namespace, fn)","= proxy() if not issubclass(type(proxy), ProxyBackend): raise TypeError(\"Type %s is not a valid","an attribute ``invalidate()``, which provides for invalidation of the value. Pass to ``invalidate()``","the given sequence of keys using the same mechanism as that of :meth:`.CacheRegion.delete_multi`::","invalidation strategy interface Implement this interface and pass implementation instance to :meth:`.CacheRegion.configure` to","also uses keyword arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but it's","self.expiration_time current_time = time.time() def value_fn(value): if value is NO_VALUE: return value elif","key\", create_value, should_cache_fn=dont_cache_none) Above, the function returns the value of create_value() if the","``set()`` is added to provide extra caching possibilities relative to the function. This","``.name`` parameter, helpful for configuring a region from a config file. :param function_key_generator:","generation can be entirely replaced on a per-region basis using the ``function_key_generator`` argument","mutex in mutexes.values(): mutex.release() def _value(self, value): \"\"\"Return a :class:`.CachedValue` given a value.\"\"\"","determine a *dynamic* expiration time for the cached function result. Example use cases","method is given a non-None expiration time. .. versionadded:: 0.3.0 :param hard: if","cached. :param to_str: callable, will be called on each function argument in order","of, for example, a background thread, a long-running queue, or a task manager","of new values. :param expiration_time: optional expiration time which will overide the expiration","if getattr(wrap, '__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator =","\"creator\", and will then return True or False, indicating if the value should","points in the future by way of, for example, a background thread, a","_backend_loader.register from . import backends # noqa value_version = 1 \"\"\"An integer placed","if True, cache values will all require immediate regeneration; dogpile logic won't be","is considered to be expired based on its creation time, the given creation","Added ``get()`` method to decorated function. The default key generation will use the","works by setting a current timestamp (using ``time.time()``) representing the \"minimum creation time\"","get and set values from the backend. If you are using a :class:`.CacheBackend`","against the creation time of the retrieved value versus the current time (as","+ b The cache key above for ``MyClass().one(3, 4)`` will again produce the","\"\"\"Indicate the region was invalidated in soft mode. :return: Boolean. True if region","be needed to disambiguate functions of the same name within the same source","key_mangler=None, async_creation_runner=None, ): \"\"\"Construct a new :class:`.CacheRegion`.\"\"\" self.name = name self.function_key_generator = function_key_generator","time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports","elif not should_cache_fn: return True else: return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create,","to the function. This is a convenience method for :meth:`.CacheRegion.set` which will store","def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated and timestamp","keys, creator, timeout, should_cache_fn) return result def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def","def is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp < self._soft_invalidated) The custom implementation is","the expiration time supplied by the ``expiration_time`` argument, is tested against the creation","running a creation function for this key against the cache. When the dogpile","the value's creation time against the expiration time, rather than returning the value","or may not be used to recreate the value and persist the newly","a sequence of new values. :param expiration_time: optional expiration time which will overide","assembled into a new argument list, and the decorated function is then called","required \" \"for soft invalidation\") if expiration_time == -1: expiration_time = None if","the value -1. :param should_cache_fn: optional callable function which will receive each value","is compat.string_type: # backwards compatible key_generator = function_key_generator(namespace, fn) else: key_generator = function_key_generator(","is available. Usage of \"soft\" invalidation requires that the region or the method","can be applied. .. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True,","self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \"Non-None expiration time required \" \"for soft invalidation\") if expiration_time","ct = time.time() - expiration_time - .0001 return value.payload, ct def gen_value(): raise","= fn return decorate return decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False,","dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k] for k in keys_to_create]) timeout =","Takes a ProxyBackend instance or class and wraps the attached backend. ''' #","time against the expiration time, rather than returning the value unconditionally. The method","( _unexpired_value_fn(value) for value in backend_values ) ] def get_or_create( self, key, creator,","new function that generates the key based on the given arguments. Such as::","function may be asked to generate any subset of the given keys. The","key. Given a function ``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\"foo\") def one(a, b):","return value is not None value = region.get_or_create(\"some key\", create_value, should_cache_fn=dont_cache_none) Above, the","mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\"k1\", \"k2\", \"k3\") ...a ``refresh()`` method, which will","modifies values, take note this function invokes ``.set_multi()`` for newly generated values using","by the key_mangler function, if present. :param creator: function which creates a new","def invalidate(self, hard=None): if hard: self._soft_invalidated = None self._hard_invalidated = time.time() else: self._soft_invalidated","from the cache if present, regardless of configured expiration times or whether or","default invalidation system works by setting a current timestamp (using ``time.time()``) representing the","value): \"\"\"Place a new value in the cache under the given key.\"\"\" if","self.set_multi( dict(zip(keys, values)) ) return values decorate.set = set_ decorate.invalidate = invalidate decorate.refresh","return [ d_values.get(key_lookup[k], NO_VALUE) for k in keys] def wrap_cache_fn(value): if value is","\"cache key\" given a data creation function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments`","which will call the creation function, cache the new values, and return them::","is not available\", e.g. # _has_value() will return False. return value.payload, 0 else:","The method also interprets the cached value in terms of the current \"invalidation\"","\"cache the result until the end of the day, week or time period\"","certain date or time passes\". .. versionchanged:: 0.5.0 ``expiration_time`` may be passed as","passed to ``creator()``, and ``creator()`` should return the generated values as a sequence","and wraps the attached backend. ''' # if we were passed a type","be specified as a callable, taking no arguments, that returns a value to","for gen_key, key in zip(gen_keys, keys)) ) def get(*arg): keys = key_generator(*arg) return","established as part of the cache key. This may be needed to disambiguate","can be entirely replaced on a per-region basis using the ``function_key_generator`` argument present","list of keys. This function will supersede the one configured on the :class:`.CacheRegion`","list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in zip(gen_keys, keys))","To set no expiration, use the value -1. :param should_cache_fn: optional callable function","string form of each key. It will then consult the cache using the","generation. :param arguments: Optional. The structure here is passed directly to the constructor","that new versions of dogpile.cache can detect cached values from a previous, backwards-incompatible","is considered to be stale. It does not affect the data in the","effectively invalidated. \"\"\" raise NotImplementedError() def is_hard_invalidated(self, timestamp): \"\"\"Check timestamp to determine if","given keys. .. versionadded:: 0.5.0 \"\"\" if not mapping: return if self.key_mangler: mapping","either the value cached for the given key, or the token ``NO_VALUE`` if","or \\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\"ct\"] if expiration_time is None: expiration_time","no such key exists:: value = generate_something.get(5, 6) .. versionadded:: 0.5.3 Added ``get()``","generate_key region = make_region( function_key_generator = my_key_generator ).configure( \"dogpile.cache.dbm\", expiration_time=300, arguments={ \"filename\":\"file.dbm\" }","<gh_stars>1000+ from __future__ import with_statement from .. import Lock, NeedRegenerationException from ..util import","\"\"\" def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \"\"\"Construct a new","expiration times or whether or not :meth:`.invalidate` was called. .. versionadded:: 0.3.0 \"\"\"","below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \"\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def","as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and set values from the backend. If","case the key mangling function recommended by the cache backend will be used.","is older than the last region invalidation time. \"\"\" raise NotImplementedError() def was_soft_invalidated(self):","the function using a sequence of keys derived from the function itself and","those keys will not be cached. :param to_str: callable, will be called on","to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key = key_generator(*arg, **kw) @wraps(fn) def creator(): return","one configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi`","generate_key(*arg, **kw): return \":\".join( [kw[k] for k in namespace] + [str(x) for x","with no associated value will always block; async_creator will not be invoked. However,","value cached for the given key, or the token ``NO_VALUE`` if no such","arguments={ \"filename\":\"file.dbm\" } ) The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not","if expiration_time == -1: expiration_time = None mutexes = {} sorted_unique_keys = sorted(set(keys))","value.\"\"\" return CachedValue( value, { \"ct\": time.time(), \"v\": value_version }) def set(self, key,","for k, v in zip(cache_keys, result) if v is not NO_VALUE) else: result","function is missing keys, those keys will not be cached. :param to_str: callable,","for a in arg])) ) return values else: self.set_multi( dict(zip(keys, values)) ) return","the first argument, and the arguments which would normally be passed to the","the newly generated value in the cache. Whether or not the function is","def async_creation_runner(cache, somekey, creator, mutex): ''' Used by dogpile.core:Lock when appropriate ''' def",":meth:`.CacheRegion.invalidate` method. :param key: Key to be retrieved. While it's typical for a","function and populate a new value into the cache with the new value,","at :func:`.sha1_mangle_key` which coerces keys into a SHA1 hash, so that the string","seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is None: function_key_generator =","in hard mode. \"\"\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated = None","not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for","a dictionary. :param wrap: Optional. A list of :class:`.ProxyBackend` classes and/or instances, each","cache key. Given a function ``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\"foo\") def one(a,","a previous value is available, that value is returned immediately without blocking. If","proxy() if not issubclass(type(proxy), ProxyBackend): raise TypeError(\"Type %s is not a valid ProxyBackend\"","For example:: def my_multi_key_generator(namespace, fn, **kw): namespace = fn.__name__ + (namespace or '')","levels: given the data creation function, return a new function that generates the","options. With \"hard\" invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate regeneration of the value","key mangling, set to ``False``. Another typical mangler is the built-in Python function","return if self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v)) for k, v in mapping.items())","cache multiple return values from the function using a sequence of keys derived","sequence of new values. :param expiration_time: optional expiration time which will overide the",":param key_mangler: Function which will be used on all incoming keys before passing","the async_creation_runner feature. \"\"\" def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ):","a SHA1 hash, so that the string length is fixed. To disable all","default key generation will use the name of the function, the module name","entrypoint. :param expiration_time: Optional. The expiration time passed to the dogpile system. May","to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \"\"\" orig_key","key, or the token ``NO_VALUE`` if no such key exists:: value = generate_something.get(5,","``zip()``:: keys = [\"one\", \"two\", \"three\"] values = region.get_multi(keys) dictionary = dict(zip(keys, values))","``timestamp`` is older than the last region invalidation time and region is invalidated","a data creation function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method. The structure","versionadded:: 0.4.1 Added ``set()`` method to decorated function. Similar to ``set()`` is ``refresh()``.","Above, the ``namespace`` parameter disambiguates between ``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python class","expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \"\"\"A function decorator that will cache multiple return","dict(( self.key_mangler(k), self._value(v)) for k, v in mapping.items()) else: mapping = dict((k, self._value(v))","= expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time","optional callable function which will receive the value returned by the \"creator\", and","in the :class:`.CachedValue` so that new versions of dogpile.cache can detect cached values","multiple times, or on a non-existent key, safely) \"\"\" if self.key_mangler: key =","cache key as follows:: myapp.tools:one|foo|3 4 The key generator will ignore an initial",":param name: Optional, a string name for the region. This isn't used internally","time for the cached function result. Example use cases include \"cache the result","of deleting the given sequence of keys using the same mechanism as that","missing keys, those keys will not be cached. :param to_str: callable, will be","accepts non-ascii unicode arguments on Python 2.x, the ``unicode()`` builtin can be substituted,","the \"multiple key\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return","the cache. :param asdict: if ``True``, the decorated function should return its result","function that will produce a \"cache key\" given a data creation function and","convert non-string or Unicode keys to bytestrings, which is needed when using a","cache values will all require immediate regeneration; dogpile logic won't be used. If","value based on the given key. If the value does not exist or","it won't be cached. .. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create`","the decorated function will also be a dictionary. If left at its default","cache under the given key.\"\"\" if self.key_mangler: key = self.key_mangler(key) self.backend.set(key, self._value(value)) def","configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \"\"\"","return somedatabase.query(x, y) The decorated function can then be called normally, where data","versionadded:: 0.5.1 \"\"\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict, prefix): \"\"\"Configure from a configuration dictionary","method, which here accepts a mapping of keys and values to set in","exception.ValidationError( 'expiration_time is not a number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler =","a return+regen will be invoked. .. versionadded:: 0.5.1 \"\"\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict,","self.lock.acquire(wait) def release(self): self.lock.release() def _create_mutex(self, key): mutex = self.backend.get_mutex(key) if mutex is","@someregion.cache_on_arguments() def generate_something(x, y): return somedatabase.query(x, y) The decorated function can then be","function argument in order to convert to a string. Defaults to ``str()``. If","function can be called normally. The decorator will produce a list of cache","to retrieve all current values; the originally passed keys corresponding to those values","versus the current time (as reported by ``time.time()``). If stale, the cached value","function may or may not be used to recreate the value and persist","+ str(a) for a in args] return generate_keys :param key_mangler: Function which will","if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None,","follow:: generate_something.set(3, 5, 6) The above example is equivalent to calling ``generate_something(5, 6)``,","is returned. Passing the flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionadded::","fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable \\ else expiration_time return self.get_or_create(key, creator,","will produce a list of cache keys using a mechanism similar to that","\"\"\" orig_key = key if self.key_mangler: key = self.key_mangler(key) def get_value(): value =","internally makes use of the :meth:`.CacheRegion.get_or_create` method to access the cache and conditionally","details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a single function signature,","config_dict, prefix): \"\"\"Configure from a configuration dictionary and a prefix. Example:: local_region =","config_dict = coerce_string_conf(config_dict) return self.configure( config_dict[\"%sbackend\" % prefix], expiration_time=config_dict.get( \"%sexpiration_time\" % prefix, None),","with the new value, as well as returning that value:: newvalue = generate_something.refresh(5,",":param function_multi_key_generator: a function that will produce a list of keys. This function","- expiration_time - .0001 return value.payload, ct def gen_value(): raise NotImplementedError() def async_creator(key,","= expiration_time() if expiration_time_is_callable \\ else expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn) def","will invoke the decorated function and populate a new value into the cache","the creation function, cache the new values, and return them:: values = generate_something.refresh(\"k1\",","timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return (self._hard_invalidated and","return 'backend' in self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False): \"\"\"Return a value from","passed since the last generation. :param arguments: Optional. The structure here is passed","The method uses the same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and","list(map(lambda key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return","gen_key, key in zip(gen_keys, keys)) ) def get(*arg): keys = key_generator(*arg) return self.get_multi(keys)","of keys and values to set in the cache:: generate_something.set({\"k1\": \"value1\", \"k2\": \"value2\",","it becomes an instance method. The function key generation can be entirely replaced","value is unconditionally regenerated if the creation time is older than the last","def generate_keys(*args): return [namespace + ':' + str(a) for a in args] return","the list are returned as the ``NO_VALUE`` token. ``NO_VALUE`` evaluates to False, but","associated value will always block; async_creator will not be invoked. However, subsequent requests","NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator","key: Key to be retrieved. While it's typical for a key to be","time, the given creation function may or may not be used to recreate","callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This function is given a value as",".. versionadded:: 0.4.1 Added ``set()`` method to decorated function. Similar to ``set()`` is","def generate_key(*arg): return namespace + \"_\" + fname + \"_\".join(str(s) for s in","incoming keys before passing to the backend. Defaults to ``None``, in which case","self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None,","dict((k, self._value(v)) for k, v in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \"\"\"Remove a","and/or instances, each of which will be applied in a chain to ultimately","distinguish between a cached value of ``None``. By default, the configured expiration time","function, the module name for the function, the arguments passed, as well as","region was invalidated in soft mode. :return: Boolean. True if region was invalidated","soft invalidation\") if expiration_time == -1: expiration_time = None mutexes = {} sorted_unique_keys","and ``creator()`` should return the generated values as a sequence corresponding to the","that value be placed in the cache. :param asdict: if ``True``, the decorated","using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \"\"\" orig_key = key if","it can't, it means a different thread or process is already running a","invalidation time check. .. versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param key:","after this time period has passed since the last generation. :param arguments: Optional.","decorators, but not yet for actual caching # later, when config is available","from .util import function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue from .proxy import","%s is not a valid ProxyBackend\" % type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self,","to a dictionary, use ``zip()``:: keys = [\"one\", \"two\", \"three\"] values = region.get_multi(keys)","of arguments. The returned result is a list:: result = generate_something(\"key1\", \"key2\", \"key3\")","the ``namespace`` parameter disambiguates between ``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python class declaration","asked to generate any subset of the given keys. The list of keys","using the same mechanism as that of :meth:`.CacheRegion.get_multi` to retrieve all current values;","return value.payload, value.metadata[\"ct\"] if expiration_time is None: expiration_time = self.expiration_time if (expiration_time is","suitable (with caveats) for use with instance or class methods. Given the example::","@wraps(fn) def decorate(*arg, **kw): cache_keys = arg keys = key_generator(*arg, **kw) key_lookup =","arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, } ) Remember that the first request for","normally, where data will be pulled from the cache region unless a new","wrapper for threading.Lock\"\"\" def __init__(self): self.lock = threading.Lock() def acquire(self, wait=True): return self.lock.acquire(wait)","\"\"\" raise NotImplementedError() def was_soft_invalidated(self): \"\"\"Indicate the region was invalidated in soft mode.","in soft mode. :return: Boolean. True if region was invalidated in soft mode.","PluginLoader, memoized_property, coerce_string_conf from .util import function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue","Sequence of keys to be retrieved. :param creator: function which accepts a sequence","time period\" and \"cache until a certain date or time passes\". .. versionchanged::",":class:`.ProxyBackend` that modifies values, take note this function invokes ``.set_multi()`` for newly generated","function should be two levels: given the data creation function, return a new","multiple times, or on a non-existent key, safely) .. versionadded:: 0.5.0 \"\"\" if","in caching or retrieving. Thus, this can be used to determine a *dynamic*","name within the same source file, such as those associated with classes -","decorator(fn): if to_str is compat.string_type: # backwards compatible key_generator = function_key_generator(namespace, fn) else:","be passed as an integer or a callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`.","return a new function that generates the key based on the given arguments.","by whatever asynchronous means the provided async_creation_runner callable implements. By default the async_creation_runner","be passed as a tuple, used to specify arguments to pluck from \\**kw::","parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list of keys.","function decorator that will cache the return value of the function using a","expiration time, rather than returning the value unconditionally. The method also interprets the","is older than the invalidation timestamp, the value is unconditionally prevented from being","returns True will that value be placed in the cache. :param asdict: if","same name within the same module, as can occur when decorating instance or","function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method. The structure of this function","in the cache. It will be passed the mutex and is responsible releasing","def __init__(self): self._is_hard_invalidated = None self._invalidated = None def invalidate(self, hard=True): self._is_hard_invalidated =","instance then # initialize it. if type(proxy) == type: proxy = proxy() if","**kw): \"\"\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`. See","the cache. Whether or not the function is used depends on if the","retrieved value whose creation time is prior to this timestamp is considered to","self._value(v)) for k, v in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \"\"\"Remove a value","be retrieved. While it's typical for a key to be a string, it","The key generator will ignore an initial argument of ``self`` or ``cls``, making",":param backend: Required. This is the name of the :class:`.CacheBackend` to use, and","key = key_generator(*arg, **kw) value = fn(*arg, **kw) self.set(key, value) return value decorate.set","based on the given arguments:: values = generate_something.get(\"k1\", \"k2\", \"k3\") .. versionadded:: 0.5.3","``time.time()``) representing the \"minimum creation time\" for a value. Any retrieved value whose","fn(*[key_lookup[k] for k in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\ else expiration_time","whose creation time is prior to this timestamp is considered to be stale.","as well as returning that value:: newvalue = generate_something.refresh(5, 6) .. versionadded:: 0.5.0","integer number of seconds, or as a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time``","decorated function. The default key generation will use the name of the function,","be a list. When ``asdict==True`` if the dictionary returned by the decorated function","new values, and return them:: values = generate_something.refresh(\"k1\", \"k2\", \"k3\") ...and a ``get()``","makes use of the :meth:`.CacheRegion.get_or_create_multi` method to access the cache and conditionally call","it returns False, the value is still returned, but isn't cached. E.g.:: def","_config_argument_dict, _config_prefix ) else: self.backend = backend_cls(arguments or {}) if not expiration_time or","- multiple key/value version \"\"\" orig_key = key if self.key_mangler: key = self.key_mangler(key)","set(self, key, value): \"\"\"Place a new value in the cache under the given","dictionary. :param wrap: Optional. A list of :class:`.ProxyBackend` classes and/or instances, each of","be pushed back before the expiration time so that a return+regen will be","provide extra caching possibilities relative to the function. This is a convenience method","was_hard_invalidated(self): \"\"\"Indicate the region was invalidated in hard mode. :return: Boolean. True if","\"\"\" raise NotImplementedError() def is_soft_invalidated(self, timestamp): \"\"\"Check timestamp to determine if it was","self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None,","invalidation, subsequent getters will return the \"old\" value until the new one is","the given key.\"\"\" if self.key_mangler: key = self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping):","unicode arguments on Python 2.x, the ``unicode()`` builtin can be substituted, but note","\"_\".join(str(s) for s in arg) return generate_key region = make_region( function_key_generator = my_key_generator","in a chain to ultimately wrap the original backend, so that custom functionality","versionadded:: 0.5.3 Added ``get()`` method to decorated function. The default key generation will","using the same values it returns to the calling function. A correct implementation","= dict( (orig_to_mangled[k], self._value(v)) for k, v in zip(keys_to_get, new_values) ) if not","the :class:`.CacheBackend` in use, though is typically a dictionary. :param wrap: Optional. A","def generate_key(*arg, **kw): return \":\".join( [kw[k] for k in namespace] + [str(x) for","Passing the flag ``ignore_expiration=True`` bypasses the invalidation time check. .. versionadded:: 0.3.0 Support","b): return a + b The cache key above for ``MyClass().one(3, 4)`` will","expiration_time_is_callable \\ else expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key","it. This method is the \"multiple key\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example::","return self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object):","and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`. :param namespace: optional string argument which will","value is present, but its creation time is older than the current invalidation","If it returns False, the value is still returned, but isn't cached. E.g.::","unconditionally prevented from being returned. The method will attempt to acquire the dogpile","decorated function should return its result as a list of values, and the","``creator()``, and ``creator()`` should return the generated values as a sequence corresponding to","used. A typical mangler is the SHA1 mangler found at :func:`.sha1_mangle_key` which coerces","return \":\".join( [kw[k] for k in namespace] + [str(x) for x in arg]","the new value. .. versionchanged:: 0.3.0 The value is unconditionally regenerated if the","configuring a region from a config file. :param function_key_generator: Optional. A function that","will be replaced. Without this flag, an exception is raised if a backend","import backends # noqa value_version = 1 \"\"\"An integer placed in the :class:`.CachedValue`","wait for. With \"soft\" invalidation, subsequent getters will return the \"old\" value until","``3`` as the value to be cached. .. versionadded:: 0.4.1 Added ``set()`` method","**not** the :meth:`.CacheRegion.get` method) will call upon the value creation function after this","arguments. Such as:: def my_key_generator(namespace, fn, **kw): fname = fn.__name__ def generate_key(*arg): return","against the expiration time, rather than returning the value unconditionally. The method also","new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for k, v","versionadded:: 0.5.3 Added ``get()`` method to decorated function. Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have","return result def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys = list(mapping)","@property def is_configured(self): \"\"\"Return True if the backend has been configured via the","MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \"\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x,","+ \"_\".join(str(s) for s in arg) return generate_key region = make_region( function_key_generator =","from having awareness of the ``MyClass`` and ``MyOtherClass`` names, as the function is","asdict: if ``True``, the decorated function should return its result as a dictionary","self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time is not a number or","): pass try: if mutexes: # sort the keys, the idea is to","flag ``ignore_expiration=True`` bypasses the invalidation time check. .. versionadded:: 0.3.0 Support for the","= generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added ``refresh()`` method to decorated function. Lastly,","decorated function. Lastly, the ``get()`` method returns either the value cached for the",":class:`.ProxyBackend` classes and/or instances, each of which will be applied in a chain","names, as the function is received by the decorator before it becomes an","of the :class:`.CacheBackend` in use, though is typically a dictionary. :param wrap: Optional.","or dbm under Python 2.x in conjunction with Unicode keys. :param async_creation_runner: A","non-None expiration time. .. versionadded:: 0.3.0 :param hard: if True, cache values will","given key. If the value does not exist or is considered to be","should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable, will be called","generated value in the cache. Whether or not the function is used depends","should return its result as a dictionary of keys->values, and the final result",":meth:`.CacheRegion.cache_on_arguments`, the decorated function is also provided with a ``set()`` method, which here","custom implementation is injected into a :class:`.CacheRegion` at configure time using the :paramref:`.CacheRegion.configure.region_invalidator`","passing to the backend. Defaults to ``None``, in which case the key mangling","The function is also given an attribute ``invalidate()``, which provides for invalidation of","mutex) else: async_creator = None with Lock( self._mutex(key), gen_value, get_value, expiration_time, async_creator) as","a list of cache keys using a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`,","\"\"\" if self.key_mangler: key = self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \"\"\"Remove multiple values",":class:`.CacheRegion` if not None. To set no expiration, use the value -1. :param","uses keyword arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but it's used",".. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks the value's creation time against the expiration","still returned, but isn't cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \"\"\"","= sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key","generation will use the name of the function, the module name for the","key_generator = function_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key = key_generator(*arg,","values from the function using a sequence of keys derived from the function","timeout = expiration_time() if expiration_time_is_callable \\ else expiration_time if asdict: def dict_create(*keys): d_values","fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for a in arg])) ) return values","a new function that generates the key based on the given arguments. Such","cache key. This may be needed to disambiguate functions of the same name","this function, so in fact can be of any form. For example, it","def make_region(*arg, **kw): \"\"\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to","+ (namespace or '') def generate_keys(*args): return [namespace + ':' + str(a) for","seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \"\"\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is None: function_multi_key_generator =","time period has passed since the last generation. :param arguments: Optional. The structure","region invalidation time. \"\"\" raise NotImplementedError() def was_soft_invalidated(self): \"\"\"Indicate the region was invalidated","was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp < self._soft_invalidated) The","should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \"\"\"A function decorator that will cache multiple return values","= self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping): \"\"\"Place new values in the cache","returned by the \"creator\", and will then return True or False, indicating if","to return the new value. .. versionchanged:: 0.3.0 The value is unconditionally regenerated","\"key2\", \"key3\") The decorator internally makes use of the :meth:`.CacheRegion.get_or_create_multi` method to access","of \"soft\" invalidation requires that the region or the method is given a","0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param key: Key to be retrieved. While","the value is still returned, but isn't cached. E.g.:: def dont_cache_none(value): return value","mutex when finished. This can be used to defer the computation of expensive","function, so can be of any type recognized by the backend or by","They will be refreshed by whatever asynchronous means the provided async_creation_runner callable implements.","the \"old\" value until the new one is available. Usage of \"soft\" invalidation","available. If a previous value is available, that value is returned immediately without","function. Similar to ``set()`` is ``refresh()``. This attribute will invoke the decorated function","or class and wraps the attached backend. ''' # if we were passed","expiration time so that a return+regen will be invoked. .. versionadded:: 0.5.1 \"\"\"","def is_configured(self): \"\"\"Return True if the backend has been configured via the :meth:`.CacheRegion.configure`","= self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration: return","cache key. :param expiration_time: if not None, will override the normal expiration time.","False): for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return self","\"cache.local.arguments.filename\":\"/path/to/dbmfile.dbm\", \"cache.memcached.backend\":\"dogpile.cache.pylibmc\", \"cache.memcached.arguments.url\":\"127.0.0.1, 10.0.0.1\", } local_region.configure_from_config(myconfig, \"cache.local.\") memcached_region.configure_from_config(myconfig, \"cache.memcached.\") \"\"\" config_dict = coerce_string_conf(config_dict)","= my_key_generator ).configure( \"dogpile.cache.dbm\", expiration_time=300, arguments={ \"filename\":\"file.dbm\" } ) The ``namespace`` is that","''' def runner(): try: value = creator() cache.set(somekey, value) finally: mutex.release() thread =","k, v in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k in","might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw): return my_data() ..","example:: class MyClass(object): @region.cache_on_arguments(namespace=\"foo\") def one(self, a, b): return a + b The","\"\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y): \"\" Above, the ``namespace`` parameter","self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values = fn(*arg) if asdict: self.set_multi( dict(zip(keys,","reported by ``time.time()``). If stale, the cached value is ignored and the ``NO_VALUE``","= self.backend.get(key) if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\"ct\"])):",":meth:`.CacheRegion.get_or_create` \"\"\" def get_value(key): value = values.get(key, NO_VALUE) if (value is NO_VALUE or","of the keys. The method uses the same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi`","self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return (self._hard_invalidated and timestamp <","creation time is older than the current invalidation time, the ``NO_VALUE`` token is","self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass try: if","been able to simulate one anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get) values_w_created","possibilities relative to the function. This is a convenience method for :meth:`.CacheRegion.set` which","the ``unicode()`` builtin can be substituted, but note this will produce unicode cache","retrieve all current values; the originally passed keys corresponding to those values which","value: value else: if expiration_time is None: expiration_time = self.expiration_time current_time = time.time()","cache. Whether or not the function is used depends on if the *dogpile","0.3.0 :meth:`.CacheRegion.get` now checks the value's creation time against the expiration time, rather","= [\"one\", \"two\", \"three\"] values = region.get_multi(keys) dictionary = dict(zip(keys, values)) Keys which","correct implementation of ``.set_multi()`` will not modify values in-place on the submitted ``mapping``","import threading def async_creation_runner(cache, somekey, creator, mutex): ''' Used by dogpile.core:Lock when appropriate","This is the name of the :class:`.CacheBackend` to use, and is resolved by","to consider all older timestamps effectively invalidated. \"\"\" raise NotImplementedError() def is_hard_invalidated(self, timestamp):","to defer the computation of expensive creator functions to later points in the","arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \"\"\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself","the :class:`.CacheBackend` to use, and is resolved by loading the class from the","The value is unconditionally regenerated if the creation time is older than the","dont_cache_none(value): return value is not None value = region.get_or_create(\"some key\", create_value, should_cache_fn=dont_cache_none) Above,","``refresh()`` method, which will call the creation function, cache the new values, and","creation function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method. The structure of this","the current \"invalidation\" time as set by the :meth:`.invalidate` method. If a value","value which all getters will wait for. With \"soft\" invalidation, subsequent getters will","of the :meth:`.CacheRegion.get_or_create` method to access the cache and conditionally call the function.","the expiration time so that a return+regen will be invoked. .. versionadded:: 0.5.1","becomes an instance method. The function key generation can be entirely replaced on","have the same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string","else: ct = value.metadata[\"ct\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time - .0001","the data in the cache in any way, and is also local to","also local to this instance of :class:`.CacheRegion`. Once set, the invalidation time is","we were passed a type rather than an instance then # initialize it.","seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \"\"\" def invalidate(self, hard=True): \"\"\"Region invalidation. :class:`.CacheRegion` propagated call. The default","... # ... region = CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 ..","value is needed:: result = generate_something(5, 6) The function is also given an","= fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for a in arg])) ) return","The :class:`.CacheRegion` itself is returned. :param backend: Required. This is the name of","This can be used to defer the computation of expensive creator functions to","will attempt to acquire the dogpile lock to generate a new value, or",":param namespace: optional string argument which will be established as part of each","values = region.get_multi([\"one\", \"two\", \"three\"]) To convert values to a dictionary, use ``zip()``::","cache in any way, and is also local to this instance of :class:`.CacheRegion`.","expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \"\"\"A function decorator that will cache the return value","def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \"\"\"A function decorator that","all current values; the originally passed keys corresponding to those values which aren't","parent class on a function as the class is being declared. :param expiration_time:",".. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True, the existing cache","``MyClass().one(3, 4)`` will again produce the same cache key of ``myapp.tools:one|foo|3 4`` -","class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y): \"\" Above, the ``namespace`` parameter disambiguates","form. For example, it can be passed as a tuple, used to specify","= invalidate decorate.refresh = refresh decorate.get = get decorate.original = fn return decorate","be called normally, where data will be pulled from the cache region unless","though haven't been able to simulate one anyway. keys_to_get = sorted(mutexes) new_values =","or time passes\". .. versionchanged:: 0.5.0 ``expiration_time`` may be passed as a callable","somekey, creator, mutex): ''' Used by dogpile.core:Lock when appropriate ''' def runner(): try:","_mutex(self, key): return self._lock_registry.get(key) class _LockWrapper(object): \"\"\"weakref-capable wrapper for threading.Lock\"\"\" def __init__(self): self.lock","\"\"\"Return True if the backend has been configured via the :meth:`.CacheRegion.configure` method already.","the region or the method is given a non-None expiration time. .. versionadded::","0 here as # \"the value is not available\", e.g. # _has_value() will","self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \"\"\"A function decorator that","def get_value(): value = self.backend.get(key) if (value is NO_VALUE or value.metadata['v'] != value_version","myapp.tools:one|foo|3 4 The key generator will ignore an initial argument of ``self`` or","as that of :meth:`.CacheRegion.get_multi` to retrieve all current values; the originally passed keys","final result of calling the decorated function will also be a dictionary. If","request for a key with no associated value will always block; async_creator will","will return values based on the given arguments:: values = generate_something.get(\"k1\", \"k2\", \"k3\")","[values[a] for a in arg])) ) return values else: self.set_multi( dict(zip(keys, values)) )","expiration_time: Optional. The expiration time passed to the dogpile system. May be passed","``.set_multi()`` will not modify values in-place on the submitted ``mapping`` dict. :param keys:","call to :meth:`.invalidate`. :param key: Key to be retrieved. While it's typical for","be applied. .. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True, the","the current invalidation time, the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True``","as a callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3","True, cache values will all require immediate regeneration; dogpile logic won't be used.","values)) Keys which aren't present in the list are returned as the ``NO_VALUE``","return self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key)","0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \"\"\" def invalidate(self, hard=True): \"\"\"Region invalidation. :class:`.CacheRegion` propagated call.","import NameRegistry from . import exception from ..util import PluginLoader, memoized_property, coerce_string_conf from","determine if it was invalidated. :return: Boolean. True if ``timestamp`` is older than","a \"cache key\" given a data creation function and arguments, when using the","any way, and is also local to this instance of :class:`.CacheRegion`. Once set,","new values. :param expiration_time: optional expiration time which will overide the expiration time","found at :func:`.sha1_mangle_key` which coerces keys into a SHA1 hash, so that the","self.expiration_time = expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError(","the value cached for the given key, or the token ``NO_VALUE`` if no","keys corresponding to those values which aren't generated or need regeneration will be","an instance then # initialize it. if type(proxy) == type: proxy = proxy()","has the effect of deleting the given sequence of keys using the same","None, it won't be cached. .. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies","to_str: callable, will be called on each function argument in order to convert","in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\ else expiration_time if asdict: def","not replace_existing_backend: raise exception.RegionAlreadyConfigured( \"This region is already \" \"configured with backend: %s.","configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \"\"\"Configure a","raised if a backend is already configured. .. versionadded:: 0.5.7 :param region_invalidator: Optional.","self._soft_invalidated = time.time() self._hard_invalidated = None def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp","block; async_creator will not be invoked. However, subsequent requests for cached-but-expired values will","used to convert non-string or Unicode keys to bytestrings, which is needed when","self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key) def","timestamps effectively invalidated. \"\"\" raise NotImplementedError() def is_hard_invalidated(self, timestamp): \"\"\"Check timestamp to determine","(k, v) for k, v in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload","will also be a list. When ``asdict==True`` if the dictionary returned by the","has been configured via the :meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1 \"\"\" return","= CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \"\"\" def","internally makes use of the :meth:`.CacheRegion.get_or_create_multi` method to access the cache and conditionally","x, y): \"\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y): \"\" Above, the","False elif not should_cache_fn: return True else: return should_cache_fn(value) result = self.get_or_create_multi( keys,","until the lock is released and a new value available. If a previous","versionadded:: 0.5.0 \"\"\" if not mapping: return if self.key_mangler: mapping = dict(( self.key_mangler(k),","and a new value available. If a previous value is available, that value","def is_soft_invalidated(self, timestamp): \"\"\"Check timestamp to determine if it was soft invalidated. :return:","access the cache and conditionally call the function. See that method for additional","Without this flag, an exception is raised if a backend is already configured.","will then consult the cache using the same mechanism as that of :meth:`.CacheRegion.get_multi`","wrap=config_dict.get( \"%swrap\" % prefix, None), ) @memoized_property def backend(self): raise exception.RegionNotConfigured( \"No backend",":meth:`.CacheRegion.get_or_create` method as well as the :meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not** the :meth:`.CacheRegion.get`","replace_existing_backend=False, region_invalidator=None ): \"\"\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned. :param backend:","if function_key_generator is None: function_key_generator = self.function_key_generator def decorator(fn): if to_str is compat.string_type:","to it. This method is the \"multiple key\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method.","be accessed via the ``.name`` parameter, helpful for configuring a region from a","instance of :class:`.CacheRegion`. Once set, the invalidation time is honored by the :meth:`.CacheRegion.get_or_create`,","getters will wait for. With \"soft\" invalidation, subsequent getters will return the \"old\"","produce the value ``3`` as the value to be cached. .. versionadded:: 0.4.1","@wraps(fn) def creator(): return fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable \\ else","can be used to convert non-string or Unicode keys to bytestrings, which is","def gen_value(): created_value = creator() value = self._value(created_value) if not should_cache_fn or \\","...and a ``get()`` method, which will return values based on the given arguments::","mutex) ): pass try: if mutexes: # sort the keys, the idea is","be used on all incoming keys before passing to the backend. Defaults to","_config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \"\"\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned.","When the dogpile lock cannot be acquired, the method will block if no","will be assembled into a new argument list, and the decorated function is","NO_VALUE, CachedValue from .proxy import ProxyBackend from ..util import compat import time import","generator will ignore an initial argument of ``self`` or ``cls``, making the decorator","the built-in Python function ``str``, which can be used to convert non-string or",":param expiration_time: if not None, will override the normal expiration time. May be","of the retrieved value versus the current time (as reported by ``time.time()``). If","= list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in zip(gen_keys,","arg] ) return generate_key Where the decorator might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y'))","into a new argument list, and the decorated function is then called with","setting a current timestamp (using ``time.time()``) to consider all older timestamps effectively invalidated.","default invalidation strategy with custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \"\"\" if","self._invalidated = None def invalidate(self, hard=True): self._is_hard_invalidated = bool(hard) self._invalidated = time.time() def","is also given an attribute ``invalidate()``, which provides for invalidation of the value.","0.5.0 :param function_key_generator: a function that will produce a \"cache key\". This function","A typical mangler is the SHA1 mangler found at :func:`.sha1_mangle_key` which coerces keys","so can be of any type recognized by the backend or by the","with classes - note that the decorator itself can't see the parent class","stale. It does not affect the data in the cache in any way,","# regions are ready to use for function # decorators, but not yet","raise NotImplementedError() def is_invalidated(self, timestamp): \"\"\"Check timestamp to determine if it was invalidated.","self.region = region # ... # ... region = CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region))","raise NotImplementedError() def async_creator(key, mutex): mutexes[key] = mutex if expiration_time is None: expiration_time","else: self.set_multi( dict(zip(keys, values)) ) return values decorate.set = set_ decorate.invalidate = invalidate","creation function may or may not be used to recreate the value and","def set_multi(self, mapping): \"\"\"Place new values in the cache under the given keys.","if expiration_time_is_callable \\ else expiration_time if asdict: def dict_create(*keys): d_values = creator(*keys) return","via the :meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1 \"\"\" return 'backend' in self.__dict__","def get(self, key, expiration_time=None, ignore_expiration=False): \"\"\"Return a value from the cache, based on","aren't generated or need regeneration will be assembled into a new argument list,","between a cached value of ``None``. By default, the configured expiration time of","convert values to a dictionary, use ``zip()``:: keys = [\"one\", \"two\", \"three\"] values","method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key) for key in keys ]","time check. .. versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param key: Key","a 0 here as # \"the value is not available\", e.g. # _has_value()","is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated and timestamp <","time of the :class:`.CacheRegion`, or alternatively the expiration time supplied by the ``expiration_time``","that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of the function with the optional namespace","based on keys corresponds to that of :meth:`.Region.get_or_create`, with the exception that the",":param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated","*dogpile lock* can be acquired or not. If it can't, it means a","Another typical mangler is the built-in Python function ``str``, which can be used","def my_key_generator(namespace, fn, **kw): fname = fn.__name__ def generate_key(*arg): return namespace + \"_\"","namespace] + [str(x) for x in arg] ) return generate_key Where the decorator","= region.get_multi([\"one\", \"two\", \"three\"]) To convert values to a dictionary, use ``zip()``:: keys",":ref:`changing_backend_behavior` :param replace_existing_backend: if True, the existing cache backend will be replaced. Without","and called by dogpile.lock when there is a stale value present in the","region or the method is given a non-None expiration time. .. versionadded:: 0.3.0","number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if","this region.\") @property def is_configured(self): \"\"\"Return True if the backend has been configured",":class:`.CacheRegion` itself is returned. :param backend: Required. This is the name of the","does not exist or is considered to be expired based on its creation","still returned, but isn't cached. E.g.:: def dont_cache_none(value): return value is not None","!= value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\"ct\"])): raise NeedRegenerationException() ct = value.metadata[\"ct\"] if self.region_invalidator.is_soft_invalidated(ct): ct","of cache keys using a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the","itself is returned. :param backend: Required. This is the name of the :class:`.CacheBackend`","in use, though is typically a dictionary. :param wrap: Optional. A list of","result) if v is not NO_VALUE) else: result = self.get_or_create_multi( keys, creator, timeout,"],"string":"[\n \"a sequence of keys derived from the function itself and the arguments passed\",\n \"async_creator) as value: return value def get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return\",\n \"or not. If it returns False, the value is still returned, but isn't\",\n \"region.get_or_create(\\\"some key\\\", create_value, should_cache_fn=dont_cache_none) Above, the function returns the value of create_value() if\",\n \"v in zip(keys_to_get, new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v)\",\n \"the given arguments. Such as:: def my_key_generator(namespace, fn, **kw): fname = fn.__name__ def\",\n \"self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v)) for k, v in mapping.items()) else: mapping\",\n \"returns a value to be used as the ``expiration_time``. This callable will be\",\n \"with that subset of arguments. The returned result is a list:: result =\",\n \"to decorated function. Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as those\",\n \"or by the key_mangler function, if present. :param creator: function which creates a\",\n \"**kw): namespace = fn.__name__ + (namespace or '') def generate_keys(*args): return [namespace +\",\n \"region invalidation time and region is invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError()\",\n \"Python 2.x in conjunction with Unicode keys. :param async_creation_runner: A callable that, when\",\n \"one(a, b): return a + b Above, calling ``one(3, 4)`` will produce a\",\n \"not present, the method returns the token ``NO_VALUE``. ``NO_VALUE`` evaluates to False, but\",\n \"threading _backend_loader = PluginLoader(\\\"dogpile.cache\\\") register_backend = _backend_loader.register from . import backends # noqa\",\n \"the cache is invalid, however if the return value is None, it won't\",\n \"- optional gen that also uses keyword arguments :param function_multi_key_generator: Optional. Similar to\",\n \"value is still returned, but isn't cached. E.g.:: def dont_cache_none(value): return value is\",\n \"if ``timestamp`` is older than the last region invalidation time. \\\"\\\"\\\" raise NotImplementedError()\",\n \"cache backend. :param name: Optional, a string name for the region. This isn't\",\n \"keys and values to set in the cache:: generate_something.set({\\\"k1\\\": \\\"value1\\\", \\\"k2\\\": \\\"value2\\\", \\\"k3\\\":\",\n \"self def wrap(self, proxy): ''' Takes a ProxyBackend instance or class and wraps\",\n \"None: expiration_time = self.expiration_time current_time = time.time() def value_fn(value): if value is NO_VALUE:\",\n \"# noqa value_version = 1 \\\"\\\"\\\"An integer placed in the :class:`.CachedValue` so that\",\n \"True if ``timestamp`` is older than the last region invalidation time and region\",\n \"= time.time() def value_fn(value): if value is NO_VALUE: return value elif expiration_time is\",\n \"raise NotImplementedError() def was_hard_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in hard mode. :return:\",\n \"future by way of, for example, a background thread, a long-running queue, or\",\n \"date or time passes\\\". .. versionchanged:: 0.5.0 ``expiration_time`` may be passed as a\",\n \"supersede the one configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso::\",\n \"present on :func:`.make_region` and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`. :param namespace: optional string\",\n \"keys): \\\"\\\"\\\"Remove multiple values from the cache. This operation is idempotent (can be\",\n \"is invalid, however if the return value is None, it won't be cached.\",\n \"a dictionary of keys->values, and the final result of calling the decorated function\",\n \"2.x, the ``unicode()`` builtin can be substituted, but note this will produce unicode\",\n \"time (as reported by ``time.time()``). If stale, the cached value is ignored and\",\n \"expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass try: if mutexes: # sort the\",\n \"older than the last region invalidation time and region is invalidated in soft\",\n \"can detect cached values from a previous, backwards-incompatible version. \\\"\\\"\\\" class RegionInvalidationStrategy(object): \\\"\\\"\\\"Region\",\n \"system. May be passed as an integer number of seconds, or as a\",\n \"has been called, and the retrieved value's timestamp is older than the invalidation\",\n \"(expiration_time is None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \\\"Non-None expiration time required \\\" \\\"for\",\n \"its result as a dictionary of keys->values, and the final result of calling\",\n \"resolved by loading the class from the ``dogpile.cache`` entrypoint. :param expiration_time: Optional. The\",\n \"if the value should actually be cached or not. If it returns False,\",\n \"compat.callable(expiration_time) if function_key_generator is None: function_key_generator = self.function_key_generator def decorator(fn): if to_str is\",\n \"if no previous value is available, until the lock is released and a\",\n \"used depends on if the *dogpile lock* can be acquired or not. If\",\n \"function itself and the arguments passed to it. This method is the \\\"multiple\",\n \"creator() cache.set(somekey, value) finally: mutex.release() thread = threading.Thread(target=runner) thread.start() region = make_region( async_creation_runner=async_creation_runner,\",\n \"so that custom functionality augmentation can be applied. .. versionadded:: 0.5.0 .. seealso::\",\n \"a value from the cache, based on the given key. If the value\",\n \"is not NO_VALUE else value for value in ( _unexpired_value_fn(value) for value in\",\n \"cache. :param asdict: if ``True``, the decorated function should return its result as\",\n \"creator(*keys) return [ d_values.get(key_lookup[k], NO_VALUE) for k in keys] def wrap_cache_fn(value): if value\",\n \"the new one is available. Usage of \\\"soft\\\" invalidation requires that the region\",\n \"the keys, the idea is to prevent deadlocks. # though haven't been able\",\n \"to :meth:`.CacheRegion.get_or_create_multi`. This function is given a value as returned by the creator,\",\n \"is raised if a backend is already configured. .. versionadded:: 0.5.7 :param region_invalidator:\",\n \"normally. The decorator will produce a list of cache keys using a mechanism\",\n \"is invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError() def is_soft_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp\",\n \"cache under the given keys. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not mapping: return\",\n \"if value is NO_VALUE: return False elif not should_cache_fn: return True else: return\",\n \"a per-region basis using the ``function_key_generator`` argument present on :func:`.make_region` and :class:`.CacheRegion`. If\",\n \"versionadded:: 0.5.7 :param region_invalidator: Optional. Override default invalidation strategy with custom implementation of\",\n \"is None, it won't be cached. .. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` -\",\n \"% prefix, None), ) @memoized_property def backend(self): raise exception.RegionNotConfigured( \\\"No backend is configured\",\n \"function which creates a new value. :param expiration_time: optional expiration time which will\",\n \"will that value be placed in the cache. :param asdict: if ``True``, the\",\n \"classes - note that the decorator itself can't see the parent class on\",\n \"is not None and \\\\ current_time - value.metadata[\\\"ct\\\"] > expiration_time: return NO_VALUE elif\",\n \"the last region invalidation time. \\\"\\\"\\\" raise NotImplementedError() def was_soft_invalidated(self): \\\"\\\"\\\"Indicate the region\",\n \"creation time is older than the last call to :meth:`.invalidate`. :param key: Key\",\n \"self.is_invalidated(timestamp) class CacheRegion(object): \\\"\\\"\\\"A front end to a particular cache backend. :param name:\",\n \"cache backend will be used. A typical mangler is the SHA1 mangler found\",\n \"token ``NO_VALUE`` if no such key exists:: value = generate_something.get(5, 6) .. versionadded::\",\n \"new value is needed:: result = generate_something(5, 6) The function is also given\",\n \"in the cache. Whether or not the function is used depends on if\",\n \"class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \\\"\\\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self,\",\n \"Override default invalidation strategy with custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \\\"\\\"\\\"\",\n \"bypasses the expiration time check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks the value's\",\n \"raise NotImplementedError() def was_soft_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in soft mode. :return:\",\n \"can be of any form. For example, it can be passed as a\",\n \":return: Boolean. True if ``timestamp`` is older than the last region invalidation time.\",\n \"functions to later points in the future by way of, for example, a\",\n \"recommended by the cache backend will be used. A typical mangler is the\",\n \"values = fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for a in arg])) )\",\n \"which will store a given value directly without calling the decorated function. The\",\n \"} local_region.configure_from_config(myconfig, \\\"cache.local.\\\") memcached_region.configure_from_config(myconfig, \\\"cache.memcached.\\\") \\\"\\\"\\\" config_dict = coerce_string_conf(config_dict) return self.configure( config_dict[\\\"%sbackend\\\" %\",\n \"versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is\",\n \"a prefix. Example:: local_region = make_region() memcached_region = make_region() # regions are ready\",\n \"configured on this :class:`.CacheRegion` if not None. To set no expiration, use the\",\n \"_unexpired_value_fn(value) for value in backend_values ) ] def get_or_create( self, key, creator, expiration_time=None,\",\n \"key, value): \\\"\\\"\\\"Place a new value in the cache under the given key.\\\"\\\"\\\"\",\n \"function. See that method for additional behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x, y):\",\n \"tested against the creation time of the retrieved value versus the current time\",\n \"at configure time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy())\",\n \"= function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy()\",\n \"methods. Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\\\"foo\\\") def one(self, a, b): return a\",\n \"self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper) if\",\n \"self.lock = threading.Lock() def acquire(self, wait=True): return self.lock.acquire(wait) def release(self): self.lock.release() def _create_mutex(self,\",\n \"the \\\"minimum creation time\\\" for a value. Any retrieved value whose creation time\",\n \"function ``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\\\"foo\\\") def one(a, b): return a +\",\n \"(using ``time.time()``) representing the \\\"minimum creation time\\\" for a value. Any retrieved value\",\n \"use, though is typically a dictionary. :param wrap: Optional. A list of :class:`.ProxyBackend`\",\n \"typical for a key to be a string, it is ultimately passed directly\",\n \"``function_key_generator`` parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list of\",\n \"applies :meth:`.get_or_create` to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version\",\n \"data will be pulled from the cache region unless a new value is\",\n \"and arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method. The structure of this function should\",\n \"the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key) for key in\",\n \"key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys = arg\",\n \"k in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\\\ else expiration_time if asdict:\",\n \"value returned by the \\\"creator\\\", and will then return True or False, indicating\",\n \"10.0.0.1\\\", } local_region.configure_from_config(myconfig, \\\"cache.local.\\\") memcached_region.configure_from_config(myconfig, \\\"cache.memcached.\\\") \\\"\\\"\\\" config_dict = coerce_string_conf(config_dict) return self.configure( config_dict[\\\"%sbackend\\\"\",\n \"as set by the :meth:`.invalidate` method. If a value is present, but its\",\n \"cache. When the dogpile lock cannot be acquired, the method will block if\",\n \":meth:`.CacheRegion.set` which will store a given value directly without calling the decorated function.\",\n \"0.4.3 :param to_str: callable, will be called on each function argument in order\",\n \"decorate(*arg, **kw): key = key_generator(*arg, **kw) @wraps(fn) def creator(): return fn(*arg, **kw) timeout\",\n \"a background thread, a long-running queue, or a task manager system like Celery.\",\n \"not keys: return [] if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) backend_values\",\n \"values_w_created = dict( (orig_to_mangled[k], self._value(v)) for k, v in zip(keys_to_get, new_values) ) if\",\n \"backend will be replaced. Without this flag, an exception is raised if a\",\n \"on a per-region basis using the ``function_key_generator`` argument present on :func:`.make_region` and :class:`.CacheRegion`.\",\n \"\\\"\\\"\\\"Check timestamp to determine if it was invalidated. :return: Boolean. True if ``timestamp``\",\n \"that custom functionality augmentation can be applied. .. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior`\",\n \"``MyOtherClass`` names, as the function is received by the decorator before it becomes\",\n \"derived from the function itself and the arguments passed to it. This method\",\n \"mapping = dict((k, self._value(v)) for k, v in mapping.items()) self.backend.set_multi(mapping) def delete(self, key):\",\n \"NotImplementedError() def is_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was invalidated. :return:\",\n \"blocking. If the :meth:`.invalidate` method has been called, and the retrieved value's timestamp\",\n \":param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This function is given a value as returned\",\n \"if it returns True will that value be placed in the cache. :param\",\n \"invalidate decorate.refresh = refresh decorate.get = get return decorate return decorator def make_region(*arg,\",\n \"of keys and returns a sequence of new values. :param expiration_time: optional expiration\",\n \"``True``, the decorated function should return its result as a dictionary of keys->values,\",\n \"should return the generated values as a sequence corresponding to the order of\",\n \"seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" def get_value(key): value = values.get(key, NO_VALUE) if (value is\",\n \"passes\\\". .. versionchanged:: 0.5.0 ``expiration_time`` may be passed as a callable to :meth:`.CacheRegion.cache_on_arguments`.\",\n \"example, it can be passed as a tuple, used to specify arguments to\",\n \"already. .. versionadded:: 0.5.1 \\\"\\\"\\\" return 'backend' in self.__dict__ def get(self, key, expiration_time=None,\",\n \"gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass try: if mutexes:\",\n \"the value is still returned, but isn't cached. .. versionadded:: 0.5.0 .. seealso::\",\n \"cache keys which may require key mangling before reaching the cache. .. versionadded::\",\n \"expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time is\",\n \"dictionary and a prefix. Example:: local_region = make_region() memcached_region = make_region() # regions\",\n \"ignore_expiration: return lambda value: value else: if expiration_time is None: expiration_time = self.expiration_time\",\n \"values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in orig_to_mangled.items(): with Lock( self._mutex(mangled_key), gen_value,\",\n \"the end of the day, week or time period\\\" and \\\"cache until a\",\n \"result = dict( (k, v) for k, v in zip(cache_keys, result) if v\",\n \"NO_VALUE else: return value return value_fn def get_multi(self, keys, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return multiple\",\n \"mangling before reaching the cache. .. versionadded:: 0.5.0 :param function_multi_key_generator: a function that\",\n \"invalidated. \\\"\\\"\\\" raise NotImplementedError() def is_hard_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it\",\n \"the key based on the given arguments. Such as:: def my_key_generator(namespace, fn, **kw):\",\n \"= values.get(key, NO_VALUE) if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated(\",\n \"mutex.release() thread = threading.Thread(target=runner) thread.start() region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={\",\n \"be expired based on its creation time, the given creation function may or\",\n \"and timestamp < self._soft_invalidated) The custom implementation is injected into a :class:`.CacheRegion` at\",\n \"self.backend = proxy.wrap(self.backend) def _mutex(self, key): return self._lock_registry.get(key) class _LockWrapper(object): \\\"\\\"\\\"weakref-capable wrapper for\",\n \"Key to be retrieved. While it's typical for a key to be a\",\n \"and only if it returns True will that value be placed in the\",\n \":param creator: function which creates a new value. :param expiration_time: optional expiration time\",\n \"the function were to produce the value ``3`` as the value to be\",\n \":meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1 \\\"\\\"\\\" return 'backend' in self.__dict__ def get(self,\",\n \"orig_key, creator, mutex) else: async_creator = None with Lock( self._mutex(key), gen_value, get_value, expiration_time,\",\n \"``refresh()`` method to decorated function. Lastly, the ``get()`` method returns either the value\",\n \"``myapp.tools:one|foo|3 4`` - the name ``self`` is skipped. The ``namespace`` parameter is optional,\",\n \"None), ) @memoized_property def backend(self): raise exception.RegionNotConfigured( \\\"No backend is configured on this\",\n \"``creator()`` should return the generated values as a sequence corresponding to the order\",\n \"Lock, NeedRegenerationException from ..util import NameRegistry from . import exception from ..util import\",\n \"value present in the cache. It will be passed the mutex and is\",\n \"self.lock.release() def _create_mutex(self, key): mutex = self.backend.get_mutex(key) if mutex is not None: return\",\n \"it is ultimately passed directly down to the cache backend, before being optionally\",\n \"the same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string argument\",\n \"cached or not. If it returns False, the value is still returned, but\",\n \"ultimately wrap the original backend, so that custom functionality augmentation can be applied.\",\n \"which can be used to convert non-string or Unicode keys to bytestrings, which\",\n \"timestamp is older than the invalidation timestamp, the value is unconditionally prevented from\",\n \"basis using the ``function_key_generator`` argument present on :func:`.make_region` and :class:`.CacheRegion`. If defaults to\",\n \"the same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and set values from\",\n \"0.5.0 ``expiration_time`` may be passed as a callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed\",\n \"with custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \\\"\\\"\\\" if \\\"backend\\\" in self.__dict__\",\n \"can be of any type recognized by the backend or by the key_mangler\",\n \"\\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is None: function_key_generator = self.function_key_generator def decorator(fn):\",\n \"somemethod(self, x, y): \\\"\\\" Above, the ``namespace`` parameter disambiguates between ``somemethod`` on ``MyClass``\",\n \"the :meth:`.CacheRegion.get` method) will call upon the value creation function after this time\",\n \"from a previous, backwards-incompatible version. \\\"\\\"\\\" class RegionInvalidationStrategy(object): \\\"\\\"\\\"Region invalidation strategy interface Implement\",\n \"to generate any subset of the given keys. The list of keys to\",\n \"given a value.\\\"\\\"\\\" return CachedValue( value, { \\\"ct\\\": time.time(), \\\"v\\\": value_version }) def\",\n \"async_creator = None with Lock( self._mutex(key), gen_value, get_value, expiration_time, async_creator) as value: return\",\n \"hard mode. \\\"\\\"\\\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated = None self._invalidated\",\n \"value = fn(*arg, **kw) self.set(key, value) return value decorate.set = set_ decorate.invalidate =\",\n \"as the class is being declared. :param expiration_time: if not None, will override\",\n \"exists:: value = generate_something.get(5, 6) .. versionadded:: 0.5.3 Added ``get()`` method to decorated\",\n \"value of create_value() if the cache is invalid, however if the return value\",\n \"placed in the :class:`.CachedValue` so that new versions of dogpile.cache can detect cached\",\n \"a new value in the cache under the given key.\\\"\\\"\\\" if self.key_mangler: key\",\n \"the backend or by the key_mangler function, if present. :param expiration_time: Optional expiration\",\n \"value = self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration:\",\n \"= region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \\\"\\\"\\\" def invalidate(self, hard=True): \\\"\\\"\\\"Region\",\n \"DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ):\",\n \"by the decorator before it becomes an instance method. The function key generation\",\n \"if asdict: def dict_create(*keys): d_values = creator(*keys) return [ d_values.get(key_lookup[k], NO_VALUE) for k\",\n \"a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned. :param backend: Required. This is the\",\n \"method for :meth:`.CacheRegion.set` which will store a given value directly without calling the\",\n \"and set values from the backend. If you are using a :class:`.CacheBackend` or\",\n \"the one configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments`\",\n \"consulted outside this function, so in fact can be of any form. For\",\n \"Unicode keys to bytestrings, which is needed when using a backend such as\",\n \"like Celery. For a specific example using async_creation_runner, new values can be created\",\n \"raise exception.DogpileCacheException( \\\"Non-None expiration time required \\\" \\\"for soft invalidation\\\") if expiration_time ==\",\n \"expiration_time = self.expiration_time if (expiration_time is None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \\\"Non-None expiration\",\n \"result is a list:: result = generate_something(\\\"key1\\\", \\\"key2\\\", \\\"key3\\\") The decorator internally makes\",\n \"or on a non-existent key, safely) \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.delete(key)\",\n \"versionadded 0.5.0 ``expiration_time`` may be optionally passed as a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create`\",\n \"the :class:`.CacheRegion` itself. .. versionadded:: 0.3.0 :param ignore_expiration: if ``True``, the value is\",\n \"list are returned as the ``NO_VALUE`` token. ``NO_VALUE`` evaluates to False, but is\",\n \"is called, in caching or retrieving. Thus, this can be used to determine\",\n \"function that will produce a \\\"cache key\\\". This function will supersede the one\",\n \"self._value(v)) for k, v in zip(keys_to_get, new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created) else:\",\n \"Number): self.expiration_time = expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else: raise\",\n \"decorator before it becomes an instance method. The function key generation can be\",\n \"mangled_key in orig_to_mangled.items(): with Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key,\",\n \"NO_VALUE) for k in keys] def wrap_cache_fn(value): if value is NO_VALUE: return False\",\n \"was invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated\",\n \"return (self._invalidated is not None and timestamp < self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated\",\n \"passed to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside this function, so in fact can\",\n \"__init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \\\"\\\"\\\"Construct a new :class:`.CacheRegion`.\\\"\\\"\\\" self.name\",\n \"having awareness of the ``MyClass`` and ``MyOtherClass`` names, as the function is received\",\n \"which will be established as part of the cache key. This may be\",\n \"``get()`` method to decorated function. The default key generation will use the name\",\n \"produce a list of cache keys using a mechanism similar to that of\",\n \"additional behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a single\",\n \"and will then return True or False, indicating if the value should actually\",\n \"creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a cached value based on the given key. If\",\n \"= async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None,\",\n \"may be asked to generate any subset of the given keys. The list\",\n \"sequence of keys and returns a sequence of new values. :param expiration_time: optional\",\n \"disabled and is set to ``None``. .. versionadded:: 0.4.2 added the async_creation_runner feature.\",\n \"\\\"the value is not available\\\", e.g. # _has_value() will return False. return value.payload,\",\n \"function, the arguments passed, as well as an optional \\\"namespace\\\" parameter in order\",\n \"self.set(key, value) return value decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh\",\n \"should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k in keys] finally: for mutex in\",\n \"The custom implementation is injected into a :class:`.CacheRegion` at configure time using the\",\n \"# ... region = CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 .. seealso::\",\n \"**kw): fname = fn.__name__ def generate_key(*arg): return namespace + \\\"_\\\" + fname +\",\n \"a dictionary. If left at its default value of ``False``, the decorated function\",\n \".. versionadded:: 0.3.0 :param ignore_expiration: if ``True``, the value is returned from the\",\n \"if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k in keys] finally: for mutex\",\n \"to distinguish between a cached value of ``None``. By default, the configured expiration\",\n \"E.g.:: @someregion.cache_on_arguments() def generate_something(x, y): return somedatabase.query(x, y) The decorated function can then\",\n \"the day, week or time period\\\" and \\\"cache until a certain date or\",\n \"*arg, **kw): key = key_generator(*arg, **kw) self.set(key, value) def get(*arg, **kw): key =\",\n \"dict( (orig_to_mangled[k], self._value(v)) for k, v in zip(keys_to_get, new_values) ) if not should_cache_fn:\",\n \"- the name ``self`` is skipped. The ``namespace`` parameter is optional, and is\",\n \"passed to and called by dogpile.lock when there is a stale value present\",\n \"region # ... # ... region = CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded::\",\n \"the cache, based on the given keys. Returns values as a list matching\",\n \"== -1: expiration_time = None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self, orig_key,\",\n \"a, b): return a + b The cache key above for ``MyClass().one(3, 4)``\",\n \"\\\"hard\\\" invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate regeneration of the value which all\",\n \"the backend. If you are using a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies values,\",\n \"was_soft_invalidated(self): return self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class\",\n \"backend is already configured. .. versionadded:: 0.5.7 :param region_invalidator: Optional. Override default invalidation\",\n \"if the creation time is older than the last call to :meth:`.invalidate`. :param\",\n \"optional expiration time which will overide the expiration time already configured on this\",\n \"RegionInvalidationStrategy(object): \\\"\\\"\\\"Region invalidation strategy interface Implement this interface and pass implementation instance to\",\n \"value is not NO_VALUE else value for value in ( _unexpired_value_fn(value) for value\",\n \"a given value directly without calling the decorated function. The value to be\",\n \"# _has_value() will return False. return value.payload, 0 else: ct = value.metadata[\\\"ct\\\"] if\",\n \"= value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time - .0001 return value.payload,\",\n \"by the :meth:`.invalidate` method. If a value is present, but its creation time\",\n \"return value.payload, ct def gen_value(): raise NotImplementedError() def async_creator(key, mutex): mutexes[key] = mutex\",\n \"arguments passed, as well as an optional \\\"namespace\\\" parameter in order to generate\",\n \"as can occur when decorating instance or class methods as below:: class MyClass(object):\",\n \"argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self, region): self.region = region # ... # ...\",\n \"the decorator suitable (with caveats) for use with instance or class methods. Given\",\n \"of the :class:`.CacheRegion`, or alternatively the expiration time supplied by the ``expiration_time`` argument,\",\n \"decorate.get = get return decorate return decorator def make_region(*arg, **kw): \\\"\\\"\\\"Instantiate a new\",\n \"the :class:`.CachedValue` so that new versions of dogpile.cache can detect cached values from\",\n \":class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time)\",\n \"passthrough to :class:`.CacheRegion`. See that class for constructor arguments. \\\"\\\"\\\" return CacheRegion(*arg, **kw)\",\n \"until the new one is available. Usage of \\\"soft\\\" invalidation requires that the\",\n \"or the token ``NO_VALUE`` if no such key exists:: value = generate_something.get(5, 6)\",\n \"times, or on a non-existent key, safely) \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key)\",\n \"well as the :meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not** the :meth:`.CacheRegion.get` method) will call\",\n \"be used. A typical mangler is the SHA1 mangler found at :func:`.sha1_mangle_key` which\",\n \"acquired, the method will block if no previous value is available, until the\",\n \"is None: function_key_generator = self.function_key_generator def decorator(fn): if to_str is compat.string_type: # backwards\",\n \"associated with classes - note that the decorator itself can't see the parent\",\n \"if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False):\",\n \"value available. If a previous value is available, that value is returned immediately\",\n \"the expiration time, rather than returning the value unconditionally. The method also interprets\",\n \"result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result def invalidate(*arg): keys =\",\n \"the key mangling function recommended by the cache backend will be used. A\",\n \"def refresh(*arg, **kw): key = key_generator(*arg, **kw) value = fn(*arg, **kw) self.set(key, value)\",\n \"retrieved. While it's typical for a key to be a string, it is\",\n \"class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated = None self._hard_invalidated = None def invalidate(self, hard=None):\",\n \"x, y): \\\"\\\" Above, the ``namespace`` parameter disambiguates between ``somemethod`` on ``MyClass`` and\",\n \"...a ``refresh()`` method, which will call the creation function, cache the new values,\",\n \"the one configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments`\",\n \"= list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type,\",\n \"value into the cache with the new value, as well as returning that\",\n \"to use for function # decorators, but not yet for actual caching #\",\n \"attribute ``invalidate()``, which provides for invalidation of the value. Pass to ``invalidate()`` the\",\n \"is disabled and is set to ``None``. .. versionadded:: 0.4.2 added the async_creation_runner\",\n \"invoked. .. versionadded:: 0.5.1 \\\"\\\"\\\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict, prefix): \\\"\\\"\\\"Configure from a\",\n \"the same name within the same source file, such as those associated with\",\n \"meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string argument which will\",\n \"the arguments passed to it. This method is the \\\"multiple key\\\" analogue to\",\n \"integer or a callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This function is given\",\n \"may be passed as a callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`.\",\n \"With \\\"hard\\\" invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate regeneration of the value which\",\n \":class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time)\",\n \"consider all older timestamps effectively invalidated. \\\"\\\"\\\" raise NotImplementedError() def is_hard_invalidated(self, timestamp): \\\"\\\"\\\"Check\",\n \"loading the class from the ``dogpile.cache`` entrypoint. :param expiration_time: Optional. The expiration time\",\n \"is passed directly to the constructor of the :class:`.CacheBackend` in use, though is\",\n \"expiration_time, ignore_expiration)(value) return value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration: return lambda value:\",\n \"promptly. They will be refreshed by whatever asynchronous means the provided async_creation_runner callable\",\n \"itself can't see the parent class on a function as the class is\",\n \"bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp < self._soft_invalidated) The custom implementation\",\n \"expiration_time: Optional expiration time value which will supersede that configured on the :class:`.CacheRegion`\",\n \"is unconditionally regenerated if the creation time is older than the last call\",\n \"a non-existent key, safely) \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.delete(key) def delete_multi(self,\",\n \"The decorator will produce a list of cache keys using a mechanism similar\",\n \"True if region was invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy):\",\n \"is returned. Passing the flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionchanged::\",\n \"self.backend.set(key, value) return value.payload, value.metadata[\\\"ct\\\"] if expiration_time is None: expiration_time = self.expiration_time if\",\n \"to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable, will be called on each\",\n \"mutex else: return self._LockWrapper() def invalidate(self, hard=True): \\\"\\\"\\\"Invalidate this :class:`.CacheRegion`. The default invalidation\",\n \"example is equivalent to calling ``generate_something(5, 6)``, if the function were to produce\",\n \"set to ``False``. Another typical mangler is the built-in Python function ``str``, which\",\n \"or the method is given a non-None expiration time. .. versionadded:: 0.3.0 :param\",\n \"mutex: async_creator(orig_key, mutex) ): pass try: if mutexes: # sort the keys, the\",\n \":func:`.sha1_mangle_key` which coerces keys into a SHA1 hash, so that the string length\",\n \"example, a background thread, a long-running queue, or a task manager system like\",\n \"passed as an integer number of seconds, or as a ``datetime.timedelta`` value. ..\",\n \"expiration, use the value -1. :param should_cache_fn: optional callable function which will receive\",\n \"be passed to and called by dogpile.lock when there is a stale value\",\n \"_config_argument_dict=config_dict, _config_prefix=\\\"%sarguments.\\\" % prefix, wrap=config_dict.get( \\\"%swrap\\\" % prefix, None), ) @memoized_property def backend(self):\",\n \"processed by the key_mangler function, so can be of any type recognized by\",\n \"expiration time which will overide the expiration time already configured on this :class:`.CacheRegion`\",\n \"expiration_time, ignore_expiration) return [ value.payload if value is not NO_VALUE else value for\",\n \"accepts a sequence of keys and returns a sequence of new values. :param\",\n \"as the ``expiration_time``. This callable will be called whenever the decorated function itself\",\n \"not None. To set no expiration, use the value -1. :param should_cache_fn: optional\",\n \"or not the function is used depends on if the *dogpile lock* can\",\n \"to get and set values from the backend. If you are using a\",\n \"to override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated = None\",\n \"DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated = None self._invalidated = None def invalidate(self, hard=True): self._is_hard_invalidated\",\n \"(value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands\",\n \"value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\\\"ct\\\"])): raise NeedRegenerationException() ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct =\",\n \"dogpile system. May be passed as an integer number of seconds, or as\",\n \":param expiration_time: optional expiration time which will overide the expiration time already configured\",\n \"''' Used by dogpile.core:Lock when appropriate ''' def runner(): try: value = creator()\",\n \"True or False, indicating if the value should actually be cached or not.\",\n \"function is then called with that subset of arguments. The returned result is\",\n \"= creator(*keys) return [ d_values.get(key_lookup[k], NO_VALUE) for k in keys] def wrap_cache_fn(value): if\",\n \"if it was invalidated. :return: Boolean. True if ``timestamp`` is older than the\",\n \"will also be a dictionary. If left at its default value of ``False``,\",\n \"= None self._hard_invalidated = None def invalidate(self, hard=None): if hard: self._soft_invalidated = None\",\n \"The decorated function can be called normally. The decorator will produce a list\",\n \"A function that will produce a \\\"cache key\\\" given a data creation function\",\n \"else expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key = key_generator(*arg,\",\n \"the function. This is a convenience method for :meth:`.CacheRegion.set` which will store a\",\n \":meth:`.CacheRegion.get_or_create_multi` method to access the cache and conditionally call the function. See that\",\n \"keys. For example:: def my_multi_key_generator(namespace, fn, **kw): namespace = fn.__name__ + (namespace or\",\n \"data creation function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method. The structure of\",\n \"expiration_time: optional expiration time which will overide the expiration time already configured on\",\n \".. versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param key: Key to be\",\n \"Function which will be used on all incoming keys before passing to the\",\n \"\\\"k2\\\", \\\"k3\\\") ...a ``refresh()`` method, which will call the creation function, cache the\",\n \"if mutex is not None: return mutex else: return self._LockWrapper() def invalidate(self, hard=True):\",\n \"def configure_from_config(self, config_dict, prefix): \\\"\\\"\\\"Configure from a configuration dictionary and a prefix. Example::\",\n \"directly without calling the decorated function. The value to be cached is passed\",\n \"follows:: myapp.tools:one|foo|3 4 The key generator will ignore an initial argument of ``self``\",\n \"behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x, y): return somedatabase.query(x, y) The decorated function\",\n \"and \\\\ current_time - value.metadata[\\\"ct\\\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\\\"ct\\\"]): return\",\n \"values based on a sequence of keys. The behavior for generation of values\",\n \"call. The default invalidation system works by setting a current timestamp (using ``time.time()``)\",\n \"((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated and timestamp < self._hard_invalidated)) def was_hard_invalidated(self):\",\n \"raise NeedRegenerationException() ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time -\",\n \"bypasses the invalidation time check. .. versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate` method.\",\n \"on ``MyClass`` and ``MyOtherClass``. Python class declaration mechanics otherwise prevent the decorator from\",\n \"defaults to :func:`.function_key_generator`. :param namespace: optional string argument which will be established as\",\n \"the cached function result. Example use cases include \\\"cache the result until the\",\n \"expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return multiple values from the cache, based on the given keys.\",\n \"versionadded:: 0.5.0 \\\"\\\"\\\" if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def\",\n \"new versions of dogpile.cache can detect cached values from a previous, backwards-incompatible version.\",\n \"if it was soft invalidated. :return: Boolean. True if ``timestamp`` is older than\",\n \"by the backend or by the key_mangler function, if present. :param expiration_time: Optional\",\n \"versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" def get_value(key): value = values.get(key, NO_VALUE)\",\n \"for mutex in mutexes.values(): mutex.release() def _value(self, value): \\\"\\\"\\\"Return a :class:`.CachedValue` given a\",\n \"replace_existing_backend: if True, the existing cache backend will be replaced. Without this flag,\",\n \"NO_VALUE) if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): #\",\n \":class:`.CacheRegion` itself. .. versionadded:: 0.3.0 :param ignore_expiration: if ``True``, the value is returned\",\n \"the async_creation_runner is disabled and is set to ``None``. .. versionadded:: 0.4.2 added\",\n \"and its arguments. The decorator internally makes use of the :meth:`.CacheRegion.get_or_create` method to\",\n \"keys using the same mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...a\",\n \"newly generated values using the same values it returns to the calling function.\",\n \"will always block; async_creator will not be invoked. However, subsequent requests for cached-but-expired\",\n \".. versionadded:: 0.5.1 \\\"\\\"\\\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict, prefix): \\\"\\\"\\\"Configure from a configuration\",\n \"will call the creation function, cache the new values, and return them:: values\",\n \"key = key_generator(*arg, **kw) @wraps(fn) def creator(): return fn(*arg, **kw) timeout = expiration_time()\",\n \"import NO_VALUE, CachedValue from .proxy import ProxyBackend from ..util import compat import time\",\n \"of create_value() if the cache is invalid, however if the return value is\",\n \"k, v in mapping.items()) else: mapping = dict((k, self._value(v)) for k, v in\",\n \"can be substituted, but note this will produce unicode cache keys which may\",\n \"so that new versions of dogpile.cache can detect cached values from a previous,\",\n \"def _value(self, value): \\\"\\\"\\\"Return a :class:`.CachedValue` given a value.\\\"\\\"\\\" return CachedValue( value, {\",\n \"a string. Defaults to ``str()``. If the function accepts non-ascii unicode arguments on\",\n \"given. E.g.:: values = region.get_multi([\\\"one\\\", \\\"two\\\", \\\"three\\\"]) To convert values to a dictionary,\",\n \"passed as an integer or a callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This\",\n \"asdict: self.set_multi( dict(zip(keys, [values[a] for a in arg])) ) return values else: self.set_multi(\",\n \"= region # ... # ... region = CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) ..\",\n \"= None def invalidate(self, hard=True): self._is_hard_invalidated = bool(hard) self._invalidated = time.time() def is_invalidated(self,\",\n \"the submitted ``mapping`` dict. :param keys: Sequence of keys to be retrieved. :param\",\n \"expiration time required \\\" \\\"for soft invalidation\\\") if expiration_time == -1: expiration_time =\",\n \"\\\"\\\"\\\"weakref-capable wrapper for threading.Lock\\\"\\\"\\\" def __init__(self): self.lock = threading.Lock() def acquire(self, wait=True): return\",\n \"= sorted(mutexes) new_values = creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k], self._value(v)) for k, v\",\n \"make_region( function_key_generator = my_key_generator ).configure( \\\"dogpile.cache.dbm\\\", expiration_time=300, arguments={ \\\"filename\\\":\\\"file.dbm\\\" } ) The ``namespace``\",\n \"memcached_region = make_region() # regions are ready to use for function # decorators,\",\n \"are ready to use for function # decorators, but not yet for actual\",\n \"\\\"%sexpiration_time\\\" % prefix, None), _config_argument_dict=config_dict, _config_prefix=\\\"%sarguments.\\\" % prefix, wrap=config_dict.get( \\\"%swrap\\\" % prefix, None),\",\n \"method uses the same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and set\",\n \"created in a background thread like so:: import threading def async_creation_runner(cache, somekey, creator,\",\n \"in hard mode. \\\"\\\"\\\" raise NotImplementedError() def is_soft_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine\",\n \"details. E.g.:: @someregion.cache_on_arguments() def generate_something(x, y): return somedatabase.query(x, y) The decorated function can\",\n \"require key mangling before reaching the cache. .. versionadded:: 0.5.0 :param function_multi_key_generator: a\",\n \"values; the originally passed keys corresponding to those values which aren't generated or\",\n \"Thus, this can be used to determine a *dynamic* expiration time for the\",\n \"If the function accepts non-ascii unicode arguments on Python 2.x, the ``unicode()`` builtin\",\n \"ignore_expiration=False): \\\"\\\"\\\"Return multiple values from the cache, based on the given keys. Returns\",\n \"set_(value, *arg, **kw): key = key_generator(*arg, **kw) self.set(key, value) def get(*arg, **kw): key\",\n \"method. The function key generation can be entirely replaced on a per-region basis\",\n \"the decorated function itself is called, in caching or retrieving. Thus, this can\",\n \"applied in a chain to ultimately wrap the original backend, so that custom\",\n \"the function with the optional namespace and with the string form of each\",\n \"region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that wish to have access to the :class:`.CacheRegion`\",\n \"creation time of the retrieved value versus the current time (as reported by\",\n \"used to determine a *dynamic* expiration time for the cached function result. Example\",\n \"async_creator(orig_key, mutex) ): pass try: if mutexes: # sort the keys, the idea\",\n \"None def invalidate(self, hard=None): if hard: self._soft_invalidated = None self._hard_invalidated = time.time() else:\",\n \"mechanism as that of :meth:`.CacheRegion.get_multi` to retrieve all current values; the originally passed\",\n \"backend_cls(arguments or {}) if not expiration_time or isinstance(expiration_time, Number): self.expiration_time = expiration_time elif\",\n \"argument which will be established as part of each cache key. :param expiration_time:\",\n \"else expiration_time if asdict: def dict_create(*keys): d_values = creator(*keys) return [ d_values.get(key_lookup[k], NO_VALUE)\",\n \"call upon the value creation function after this time period has passed since\",\n \"expiration_time - .0001 return value.payload, ct def gen_value(): created_value = creator() value =\",\n \"as the :meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not** the :meth:`.CacheRegion.get` method) will call upon\",\n \"if region was invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError() def was_hard_invalidated(self): \\\"\\\"\\\"Indicate\",\n \":param wrap: Optional. A list of :class:`.ProxyBackend` classes and/or instances, each of which\",\n \"wraps the attached backend. ''' # if we were passed a type rather\",\n \"for value in backend_values ) ] def get_or_create( self, key, creator, expiration_time=None, should_cache_fn=None):\",\n \"a list matching the keys given. E.g.:: values = region.get_multi([\\\"one\\\", \\\"two\\\", \\\"three\\\"]) To\",\n \"it returns to the calling function. A correct implementation of ``.set_multi()`` will not\",\n \"function, return a new function that generates the key based on the given\",\n \"return a + b Above, calling ``one(3, 4)`` will produce a cache key\",\n \"analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key) for\",\n \"= int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time is not a number or timedelta.')\",\n \"``self`` is skipped. The ``namespace`` parameter is optional, and is used normally to\",\n \"backwards-incompatible version. \\\"\\\"\\\" class RegionInvalidationStrategy(object): \\\"\\\"\\\"Region invalidation strategy interface Implement this interface and\",\n \"as the ``NO_VALUE`` token. ``NO_VALUE`` evaluates to False, but is separate from ``None``\",\n \"region = CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \\\"\\\"\\\"\",\n \"additional behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x, y): return somedatabase.query(x, y) The decorated\",\n \"of which will be applied in a chain to ultimately wrap the original\",\n \"\\\"No backend is configured on this region.\\\") @property def is_configured(self): \\\"\\\"\\\"Return True if\",\n \"method. :param key: Key to be retrieved. While it's typical for a key\",\n \"is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands a\",\n \"0.5.1 \\\"\\\"\\\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict, prefix): \\\"\\\"\\\"Configure from a configuration dictionary and\",\n \"defer the computation of expensive creator functions to later points in the future\",\n \"exception.DogpileCacheException( \\\"Non-None expiration time required \\\" \\\"for soft invalidation\\\") if expiration_time == -1:\",\n \"call the function. See that method for additional behavioral details. E.g.:: @someregion.cache_on_arguments() def\",\n \"return decorate return decorator def make_region(*arg, **kw): \\\"\\\"\\\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region`\",\n \"time is prior to this timestamp is considered to be stale. It does\",\n \"length is fixed. To disable all key mangling, set to ``False``. Another typical\",\n \"on :func:`.make_region` and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`. :param namespace: optional string argument\",\n \"def wrap_cache_fn(value): if value is NO_VALUE: return False elif not should_cache_fn: return True\",\n \"time and region is invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError() def is_invalidated(self,\",\n \"\\\" \\\"Specify replace_existing_backend=True to replace.\\\" % self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend\",\n \"this instance of :class:`.CacheRegion`. Once set, the invalidation time is honored by the\",\n \"threading def async_creation_runner(cache, somekey, creator, mutex): ''' Used by dogpile.core:Lock when appropriate '''\",\n \"backend or by the key_mangler function, if present. :param creator: function which creates\",\n \"above for ``MyClass().one(3, 4)`` will again produce the same cache key of ``myapp.tools:one|foo|3\",\n \"instance method. The function key generation can be entirely replaced on a per-region\",\n \"key, safely) \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \\\"\\\"\\\"Remove\",\n \"= generate_something(5, 6) The function is also given an attribute ``invalidate()``, which provides\",\n \"\\\"\\\"\\\" raise NotImplementedError() def was_hard_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in hard mode.\",\n \"directly to the constructor of the :class:`.CacheBackend` in use, though is typically a\",\n \"= key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys = list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key,\",\n \"which will receive each value returned by the \\\"creator\\\", and will then return\",\n \"of ``.set_multi()`` will not modify values in-place on the submitted ``mapping`` dict. :param\",\n \"expiration_time = None mutexes = {} sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys =\",\n \"in keys ] The decorated function can be called normally. The decorator will\",\n \"get_or_create( self, key, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a cached value based on the\",\n \"will be passed the mutex and is responsible releasing that mutex when finished.\",\n \"are returned as the ``NO_VALUE`` token. ``NO_VALUE`` evaluates to False, but is separate\",\n \"will not modify values in-place on the submitted ``mapping`` dict. :param keys: Sequence\",\n \"in order to generate a cache key. Given a function ``one`` inside the\",\n \":param hard: if True, cache values will all require immediate regeneration; dogpile logic\",\n \"older timestamps effectively invalidated. \\\"\\\"\\\" raise NotImplementedError() def is_hard_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to\",\n \"def dont_cache_none(value): return value is not None value = region.get_or_create(\\\"some key\\\", create_value, should_cache_fn=dont_cache_none)\",\n \"The decorator internally makes use of the :meth:`.CacheRegion.get_or_create` method to access the cache\",\n \"keys, dict_create, timeout, wrap_cache_fn) result = dict( (k, v) for k, v in\",\n \"is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\\\"ct\\\"])): raise NeedRegenerationException() ct =\",\n \"that of :meth:`.Region.get_or_create`, with the exception that the ``creator()`` function may be asked\",\n \"\\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn):\",\n \"hard=True): \\\"\\\"\\\"Invalidate this :class:`.CacheRegion`. The default invalidation system works by setting a current\",\n \"method will attempt to acquire the dogpile lock to generate a new value,\",\n \"by way of, for example, a background thread, a long-running queue, or a\",\n \"which will be used on all incoming keys before passing to the backend.\",\n \"region = make_region( function_key_generator = my_key_generator ).configure( \\\"dogpile.cache.dbm\\\", expiration_time=300, arguments={ \\\"filename\\\":\\\"file.dbm\\\" } )\",\n \"which case the key mangling function recommended by the cache backend will be\",\n \"default value of ``False``, the decorated function should return its result as a\",\n \"``ignore_expiration=True`` bypasses the invalidation time check. .. versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate`\",\n \"optionally passed as a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method as well as the\",\n \"the function. See that method for additional behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method,\",\n \"creation function, cache the new values, and return them:: values = generate_something.refresh(\\\"k1\\\", \\\"k2\\\",\",\n \"implementation of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \\\"\\\"\\\" if \\\"backend\\\" in self.__dict__ and not\",\n \"fn, **kw): namespace = fn.__name__ + (namespace or '') def generate_keys(*args): return [namespace\",\n \"caching # later, when config is available myconfig = { \\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\", \\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\", \\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\",\",\n \"gen_value(): raise NotImplementedError() def async_creator(key, mutex): mutexes[key] = mutex if expiration_time is None:\",\n \"token. ``NO_VALUE`` evaluates to False, but is separate from ``None`` to distinguish between\",\n \"self.backend.set(key, self._value(value)) def set_multi(self, mapping): \\\"\\\"\\\"Place new values in the cache under the\",\n \"for s in arg) return generate_key region = make_region( function_key_generator = my_key_generator ).configure(\",\n \"region.get_multi(keys) dictionary = dict(zip(keys, values)) Keys which aren't present in the list are\",\n \"get_value(key): value = values.get(key, NO_VALUE) if (value is NO_VALUE or value.metadata['v'] != value_version\",\n \"if to_str is compat.string_type: # backwards compatible key_generator = function_key_generator(namespace, fn) else: key_generator\",\n \"timeout = expiration_time() if expiration_time_is_callable \\\\ else expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn)\",\n \"if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time - .0001 return value.payload, ct def\",\n \"mangling before reaching the cache. .. versionadded:: 0.5.0 :param function_key_generator: a function that\",\n \"as well as an optional \\\"namespace\\\" parameter in order to generate a cache\",\n \"function were to produce the value ``3`` as the value to be cached.\",\n \"all key mangling, set to ``False``. Another typical mangler is the built-in Python\",\n \"in the future by way of, for example, a background thread, a long-running\",\n \"v in zip(cache_keys, result) if v is not NO_VALUE) else: result = self.get_or_create_multi(\",\n \"region = CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that wish to have access\",\n \"will wait until the lock is released to return the new value. ..\",\n \"keys. The list of keys to be generated is passed to ``creator()``, and\",\n \"= [self.key_mangler(k) for k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys,\",\n \"or retrieving. Thus, this can be used to determine a *dynamic* expiration time\",\n \"based on the given arguments. Such as:: def my_key_generator(namespace, fn, **kw): fname =\",\n \"async_creation_runner is disabled and is set to ``None``. .. versionadded:: 0.4.2 added the\",\n \"the value unconditionally. The method also interprets the cached value in terms of\",\n \"the flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now\",\n \"or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands a 0 here as # \\\"the value\",\n \"the given key, or the token ``NO_VALUE`` if no such key exists:: value\",\n \"it was soft invalidated. :return: Boolean. True if ``timestamp`` is older than the\",\n \"``dogpile.cache`` entrypoint. :param expiration_time: Optional. The expiration time passed to the dogpile system.\",\n \"be a string, it is ultimately passed directly down to the cache backend,\",\n \"to be generated is passed to ``creator()``, and ``creator()`` should return the generated\",\n \"Added ``set()`` method to decorated function. Similar to ``set()`` is ``refresh()``. This attribute\",\n \"v in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k in keys]\",\n \"cached. E.g.:: def dont_cache_none(value): return value is not None value = region.get_or_create(\\\"some key\\\",\",\n \"argument which will be established as part of the cache key. This may\",\n \"If stale, the cached value is ignored and the ``NO_VALUE`` token is returned.\",\n \"called, and the retrieved value's timestamp is older than the invalidation timestamp, the\",\n \"immediately without blocking. If the :meth:`.invalidate` method has been called, and the retrieved\",\n \"# decorators, but not yet for actual caching # later, when config is\",\n \"'127.0.0.1:11211', 'distributed_lock': True, } ) Remember that the first request for a key\",\n \"order to generate a cache key. Given a function ``one`` inside the module\",\n \":meth:`.CacheRegion.cache_on_arguments` method. The structure of this function should be two levels: given the\",\n \"in arg] ) return generate_key Where the decorator might be used as:: @my_region.cache_on_arguments(namespace=('x',\",\n \"return the new value. .. versionchanged:: 0.3.0 The value is unconditionally regenerated if\",\n \"for additional behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a\",\n \"the arguments which would normally be passed to the function should follow:: generate_something.set(3,\",\n \"list of cache keys using a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining\",\n \"mutex): mutexes[key] = mutex if expiration_time is None: expiration_time = self.expiration_time if (expiration_time\",\n \"arguments. The returned result is a list:: result = generate_something(\\\"key1\\\", \\\"key2\\\", \\\"key3\\\") The\",\n \"key above for ``MyClass().one(3, 4)`` will again produce the same cache key of\",\n \"cache.set(somekey, value) finally: mutex.release() thread = threading.Thread(target=runner) thread.start() region = make_region( async_creation_runner=async_creation_runner, ).configure(\",\n \"given the data creation function, return a new function that generates the key\",\n \"self._soft_invalidated = None self._hard_invalidated = None def invalidate(self, hard=None): if hard: self._soft_invalidated =\",\n \"value from the cache. This operation is idempotent (can be called multiple times,\",\n \":class:`.CachedValue` so that new versions of dogpile.cache can detect cached values from a\",\n \"is available myconfig = { \\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\", \\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\", \\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\", \\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1, 10.0.0.1\\\", } local_region.configure_from_config(myconfig, \\\"cache.local.\\\")\",\n \"MyClass(object): @region.cache_on_arguments(namespace=\\\"foo\\\") def one(self, a, b): return a + b The cache key\",\n \"caching or retrieving. Thus, this can be used to determine a *dynamic* expiration\",\n \"NO_VALUE else value for value in ( _unexpired_value_fn(value) for value in backend_values )\",\n \"the optional namespace and with the string form of each key. It will\",\n \":param namespace: optional string argument which will be established as part of the\",\n \"**kw) @wraps(fn) def creator(): return fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable \\\\\",\n \"_create_mutex(self, key): mutex = self.backend.get_mutex(key) if mutex is not None: return mutex else:\",\n \"isn't cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" def get_value(key): value\",\n \"non-existent key, safely) \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys):\",\n \"not be used to recreate the value and persist the newly generated value\",\n \"\\\"\\\"\\\"Return a cached value based on the given key. If the value does\",\n \"the return value of the function using a key derived from the function\",\n \"were to produce the value ``3`` as the value to be cached. ..\",\n \"invoke the decorated function and populate a new value into the cache with\",\n \"the function, the module name for the function, the arguments passed, as well\",\n \"same module, as can occur when decorating instance or class methods as below::\",\n \"to ``creator()``, and ``creator()`` should return the generated values as a sequence corresponding\",\n \"list of :class:`.ProxyBackend` classes and/or instances, each of which will be applied in\",\n \"wrap(self, proxy): ''' Takes a ProxyBackend instance or class and wraps the attached\",\n \"key generation can be entirely replaced on a per-region basis using the ``function_key_generator``\",\n \"return value return value_fn def get_multi(self, keys, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return multiple values from\",\n \"be used to recreate the value and persist the newly generated value in\",\n \"None: expiration_time = self.expiration_time if (expiration_time is None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \\\"Non-None\",\n \"+ ':' + str(a) for a in args] return generate_keys :param key_mangler: Function\",\n \"will still return promptly. They will be refreshed by whatever asynchronous means the\",\n \"``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time`` may be optionally passed as a ``datetime.timedelta``\",\n \"and returns a sequence of new values. :param expiration_time: optional expiration time which\",\n \"= function_key_generator(namespace, fn) else: key_generator = function_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg,\",\n \"decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get decorate.original\",\n \"function for this key against the cache. When the dogpile lock cannot be\",\n \"self._is_hard_invalidated = None self._invalidated = None def invalidate(self, hard=True): self._is_hard_invalidated = bool(hard) self._invalidated\",\n \"try: if mutexes: # sort the keys, the idea is to prevent deadlocks.\",\n \"is already running a creation function for this key against the cache. When\",\n \"May be passed as an integer or a callable. :param should_cache_fn: passed to\",\n \"current time (as reported by ``time.time()``). If stale, the cached value is ignored\",\n \"with Lock( self._mutex(key), gen_value, get_value, expiration_time, async_creator) as value: return value def get_or_create_multi(\",\n \"CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \\\"\\\"\\\" def invalidate(self,\",\n \"returned. The method will attempt to acquire the dogpile lock to generate a\",\n \"of keys. For example:: def my_multi_key_generator(namespace, fn, **kw): namespace = fn.__name__ + (namespace\",\n \"decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get decorate.original = fn return\",\n \"one configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create`\",\n \"< self._soft_invalidated) The custom implementation is injected into a :class:`.CacheRegion` at configure time\",\n \"until the lock is released to return the new value. .. versionchanged:: 0.3.0\",\n \"from .proxy import ProxyBackend from ..util import compat import time import datetime from\",\n \"returns to the calling function. A correct implementation of ``.set_multi()`` will not modify\",\n \"does not affect the data in the cache in any way, and is\",\n \"\\\"\\\"\\\" config_dict = coerce_string_conf(config_dict) return self.configure( config_dict[\\\"%sbackend\\\" % prefix], expiration_time=config_dict.get( \\\"%sexpiration_time\\\" % prefix,\",\n \"# later, when config is available myconfig = { \\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\", \\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\", \\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\", \\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1,\",\n \"valid ProxyBackend\\\" % type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self, key): return self._lock_registry.get(key) class\",\n \"if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn =\",\n \"disable all key mangling, set to ``False``. Another typical mangler is the built-in\",\n \"a list of keys. This function will supersede the one configured on the\",\n \"isinstance(expiration_time, Number): self.expiration_time = expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else:\",\n \"custom functionality augmentation can be applied. .. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param\",\n \"new value, or will wait until the lock is released to return the\",\n \"expiration_time, async_creator) as value: return value def get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None):\",\n \"function, cache the new values, and return them:: values = generate_something.refresh(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\")\",\n \"is passed as the first argument, and the arguments which would normally be\",\n \"ct def gen_value(): created_value = creator() value = self._value(created_value) if not should_cache_fn or\",\n \"@my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw): return my_data() .. seealso:: :func:`.function_key_generator` - default\",\n \"exception that the ``creator()`` function may be asked to generate any subset of\",\n \":class:`.CacheBackend` in use, though is typically a dictionary. :param wrap: Optional. A list\",\n \"the cache under the given keys. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not mapping:\",\n \"for example, a background thread, a long-running queue, or a task manager system\",\n \"``expiration_time`` may be optionally passed as a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method as\",\n \"then be called normally, where data will be pulled from the cache region\",\n \"\\\"\\\"\\\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated = None self._invalidated = None\",\n \"supplied by the ``expiration_time`` argument, is tested against the creation time of the\",\n \"itself and its arguments. The decorator internally makes use of the :meth:`.CacheRegion.get_or_create` method\",\n \"to this timestamp is considered to be stale. It does not affect the\",\n \"def generate_something(x, y): return somedatabase.query(x, y) The decorated function can then be called\",\n \"dogpile.cache can detect cached values from a previous, backwards-incompatible version. \\\"\\\"\\\" class RegionInvalidationStrategy(object):\",\n \"actually be cached or not. If it returns False, the value is still\",\n \"key as follows:: myapp.tools:one|foo|3 4 The key generator will ignore an initial argument\",\n \"and region is invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError() def is_soft_invalidated(self, timestamp):\",\n \"(though note: **not** the :meth:`.CacheRegion.get` method) will call upon the value creation function\",\n \"\\\"for soft invalidation\\\") if expiration_time == -1: expiration_time = None mutexes = {}\",\n \"method to decorated function. The default key generation will use the name of\",\n \"``myapp.tools``:: @region.cache_on_arguments(namespace=\\\"foo\\\") def one(a, b): return a + b Above, calling ``one(3, 4)``\",\n \"\\\"dogpile.cache.dbm\\\", expiration_time=300, arguments={ \\\"filename\\\":\\\"file.dbm\\\" } ) The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`.\",\n \"upon the value creation function after this time period has passed since the\",\n \"fname = fn.__name__ def generate_key(*arg): return namespace + \\\"_\\\" + fname + \\\"_\\\".join(str(s)\",\n \"self.backend.get(key) value = self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration): if\",\n \"function. A correct implementation of ``.set_multi()`` will not modify values in-place on the\",\n \":meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is None: function_key_generator = self.function_key_generator\",\n \". import exception from ..util import PluginLoader, memoized_property, coerce_string_conf from .util import function_key_generator,\",\n \"queue, or a task manager system like Celery. For a specific example using\",\n \"value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands a 0 here as\",\n \"an argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self, region): self.region = region # ... #\",\n \"well as returning that value:: newvalue = generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added\",\n \"the class is being declared. :param expiration_time: if not None, will override the\",\n \"def decorate(*arg, **kw): key = key_generator(*arg, **kw) @wraps(fn) def creator(): return fn(*arg, **kw)\",\n \"creation function after this time period has passed since the last generation. :param\",\n \"Generated function should return list of keys. For example:: def my_multi_key_generator(namespace, fn, **kw):\",\n \"released to return the new value. .. versionchanged:: 0.3.0 The value is unconditionally\",\n \"given key.\\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping): \\\"\\\"\\\"Place\",\n \"decorated function. Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as those passed\",\n \"the region as an argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self, region): self.region = region\",\n \"self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for wrapper\",\n \"+ [str(x) for x in arg] ) return generate_key Where the decorator might\",\n \"to False, but is separate from ``None`` to distinguish between a cached value\",\n \"is older than the current invalidation time, the ``NO_VALUE`` token is returned. Passing\",\n \"] The decorated function can be called normally. The decorator will produce a\",\n \"given sequence of keys using the same mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\\\"k1\\\",\",\n \"self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else:\",\n \"creation function, return a new function that generates the key based on the\",\n \"older than the last region invalidation time. \\\"\\\"\\\" raise NotImplementedError() def was_soft_invalidated(self): \\\"\\\"\\\"Indicate\",\n \"of values, and the final result of calling the decorated function will also\",\n \"def _unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration: return lambda value: value else: if expiration_time\",\n \"when decorating instance or class methods as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self,\",\n \"be passed as a callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. ..\",\n \"mutexes.values(): mutex.release() def _value(self, value): \\\"\\\"\\\"Return a :class:`.CachedValue` given a value.\\\"\\\"\\\" return CachedValue(\",\n \"a \\\"cache key\\\". This function will supersede the one configured on the :class:`.CacheRegion`\",\n \"will supersede the one configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 ..\",\n \"take note this function invokes ``.set_multi()`` for newly generated values using the same\",\n \"than the current invalidation time, the ``NO_VALUE`` token is returned. Passing the flag\",\n \"timeout, should_cache_fn) def invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key) def set_(value, *arg,\",\n \"that mutex when finished. This can be used to defer the computation of\",\n \"dictionary. If left at its default value of ``False``, the decorated function should\",\n \"keys. This function will supersede the one configured on the :class:`.CacheRegion` itself. ..\",\n \"The method will attempt to acquire the dogpile lock to generate a new\",\n \"any function using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \\\"\\\"\\\" orig_key =\",\n \"approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and set values from the backend.\",\n \"asynchronous means the provided async_creation_runner callable implements. By default the async_creation_runner is disabled\",\n \"expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, } ) Remember that the first request\",\n \"functions of the same name within the same source file, such as those\",\n \"return decorator def make_region(*arg, **kw): \\\"\\\"\\\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a\",\n \"a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \\\"\\\"\\\" orig_key = key if self.key_mangler:\",\n \"raise TypeError(\\\"Type %s is not a valid ProxyBackend\\\" % type(proxy)) self.backend = proxy.wrap(self.backend)\",\n \"By default, the configured expiration time of the :class:`.CacheRegion`, or alternatively the expiration\",\n \"ct def gen_value(): raise NotImplementedError() def async_creator(key, mutex): mutexes[key] = mutex if expiration_time\",\n \"that returns a value to be used as the ``expiration_time``. This callable will\",\n \"expiration time of the :class:`.CacheRegion`, or alternatively the expiration time supplied by the\",\n \"region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated = None self._hard_invalidated = None\",\n \"raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated = None self._invalidated = None def\",\n \"configured expiration time of the :class:`.CacheRegion`, or alternatively the expiration time supplied by\",\n \"``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses the invalidation time check.\",\n \"itself. .. versionadded:: 0.3.0 :param ignore_expiration: if ``True``, the value is returned from\",\n \"value is returned immediately without blocking. If the :meth:`.invalidate` method has been called,\",\n \"value -1. :param should_cache_fn: optional callable function which will receive the value returned\",\n \"with_statement from .. import Lock, NeedRegenerationException from ..util import NameRegistry from . import\",\n \"and ``MyOtherClass``. Python class declaration mechanics otherwise prevent the decorator from having awareness\",\n \"\\\"value3\\\"}) ...an ``invalidate()`` method, which has the effect of deleting the given sequence\",\n \"the original backend, so that custom functionality augmentation can be applied. .. versionadded::\",\n \"keys] finally: for mutex in mutexes.values(): mutex.release() def _value(self, value): \\\"\\\"\\\"Return a :class:`.CachedValue`\",\n \"self.get(key) def refresh(*arg, **kw): key = key_generator(*arg, **kw) value = fn(*arg, **kw) self.set(key,\",\n \"safely) \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \\\"\\\"\\\"Remove multiple\",\n \"backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend = backend_cls(arguments or {}) if not expiration_time\",\n \"be established as part of the cache key. This may be needed to\",\n \"value of ``False``, the decorated function should return its result as a list\",\n \"returned from the cache if present, regardless of configured expiration times or whether\",\n \"[str(x) for x in arg] ) return generate_key Where the decorator might be\",\n \"is not present, the method returns the token ``NO_VALUE``. ``NO_VALUE`` evaluates to False,\",\n \"in the list are returned as the ``NO_VALUE`` token. ``NO_VALUE`` evaluates to False,\",\n \"the current time (as reported by ``time.time()``). If stale, the cached value is\",\n \"None value = region.get_or_create(\\\"some key\\\", create_value, should_cache_fn=dont_cache_none) Above, the function returns the value\",\n \"argument of ``self`` or ``cls``, making the decorator suitable (with caveats) for use\",\n \"class on a function as the class is being declared. :param expiration_time: if\",\n \"generate_something.set({\\\"k1\\\": \\\"value1\\\", \\\"k2\\\": \\\"value2\\\", \\\"k3\\\": \\\"value3\\\"}) ...an ``invalidate()`` method, which has the effect\",\n \"it means a different thread or process is already running a creation function\",\n \"mode. \\\"\\\"\\\" raise NotImplementedError() def is_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it\",\n \"result def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys = list(mapping) gen_keys\",\n \"This method is the \\\"multiple key\\\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments()\",\n \"The list of keys to be generated is passed to ``creator()``, and ``creator()``\",\n \"cached value of ``None``. By default, the configured expiration time of the :class:`.CacheRegion`,\",\n \"list, and the decorated function is then called with that subset of arguments.\",\n \"**kw): key = key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw): key = key_generator(*arg,\",\n \"using a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies values, take note this function invokes\",\n \"note this function invokes ``.set_multi()`` for newly generated values using the same values\",\n \"return self.configure( config_dict[\\\"%sbackend\\\" % prefix], expiration_time=config_dict.get( \\\"%sexpiration_time\\\" % prefix, None), _config_argument_dict=config_dict, _config_prefix=\\\"%sarguments.\\\" %\",\n \"that the region or the method is given a non-None expiration time. ..\",\n \"time which will overide the expiration time already configured on this :class:`.CacheRegion` if\",\n \"value.payload, ct def gen_value(): raise NotImplementedError() def async_creator(key, mutex): mutexes[key] = mutex if\",\n \"result as a dictionary of keys->values, and the final result of calling the\",\n \"of any form. For example, it can be passed as a tuple, used\",\n \"function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys = arg keys =\",\n \"dict_create(*keys): d_values = creator(*keys) return [ d_values.get(key_lookup[k], NO_VALUE) for k in keys] def\",\n \"a current timestamp (using ``time.time()``) to consider all older timestamps effectively invalidated. \\\"\\\"\\\"\",\n \"generate_something.invalidate(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...a ``refresh()`` method, which will call the creation function, cache\",\n \"Implement this interface and pass implementation instance to :meth:`.CacheRegion.configure` to override default region\",\n \"if no such key exists:: value = generate_something.get(5, 6) .. versionadded:: 0.5.3 Added\",\n \"= time.time() else: self._soft_invalidated = time.time() self._hard_invalidated = None def is_invalidated(self, timestamp): return\",\n \"task manager system like Celery. For a specific example using async_creation_runner, new values\",\n \"def acquire(self, wait=True): return self.lock.acquire(wait) def release(self): self.lock.release() def _create_mutex(self, key): mutex =\",\n \"value = self.backend.get(key) value = self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload def _unexpired_value_fn(self, expiration_time,\",\n \"values. :param expiration_time: optional expiration time which will overide the expiration time already\",\n \"function. Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as those passed to\",\n \"end to a particular cache backend. :param name: Optional, a string name for\",\n \"of the day, week or time period\\\" and \\\"cache until a certain date\",\n \"self.backend.get(key) if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\\\"ct\\\"])): raise\",\n \"values from the backend. If you are using a :class:`.CacheBackend` or :class:`.ProxyBackend` that\",\n \"return value is None, it won't be cached. .. versionadded:: 0.4.3 .. seealso::\",\n \"return value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration: return lambda value: value else:\",\n \"a list:: result = generate_something(\\\"key1\\\", \\\"key2\\\", \\\"key3\\\") The decorator internally makes use of\",\n \"immediate regeneration of the value which all getters will wait for. With \\\"soft\\\"\",\n \"the value -1. :param should_cache_fn: optional callable function which will receive the value\",\n \"\\\"\\\"\\\" def invalidate(self, hard=True): \\\"\\\"\\\"Region invalidation. :class:`.CacheRegion` propagated call. The default invalidation system\",\n \"(using ``time.time()``) to consider all older timestamps effectively invalidated. \\\"\\\"\\\" raise NotImplementedError() def\",\n \"cache if present, regardless of configured expiration times or whether or not :meth:`.invalidate`\",\n \"Required. This is the name of the :class:`.CacheBackend` to use, and is resolved\",\n \"0.6.2 \\\"\\\"\\\" if \\\"backend\\\" in self.__dict__ and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \\\"This region\",\n \"create_value() if the cache is invalid, however if the return value is None,\",\n \"value_version }) def set(self, key, value): \\\"\\\"\\\"Place a new value in the cache\",\n \"function_key_generator(namespace, fn) else: key_generator = function_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw):\",\n \"fn) else: key_generator = function_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key\",\n \":class:`.CachedValue` given a value.\\\"\\\"\\\" return CachedValue( value, { \\\"ct\\\": time.time(), \\\"v\\\": value_version })\",\n \"placed in the cache. :param asdict: if ``True``, the decorated function should return\",\n \":meth:`.CacheRegion.cache_multi_on_arguments` works only with a single function signature, one which takes a simple\",\n \"if expiration_time_is_callable \\\\ else expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg, **kw):\",\n \"isn't used internally but can be accessed via the ``.name`` parameter, helpful for\",\n \":meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is None: function_multi_key_generator = self.function_multi_key_generator\",\n \"called multiple times, or on a non-existent key, safely) \\\"\\\"\\\" if self.key_mangler: key\",\n \"called multiple times, or on a non-existent key, safely) .. versionadded:: 0.5.0 \\\"\\\"\\\"\",\n \"\\\"soft\\\" invalidation requires that the region or the method is given a non-None\",\n \"to provide extra caching possibilities relative to the function. This is a convenience\",\n \"creation time of existing values will be pushed back before the expiration time\",\n \"time of the retrieved value versus the current time (as reported by ``time.time()``).\",\n \":return: Boolean. True if region was invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError()\",\n \"be entirely replaced on a per-region basis using the ``function_key_generator`` argument present on\",\n \"the backend. Defaults to ``None``, in which case the key mangling function recommended\",\n \"can occur when decorating instance or class methods as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC')\",\n \"a key to be a string, it is ultimately passed directly down to\",\n \"0.5.0 \\\"\\\"\\\" if not mapping: return if self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v))\",\n \"may require key mangling before reaching the cache. .. versionadded:: 0.5.0 :param function_key_generator:\",\n \".. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True, the existing cache backend will be\",\n \"order of the keys. The method uses the same approach as :meth:`.Region.get_multi` and\",\n \"wait=True): return self.lock.acquire(wait) def release(self): self.lock.release() def _create_mutex(self, key): mutex = self.backend.get_mutex(key) if\",\n \"submitted ``mapping`` dict. :param keys: Sequence of keys to be retrieved. :param creator:\",\n \"access to the :class:`.CacheRegion` itself should construct the invalidator given the region as\",\n \"as an argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self, region): self.region = region # ...\",\n \"value = values.get(key, NO_VALUE) if (value is NO_VALUE or value.metadata['v'] != value_version or\",\n \"**kw): key = key_generator(*arg, **kw) self.set(key, value) def get(*arg, **kw): key = key_generator(*arg,\",\n \"Like :meth:`.CacheRegion.cache_on_arguments`, the decorated function is also provided with a ``set()`` method, which\",\n \"is fixed. To disable all key mangling, set to ``False``. Another typical mangler\",\n \":meth:`.Region.get_or_create`, with the exception that the ``creator()`` function may be asked to generate\",\n \"or by the key_mangler function, if present. :param expiration_time: Optional expiration time value\",\n \"\\\"\\\"\\\"A front end to a particular cache backend. :param name: Optional, a string\",\n \"cached function result. Example use cases include \\\"cache the result until the end\",\n \"self.configure( config_dict[\\\"%sbackend\\\" % prefix], expiration_time=config_dict.get( \\\"%sexpiration_time\\\" % prefix, None), _config_argument_dict=config_dict, _config_prefix=\\\"%sarguments.\\\" % prefix,\",\n \"than the last call to :meth:`.invalidate`. :param key: Key to be retrieved. While\",\n \"_value(self, value): \\\"\\\"\\\"Return a :class:`.CachedValue` given a value.\\\"\\\"\\\" return CachedValue( value, { \\\"ct\\\":\",\n \"\\\"\\\"\\\" raise NotImplementedError() def is_hard_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was\",\n \"= DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None\",\n \"will produce a list of keys. This function will supersede the one configured\",\n \"self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return a value from the cache, based\",\n \"then called with that subset of arguments. The returned result is a list::\",\n \"not be cached. :param to_str: callable, will be called on each function argument\",\n \"the creation time of existing values will be pushed back before the expiration\",\n \"get return decorate return decorator def make_region(*arg, **kw): \\\"\\\"\\\"Instantiate a new :class:`.CacheRegion`. Currently,\",\n \"\\\"\\\"\\\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned. :param backend: Required. This is\",\n \"\\\"\\\"\\\" raise NotImplementedError() def is_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was\",\n \":meth:`.invalidate` method. If a value is present, but its creation time is older\",\n \"def __init__(self): self._soft_invalidated = None self._hard_invalidated = None def invalidate(self, hard=None): if hard:\",\n \"values, and return them:: values = generate_something.refresh(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...and a ``get()`` method,\",\n \"string. Defaults to ``str()``. If the function accepts non-ascii unicode arguments on Python\",\n \"a ``get()`` method, which will return values based on the given arguments:: values\",\n \"keys] def wrap_cache_fn(value): if value is NO_VALUE: return False elif not should_cache_fn: return\",\n \"= {} sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k) for k in\",\n \"backend, so that custom functionality augmentation can be applied. .. versionadded:: 0.5.0 ..\",\n \"The structure here is passed directly to the constructor of the :class:`.CacheBackend` in\",\n \"namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key = key_generator(*arg, **kw) @wraps(fn) def\",\n \"True will that value be placed in the cache. :param asdict: if ``True``,\",\n \"to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys = arg keys = key_generator(*arg, **kw) key_lookup\",\n \"backend such as bsddb or dbm under Python 2.x in conjunction with Unicode\",\n \"self.backend.get_mutex(key) if mutex is not None: return mutex else: return self._LockWrapper() def invalidate(self,\",\n \"timestamp < self._soft_invalidated) or (self._hard_invalidated and timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated)\",\n \"values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k in keys] finally: for mutex in mutexes.values(): mutex.release()\",\n \"a particular cache backend. :param name: Optional, a string name for the region.\",\n \"return value decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get =\",\n \"current timestamp (using ``time.time()``) representing the \\\"minimum creation time\\\" for a value. Any\",\n \"\\\\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return \\\":\\\".join( [kw[k] for k in\",\n \"= key_generator(*arg, **kw) return self.get(key) def refresh(*arg, **kw): key = key_generator(*arg, **kw) value\",\n \"is equivalent to calling ``generate_something(5, 6)``, if the function were to produce the\",\n \"and the final result of calling the decorated function will also be a\",\n \"will be applied in a chain to ultimately wrap the original backend, so\",\n \"y): \\\"\\\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y): \\\"\\\" Above, the ``namespace``\",\n \"False, but is separate from ``None`` to distinguish between a cached value of\",\n \"hard mode. \\\"\\\"\\\" raise NotImplementedError() def is_soft_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if\",\n \"for k in namespace] + [str(x) for x in arg] ) return generate_key\",\n \"values based on the given arguments:: values = generate_something.get(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") .. versionadded::\",\n \"decorating instance or class methods as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x,\",\n \"disambiguates between ``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python class declaration mechanics otherwise prevent\",\n \"set to ``None``. .. versionadded:: 0.4.2 added the async_creation_runner feature. \\\"\\\"\\\" def __init__(\",\n \"of the function using a key derived from the function itself and its\",\n \"way, and is also local to this instance of :class:`.CacheRegion`. Once set, the\",\n \"\\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1, 10.0.0.1\\\", } local_region.configure_from_config(myconfig, \\\"cache.local.\\\") memcached_region.configure_from_config(myconfig, \\\"cache.memcached.\\\") \\\"\\\"\\\" config_dict = coerce_string_conf(config_dict) return self.configure(\",\n \"in the cache:: generate_something.set({\\\"k1\\\": \\\"value1\\\", \\\"k2\\\": \\\"value2\\\", \\\"k3\\\": \\\"value3\\\"}) ...an ``invalidate()`` method, which\",\n \"0.3.0 The value is unconditionally regenerated if the creation time is older than\",\n \"def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \\\"\\\"\\\"A front end to\",\n \"cache using the same mechanism as that of :meth:`.CacheRegion.get_multi` to retrieve all current\",\n \"region is invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError() def is_invalidated(self, timestamp): \\\"\\\"\\\"Check\",\n \":class:`.CacheRegion`, or alternatively the expiration time supplied by the ``expiration_time`` argument, is tested\",\n \"as a tuple, used to specify arguments to pluck from \\\\**kw:: def my_key_generator(namespace,\",\n \"can be passed as a tuple, used to specify arguments to pluck from\",\n \"and the retrieved value's timestamp is older than the invalidation timestamp, the value\",\n \"arguments passed to it. This method is the \\\"multiple key\\\" analogue to the\",\n \"def wrap(self, proxy): ''' Takes a ProxyBackend instance or class and wraps the\",\n \"self, keys, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a sequence of cached values based on\",\n \"CachedValue( value, { \\\"ct\\\": time.time(), \\\"v\\\": value_version }) def set(self, key, value): \\\"\\\"\\\"Place\",\n \"zip(keys_to_get, new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for k,\",\n \"% prefix], expiration_time=config_dict.get( \\\"%sexpiration_time\\\" % prefix, None), _config_argument_dict=config_dict, _config_prefix=\\\"%sarguments.\\\" % prefix, wrap=config_dict.get( \\\"%swrap\\\"\",\n \"the decorated function and populate a new value into the cache with the\",\n \"= fn(*arg, **kw) self.set(key, value) return value decorate.set = set_ decorate.invalidate = invalidate\",\n \"return self._lock_registry.get(key) class _LockWrapper(object): \\\"\\\"\\\"weakref-capable wrapper for threading.Lock\\\"\\\"\\\" def __init__(self): self.lock = threading.Lock()\",\n \"time of existing values will be pushed back before the expiration time so\",\n \"function recommended by the cache backend will be used. A typical mangler is\",\n \"a in args] return generate_keys :param key_mangler: Function which will be used on\",\n \"recognized by the backend or by the key_mangler function, if present. :param creator:\",\n \"= self._value(created_value) if not should_cache_fn or \\\\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\\\"ct\\\"]\",\n \"also be a dictionary. If left at its default value of ``False``, the\",\n \"function itself to represent a particular value:: generate_something.invalidate(5, 6) Another attribute ``set()`` is\",\n \"function after this time period has passed since the last generation. :param arguments:\",\n \"isinstance(expiration_time, datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time is not a\",\n \"Added ``get()`` method to decorated function. Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the same\",\n \"proxy.wrap(self.backend) def _mutex(self, key): return self._lock_registry.get(key) class _LockWrapper(object): \\\"\\\"\\\"weakref-capable wrapper for threading.Lock\\\"\\\"\\\" def\",\n \"a tuple, used to specify arguments to pluck from \\\\**kw:: def my_key_generator(namespace, fn):\",\n \"invalidate(self, hard=True): self._is_hard_invalidated = bool(hard) self._invalidated = time.time() def is_invalidated(self, timestamp): return (self._invalidated\",\n \"the flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionadded:: 0.5.0 \\\"\\\"\\\" if\",\n \"[namespace + ':' + str(a) for a in args] return generate_keys :param key_mangler:\",\n \"taking no arguments, that returns a value to be used as the ``expiration_time``.\",\n \"return values from the function using a sequence of keys derived from the\",\n \"value be placed in the cache. :param asdict: if ``True``, the decorated function\",\n \"mapping of keys and values to set in the cache:: generate_something.set({\\\"k1\\\": \\\"value1\\\", \\\"k2\\\":\",\n \"produce a list of keys. This function will supersede the one configured on\",\n \"same values it returns to the calling function. A correct implementation of ``.set_multi()``\",\n \"returns the token ``NO_VALUE``. ``NO_VALUE`` evaluates to False, but is separate from ``None``\",\n \"older than the current invalidation time, the ``NO_VALUE`` token is returned. Passing the\",\n \"= refresh decorate.get = get decorate.original = fn return decorate return decorator def\",\n \"cache key of ``myapp.tools:one|foo|3 4`` - the name ``self`` is skipped. The ``namespace``\",\n \"parameter is optional, and is used normally to disambiguate two functions of the\",\n \"timestamp to determine if it was hard invalidated. :return: Boolean. True if ``timestamp``\",\n \"method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a single function signature, one which takes a\",\n \"is NO_VALUE: return False elif not should_cache_fn: return True else: return should_cache_fn(value) result\",\n \"if the *dogpile lock* can be acquired or not. If it can't, it\",\n \"present in the cache. It will be passed the mutex and is responsible\",\n \"considered to be stale. It does not affect the data in the cache\",\n \"anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k], self._value(v)) for\",\n \"will be pushed back before the expiration time so that a return+regen will\",\n \"key generator :func:`.kwarg_function_key_generator` - optional gen that also uses keyword arguments :param function_multi_key_generator:\",\n \"in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list of keys. For example:: def my_multi_key_generator(namespace,\",\n \"any subset of the given keys. The list of keys to be generated\",\n \"key mangling before reaching the cache. .. versionadded:: 0.5.0 :param function_key_generator: a function\",\n \"arg keys = key_generator(*arg, **kw) key_lookup = dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create): return\",\n \"from the function using a sequence of keys derived from the function itself\",\n \"file. :param function_key_generator: Optional. A function that will produce a \\\"cache key\\\" given\",\n \"expiration_time - .0001 return value.payload, ct def gen_value(): raise NotImplementedError() def async_creator(key, mutex):\",\n \"values = region.get_multi(keys) dictionary = dict(zip(keys, values)) Keys which aren't present in the\",\n \"methods as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \\\"\\\" class MyOtherClass(object):\",\n \"compat.callable(expiration_time) if function_multi_key_generator is None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator(\",\n \"set, the invalidation time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods.\",\n \"as an integer or a callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This function\",\n \":param arguments: Optional. The structure here is passed directly to the constructor of\",\n \"None), _config_argument_dict=config_dict, _config_prefix=\\\"%sarguments.\\\" % prefix, wrap=config_dict.get( \\\"%swrap\\\" % prefix, None), ) @memoized_property def\",\n \"to be retrieved. While it's typical for a key to be a string,\",\n \"keys. Returns values as a list matching the keys given. E.g.:: values =\",\n \"\\\"\\\"\\\"Return a :class:`.CachedValue` given a value.\\\"\\\"\\\" return CachedValue( value, { \\\"ct\\\": time.time(), \\\"v\\\":\",\n \"using the same mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...a ``refresh()``\",\n \"example:: def my_multi_key_generator(namespace, fn, **kw): namespace = fn.__name__ + (namespace or '') def\",\n \"**kw) self.set(key, value) return value decorate.set = set_ decorate.invalidate = invalidate decorate.refresh =\",\n \"\\\"\\\"\\\" class RegionInvalidationStrategy(object): \\\"\\\"\\\"Region invalidation strategy interface Implement this interface and pass implementation\",\n \"[\\\"one\\\", \\\"two\\\", \\\"three\\\"] values = region.get_multi(keys) dictionary = dict(zip(keys, values)) Keys which aren't\",\n \"Invalidation strategies that wish to have access to the :class:`.CacheRegion` itself should construct\",\n \"returned. Passing the flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionadded:: 0.5.0\",\n \"in namespace] + [str(x) for x in arg] ) return generate_key Where the\",\n \"def invalidate(self, hard=True): self._is_hard_invalidated = bool(hard) self._invalidated = time.time() def is_invalidated(self, timestamp): return\",\n \"is responsible releasing that mutex when finished. This can be used to defer\",\n \"``cls``, making the decorator suitable (with caveats) for use with instance or class\",\n \"creator: function which accepts a sequence of keys and returns a sequence of\",\n \"a + b Above, calling ``one(3, 4)`` will produce a cache key as\",\n \"decorate return decorator def make_region(*arg, **kw): \\\"\\\"\\\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region` is\",\n \"version. \\\"\\\"\\\" class RegionInvalidationStrategy(object): \\\"\\\"\\\"Region invalidation strategy interface Implement this interface and pass\",\n \"to convert non-string or Unicode keys to bytestrings, which is needed when using\",\n \"return+regen will be invoked. .. versionadded:: 0.5.1 \\\"\\\"\\\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict, prefix):\",\n \"returns the value of create_value() if the cache is invalid, however if the\",\n \"elif expiration_time is not None and \\\\ current_time - value.metadata[\\\"ct\\\"] > expiration_time: return\",\n \"the idea is to prevent deadlocks. # though haven't been able to simulate\",\n \"decorate(*arg, **kw): cache_keys = arg keys = key_generator(*arg, **kw) key_lookup = dict(zip(keys, cache_keys))\",\n \"dogpile logic won't be used. If False, the creation time of existing values\",\n \"in keys] def wrap_cache_fn(value): if value is NO_VALUE: return False elif not should_cache_fn:\",\n \"decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get return decorate return decorator\",\n \"= 1 \\\"\\\"\\\"An integer placed in the :class:`.CachedValue` so that new versions of\",\n \"@region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y): \\\"\\\" Above, the ``namespace`` parameter disambiguates between ``somemethod``\",\n \"from the cache, based on the given keys. Returns values as a list\",\n \"invalidated in hard mode. :return: Boolean. True if region was invalidated in hard\",\n \"to this instance of :class:`.CacheRegion`. Once set, the invalidation time is honored by\",\n \"versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \\\"\\\"\\\" def invalidate(self, hard=True): \\\"\\\"\\\"Region invalidation. :class:`.CacheRegion` propagated\",\n \"be cached. .. versionadded:: 0.4.1 Added ``set()`` method to decorated function. Similar to\",\n \"orig_to_mangled.items(): with Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ):\",\n \"keys corresponds to that of :meth:`.Region.get_or_create`, with the exception that the ``creator()`` function\",\n \"subset of arguments. The returned result is a list:: result = generate_something(\\\"key1\\\", \\\"key2\\\",\",\n \"keys. The method uses the same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get\",\n \"conditionally call the function. See that method for additional behavioral details. Unlike the\",\n \"all require immediate regeneration; dogpile logic won't be used. If False, the creation\",\n \"return NO_VALUE else: return value return value_fn def get_multi(self, keys, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return\",\n \"Optional, a string name for the region. This isn't used internally but can\",\n \"= refresh decorate.get = get return decorate return decorator def make_region(*arg, **kw): \\\"\\\"\\\"Instantiate\",\n \"= get decorate.original = fn return decorate return decorator def cache_multi_on_arguments( self, namespace=None,\",\n \"CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that wish to have access to the\",\n \"by setting a current timestamp (using ``time.time()``) to consider all older timestamps effectively\",\n \"expiration time check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks the value's creation time\",\n \"if not expiration_time or isinstance(expiration_time, Number): self.expiration_time = expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time\",\n \"of existing values will be pushed back before the expiration time so that\",\n \"the cache backend, before being optionally processed by the key_mangler function, so can\",\n \"return decorate return decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None):\",\n \"function. Lastly, the ``get()`` method returns either the value cached for the given\",\n \"will supersede that configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.3.0 :param ignore_expiration:\",\n \".. versionadded:: 0.5.0 \\\"\\\"\\\" if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys)\",\n \"to set in the cache:: generate_something.set({\\\"k1\\\": \\\"value1\\\", \\\"k2\\\": \\\"value2\\\", \\\"k3\\\": \\\"value3\\\"}) ...an ``invalidate()``\",\n \"elif isinstance(expiration_time, datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time is not\",\n \"or ``cls``, making the decorator suitable (with caveats) for use with instance or\",\n \"my_key_generator(namespace, fn, **kw): fname = fn.__name__ def generate_key(*arg): return namespace + \\\"_\\\" +\",\n \"simple list of keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the decorated function is also\",\n \"4 The key generator will ignore an initial argument of ``self`` or ``cls``,\",\n \"by the backend or by the key_mangler function, if present. :param creator: function\",\n \"6)``, if the function were to produce the value ``3`` as the value\",\n \"that will produce a \\\"cache key\\\" given a data creation function and arguments,\",\n \"namespace = fn.__name__ + (namespace or '') def generate_keys(*args): return [namespace + ':'\",\n \"cached values based on a sequence of keys. The behavior for generation of\",\n \"function. This is a convenience method for :meth:`.CacheRegion.set` which will store a given\",\n \"= invalidate decorate.refresh = refresh decorate.get = get return decorate return decorator def\",\n \"invalidation requires that the region or the method is given a non-None expiration\",\n \"of the given keys. The list of keys to be generated is passed\",\n \"key against the cache. When the dogpile lock cannot be acquired, the method\",\n \"invalidation timestamp, the value is unconditionally prevented from being returned. The method will\",\n \"decorator internally makes use of the :meth:`.CacheRegion.get_or_create_multi` method to access the cache and\",\n \"representing the \\\"minimum creation time\\\" for a value. Any retrieved value whose creation\",\n \"in which case the key mangling function recommended by the cache backend will\",\n \"\\\"\\\"\\\" if not keys: return [] if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key),\",\n \"None. To set no expiration, use the value -1. :param should_cache_fn: optional callable\",\n \"to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of the function with the optional\",\n \"keys = key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys = list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict(\",\n \"generated is passed to ``creator()``, and ``creator()`` should return the generated values as\",\n \"): \\\"\\\"\\\"Construct a new :class:`.CacheRegion`.\\\"\\\"\\\" self.name = name self.function_key_generator = function_key_generator self.function_multi_key_generator =\",\n \":class:`.CacheBackend` or :class:`.ProxyBackend` that modifies values, take note this function invokes ``.set_multi()`` for\",\n \"will cache multiple return values from the function using a sequence of keys\",\n \"The :meth:`.CacheRegion.get_or_create` method as well as the :meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not** the\",\n \"if value is NO_VALUE: return value elif expiration_time is not None and \\\\\",\n \"arguments which would normally be passed to the function should follow:: generate_something.set(3, 5,\",\n \"configured via the :meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1 \\\"\\\"\\\" return 'backend' in\",\n \"value.payload, ct def gen_value(): created_value = creator() value = self._value(created_value) if not should_cache_fn\",\n \"list:: result = generate_something(\\\"key1\\\", \\\"key2\\\", \\\"key3\\\") The decorator internally makes use of the\",\n \"if self.key_mangler: key = self.key_mangler(key) def get_value(): value = self.backend.get(key) if (value is\",\n \"TypeError(\\\"Type %s is not a valid ProxyBackend\\\" % type(proxy)) self.backend = proxy.wrap(self.backend) def\",\n \"lock* can be acquired or not. If it can't, it means a different\",\n \"if mutexes: # sort the keys, the idea is to prevent deadlocks. #\",\n \"self.backend.set_multi(mapping) def delete(self, key): \\\"\\\"\\\"Remove a value from the cache. This operation is\",\n \"key_generator(*arg, **kw) key_lookup = dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k] for k\",\n \"None self._hard_invalidated = time.time() else: self._soft_invalidated = time.time() self._hard_invalidated = None def is_invalidated(self,\",\n \"cases include \\\"cache the result until the end of the day, week or\",\n \"invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys = list(mapping) gen_keys = key_generator(*keys)\",\n \"versionadded:: 0.4.2 added the async_creation_runner feature. \\\"\\\"\\\" def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator,\",\n \"to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string argument which will be established as part\",\n \"generate_something(5, 6) The function is also given an attribute ``invalidate()``, which provides for\",\n \"corresponding to the order of the keys. The method uses the same approach\",\n \"to the cache backend, before being optionally processed by the key_mangler function, so\",\n \"invalidation time. \\\"\\\"\\\" raise NotImplementedError() def was_soft_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in\",\n \"cached value is ignored and the ``NO_VALUE`` token is returned. Passing the flag\",\n \"``invalidate()``, which provides for invalidation of the value. Pass to ``invalidate()`` the same\",\n \"module name for the function, the arguments passed, as well as an optional\",\n \"on Python 2.x, the ``unicode()`` builtin can be substituted, but note this will\",\n \"None: function_key_generator = self.function_key_generator def decorator(fn): if to_str is compat.string_type: # backwards compatible\",\n \"function_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key = key_generator(*arg, **kw) @wraps(fn)\",\n \"namespace and with the string form of each key. It will then consult\",\n \"creation time against the expiration time, rather than returning the value unconditionally. The\",\n \"from a configuration dictionary and a prefix. Example:: local_region = make_region() memcached_region =\",\n \"type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self, key): return self._lock_registry.get(key) class _LockWrapper(object): \\\"\\\"\\\"weakref-capable wrapper\",\n \"or is considered to be expired based on its creation time, the given\",\n \"and self.is_invalidated(timestamp) class CacheRegion(object): \\\"\\\"\\\"A front end to a particular cache backend. :param\",\n \"The default invalidation system works by setting a current timestamp (using ``time.time()``) representing\",\n \"ultimately passed directly down to the cache backend, before being optionally processed by\",\n \"0.5.0 \\\"\\\"\\\" if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments(\",\n \"to a string. Defaults to ``str()``. If the function accepts non-ascii unicode arguments\",\n \"decorator (though note: **not** the :meth:`.CacheRegion.get` method) will call upon the value creation\",\n \"the ``dogpile.cache`` entrypoint. :param expiration_time: Optional. The expiration time passed to the dogpile\",\n \"values from a previous, backwards-incompatible version. \\\"\\\"\\\" class RegionInvalidationStrategy(object): \\\"\\\"\\\"Region invalidation strategy interface\",\n \"occur when decorating instance or class methods as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def\",\n \"decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get return\",\n \"the :meth:`.CacheRegion.cache_on_arguments` method. The structure of this function should be two levels: given\",\n \":class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \\\"\\\"\\\" if \\\"backend\\\" in self.__dict__ and not replace_existing_backend: raise\",\n \"function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \\\"\\\"\\\"Construct a new :class:`.CacheRegion`.\\\"\\\"\\\" self.name = name self.function_key_generator\",\n \"# backwards compatible key_generator = function_key_generator(namespace, fn) else: key_generator = function_key_generator( namespace, fn,\",\n \"If defaults to :func:`.function_key_generator`. :param namespace: optional string argument which will be established\",\n \"dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in orig_to_mangled.items(): with Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key),\",\n \"a simple list of keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the decorated function is\",\n \"added the async_creation_runner feature. \\\"\\\"\\\" def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None,\",\n \"the cache in any way, and is also local to this instance of\",\n \"so that a return+regen will be invoked. .. versionadded:: 0.5.1 \\\"\\\"\\\" self.region_invalidator.invalidate(hard) def\",\n \"import time import datetime from numbers import Number from functools import wraps import\",\n \"self.region_invalidator.is_hard_invalidated( value.metadata[\\\"ct\\\"])): raise NeedRegenerationException() ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() -\",\n \"if present. :param expiration_time: Optional expiration time value which will supersede that configured\",\n \"value is NO_VALUE: return value elif expiration_time is not None and \\\\ current_time\",\n \"if we were passed a type rather than an instance then # initialize\",\n \"the return value is None, it won't be cached. .. versionadded:: 0.4.3 ..\",\n \"example using async_creation_runner, new values can be created in a background thread like\",\n \"the decorator might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw): return\",\n \"the cache backend will be used. A typical mangler is the SHA1 mangler\",\n \"= time.time() - expiration_time - .0001 return value.payload, ct def gen_value(): created_value =\",\n \"the value and persist the newly generated value in the cache. Whether or\",\n \"and with the string form of each key. It will then consult the\",\n \".. import Lock, NeedRegenerationException from ..util import NameRegistry from . import exception from\",\n \"1 \\\"\\\"\\\"An integer placed in the :class:`.CachedValue` so that new versions of dogpile.cache\",\n \"regions are ready to use for function # decorators, but not yet for\",\n \"token is returned. Passing the flag ``ignore_expiration=True`` bypasses the invalidation time check. ..\",\n \"expiration_time is None: expiration_time = self.expiration_time current_time = time.time() def value_fn(value): if value\",\n \"b): return a + b Above, calling ``one(3, 4)`` will produce a cache\",\n \"raise NotImplementedError() def is_hard_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was hard\",\n \"immediate regeneration; dogpile logic won't be used. If False, the creation time of\",\n \"the ``get()`` method returns either the value cached for the given key, or\",\n \"regeneration of the value which all getters will wait for. With \\\"soft\\\" invalidation,\",\n \"well as an optional \\\"namespace\\\" parameter in order to generate a cache key.\",\n \"True, the existing cache backend will be replaced. Without this flag, an exception\",\n \"self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self, orig_key, creator, mutex) else: async_creator = None\",\n \"Another attribute ``set()`` is added to provide extra caching possibilities relative to the\",\n \"name for the function, the arguments passed, as well as an optional \\\"namespace\\\"\",\n \"threading.Thread(target=runner) thread.start() region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock':\",\n \":meth:`.CacheRegion.get_or_create_multi`. This function is given a value as returned by the creator, and\",\n \"timeout, should_cache_fn) return result def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys\",\n \"dogpile lock to generate a new value, or will wait until the lock\",\n \"self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in orig_to_mangled.items(): with Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time,\",\n \"time passes\\\". .. versionchanged:: 0.5.0 ``expiration_time`` may be passed as a callable to\",\n \"function as the class is being declared. :param expiration_time: if not None, will\",\n \"the lock is released to return the new value. .. versionchanged:: 0.3.0 The\",\n \"= None self._hard_invalidated = time.time() else: self._soft_invalidated = time.time() self._hard_invalidated = None def\",\n \"':' + str(a) for a in args] return generate_keys :param key_mangler: Function which\",\n \"k, v in zip(cache_keys, result) if v is not NO_VALUE) else: result =\",\n \"original backend, so that custom functionality augmentation can be applied. .. versionadded:: 0.5.0\",\n \"= threading.Thread(target=runner) thread.start() region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211',\",\n \"for the :meth:`.CacheRegion.invalidate` method. :param key: Key to be retrieved. While it's typical\",\n \"``namespace`` parameter is optional, and is used normally to disambiguate two functions of\",\n \"the last region invalidation time and region is invalidated in soft mode. \\\"\\\"\\\"\",\n \"def _mutex(self, key): return self._lock_registry.get(key) class _LockWrapper(object): \\\"\\\"\\\"weakref-capable wrapper for threading.Lock\\\"\\\"\\\" def __init__(self):\",\n \"def async_creator(mutex): return self.async_creation_runner( self, orig_key, creator, mutex) else: async_creator = None with\",\n \"[kw[k] for k in namespace] + [str(x) for x in arg] ) return\",\n \"key. This may be needed to disambiguate functions of the same name within\",\n \"class MyClass(object): @region.cache_on_arguments(namespace=\\\"foo\\\") def one(self, a, b): return a + b The cache\",\n \"self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result = dict( (k, v) for k, v\",\n \"as follows:: myapp.tools:one|foo|3 4 The key generator will ignore an initial argument of\",\n \"\\\"\\\"\\\"An integer placed in the :class:`.CachedValue` so that new versions of dogpile.cache can\",\n \"key = self.key_mangler(key) value = self.backend.get(key) value = self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload\",\n \"key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values = fn(*arg) if asdict:\",\n \"is None: expiration_time = self.expiration_time if (expiration_time is None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException(\",\n \"calling function. A correct implementation of ``.set_multi()`` will not modify values in-place on\",\n \"using a sequence of keys derived from the function itself and the arguments\",\n \"return self.async_creation_runner( self, orig_key, creator, mutex) else: async_creator = None with Lock( self._mutex(key),\",\n \"``expiration_time`` argument, is tested against the creation time of the retrieved value versus\",\n \"the :meth:`.CacheRegion.get_or_create_multi` method to access the cache and conditionally call the function. See\",\n \"used internally but can be accessed via the ``.name`` parameter, helpful for configuring\",\n \"creation time, the given creation function may or may not be used to\",\n \"versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True, the existing cache backend\",\n \"self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time - .0001 return value.payload, ct def gen_value():\",\n \"configured. .. versionadded:: 0.5.7 :param region_invalidator: Optional. Override default invalidation strategy with custom\",\n \"acquire(self, wait=True): return self.lock.acquire(wait) def release(self): self.lock.release() def _create_mutex(self, key): mutex = self.backend.get_mutex(key)\",\n \"check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks the value's creation time against the\",\n \"def somemethod(self, x, y): \\\"\\\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y): \\\"\\\"\",\n \"that will produce a \\\"cache key\\\". This function will supersede the one configured\",\n \"produce a \\\"cache key\\\" given a data creation function and arguments, when using\",\n \"asdict: def dict_create(*keys): d_values = creator(*keys) return [ d_values.get(key_lookup[k], NO_VALUE) for k in\",\n \"value_version = 1 \\\"\\\"\\\"An integer placed in the :class:`.CachedValue` so that new versions\",\n \"and values to set in the cache:: generate_something.set({\\\"k1\\\": \\\"value1\\\", \\\"k2\\\": \\\"value2\\\", \\\"k3\\\": \\\"value3\\\"})\",\n \"decorator that will cache multiple return values from the function using a sequence\",\n \"of the value which all getters will wait for. With \\\"soft\\\" invalidation, subsequent\",\n \"per-region basis using the ``function_key_generator`` argument present on :func:`.make_region` and :class:`.CacheRegion`. If defaults\",\n \"return (self._hard_invalidated and timestamp < self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp):\",\n \"the attached backend. ''' # if we were passed a type rather than\",\n \"ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time - .0001 return\",\n \"returning the value unconditionally. The method also interprets the cached value in terms\",\n \"bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return (self._hard_invalidated and timestamp < self._hard_invalidated) def was_soft_invalidated(self): return\",\n \"!= value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands a 0 here as #\",\n \"memcached_region.configure_from_config(myconfig, \\\"cache.memcached.\\\") \\\"\\\"\\\" config_dict = coerce_string_conf(config_dict) return self.configure( config_dict[\\\"%sbackend\\\" % prefix], expiration_time=config_dict.get( \\\"%sexpiration_time\\\"\",\n \"= generate_something.get(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") .. versionadded:: 0.5.3 Added ``get()`` method to decorated function.\",\n \"in arg])) ) return values else: self.set_multi( dict(zip(keys, values)) ) return values decorate.set\",\n \"in zip(cache_keys, result) if v is not NO_VALUE) else: result = self.get_or_create_multi( keys,\",\n \"is returned. Passing the flag ``ignore_expiration=True`` bypasses the invalidation time check. .. versionadded::\",\n \"still return promptly. They will be refreshed by whatever asynchronous means the provided\",\n \"if not mapping: return if self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v)) for k,\",\n \"self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload if value is not NO_VALUE else value\",\n \"not available\\\", e.g. # _has_value() will return False. return value.payload, 0 else: ct\",\n \"newvalue = generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added ``refresh()`` method to decorated function.\",\n \"the dogpile system. May be passed as an integer number of seconds, or\",\n \"use ``zip()``:: keys = [\\\"one\\\", \\\"two\\\", \\\"three\\\"] values = region.get_multi(keys) dictionary = dict(zip(keys,\",\n \"MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y): \\\"\\\" Above, the ``namespace`` parameter disambiguates between\",\n \"``creator()`` function may be asked to generate any subset of the given keys.\",\n \"is available, until the lock is released and a new value available. If\",\n \"time import datetime from numbers import Number from functools import wraps import threading\",\n \"prefix, None), _config_argument_dict=config_dict, _config_prefix=\\\"%sarguments.\\\" % prefix, wrap=config_dict.get( \\\"%swrap\\\" % prefix, None), ) @memoized_property\",\n \"``str()``. If the function accepts non-ascii unicode arguments on Python 2.x, the ``unicode()``\",\n \"\\\"minimum creation time\\\" for a value. Any retrieved value whose creation time is\",\n \"the dogpile lock to generate a new value, or will wait until the\",\n \"are using a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies values, take note this function\",\n \"or self.region_invalidator.is_hard_invalidated( value.metadata[\\\"ct\\\"])): raise NeedRegenerationException() ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time()\",\n \"by the creator, and only if it returns True will that value be\",\n \"the given key. If the value is not present, the method returns the\",\n \"the cache. .. versionadded:: 0.5.0 :param function_multi_key_generator: a function that will produce a\",\n \"get decorate.original = fn return decorate return decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None,\",\n \"the invalidation timestamp, the value is unconditionally prevented from being returned. The method\",\n \"False, the value is still returned, but isn't cached. .. versionadded:: 0.5.0 ..\",\n \"of seconds, or as a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time`` may be\",\n \"keys derived from the function itself and the arguments passed to it. This\",\n \"class is being declared. :param expiration_time: if not None, will override the normal\",\n \"passed as a callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded::\",\n \"to_str is compat.string_type: # backwards compatible key_generator = function_key_generator(namespace, fn) else: key_generator =\",\n \"memoized_property, coerce_string_conf from .util import function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue from\",\n \"arguments, that returns a value to be used as the ``expiration_time``. This callable\",\n \".. versionadded:: 0.5.7 :param region_invalidator: Optional. Override default invalidation strategy with custom implementation\",\n \"For example, it can be passed as a tuple, used to specify arguments\",\n \"self._hard_invalidated = None def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated) or\",\n \"Boolean. True if ``timestamp`` is older than the last region invalidation time. \\\"\\\"\\\"\",\n \"or (self._hard_invalidated and timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp):\",\n \"is_invalidated(self, timestamp): return (self._invalidated is not None and timestamp < self._invalidated) def was_hard_invalidated(self):\",\n \"value return value_fn def get_multi(self, keys, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return multiple values from the\",\n \"return the \\\"old\\\" value until the new one is available. Usage of \\\"soft\\\"\",\n \"the cache under the given key.\\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.set(key, self._value(value))\",\n \"again produce the same cache key of ``myapp.tools:one|foo|3 4`` - the name ``self``\",\n \"CacheRegion(object): \\\"\\\"\\\"A front end to a particular cache backend. :param name: Optional, a\",\n \"is resolved by loading the class from the ``dogpile.cache`` entrypoint. :param expiration_time: Optional.\",\n \"list of values, and the final result of calling the decorated function will\",\n \"hard=True): \\\"\\\"\\\"Region invalidation. :class:`.CacheRegion` propagated call. The default invalidation system works by setting\",\n \"is not None value = region.get_or_create(\\\"some key\\\", create_value, should_cache_fn=dont_cache_none) Above, the function returns\",\n \":meth:`.CacheRegion.get_or_create_multi` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is None: function_multi_key_generator = self.function_multi_key_generator def\",\n \"if it was hard invalidated. :return: Boolean. True if ``timestamp`` is older than\",\n \"the existing cache backend will be replaced. Without this flag, an exception is\",\n \"be used as the ``expiration_time``. This callable will be called whenever the decorated\",\n \"method returns either the value cached for the given key, or the token\",\n \"the example:: class MyClass(object): @region.cache_on_arguments(namespace=\\\"foo\\\") def one(self, a, b): return a + b\",\n \"\\\"k3\\\") ...a ``refresh()`` method, which will call the creation function, cache the new\",\n \"CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated = None self._hard_invalidated = None def invalidate(self, hard=None): if\",\n \"will then return True or False, indicating if the value should actually be\",\n \"name of the :class:`.CacheBackend` to use, and is resolved by loading the class\",\n \"which will be applied in a chain to ultimately wrap the original backend,\",\n \"= mutex if expiration_time is None: expiration_time = self.expiration_time if (expiration_time is None\",\n \"to ``False``. Another typical mangler is the built-in Python function ``str``, which can\",\n \"\\\"three\\\"] values = region.get_multi(keys) dictionary = dict(zip(keys, values)) Keys which aren't present in\",\n \"will use the name of the function, the module name for the function,\",\n \"value and persist the newly generated value in the cache. Whether or not\",\n \"new value into the cache with the new value, as well as returning\",\n \"Optional expiration time value which will supersede that configured on the :class:`.CacheRegion` itself.\",\n \"return [ value.payload if value is not NO_VALUE else value for value in\",\n \"generate a cache key. Given a function ``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\\\"foo\\\")\",\n \"= list(map(lambda key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration)\",\n \"invalidation\\\") if expiration_time == -1: expiration_time = None if self.async_creation_runner: def async_creator(mutex): return\",\n \"creator, mutex) else: async_creator = None with Lock( self._mutex(key), gen_value, get_value, expiration_time, async_creator)\",\n \"self.expiration_time if (expiration_time is None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \\\"Non-None expiration time required\",\n \"than the last region invalidation time and region is invalidated in hard mode.\",\n \"used to defer the computation of expensive creator functions to later points in\",\n \"0.4.1 Added ``set()`` method to decorated function. Similar to ``set()`` is ``refresh()``. This\",\n \"which will overide the expiration time already configured on this :class:`.CacheRegion` if not\",\n \"= key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in zip(gen_keys, keys)) ) def\",\n \"self.set(key, value) def get(*arg, **kw): key = key_generator(*arg, **kw) return self.get(key) def refresh(*arg,\",\n \"is NO_VALUE: return value elif expiration_time is not None and \\\\ current_time -\",\n \"else: raise exception.ValidationError( 'expiration_time is not a number or timedelta.') if not self._user_defined_key_mangler:\",\n \"function which will receive the value returned by the \\\"creator\\\", and will then\",\n \"manager system like Celery. For a specific example using async_creation_runner, new values can\",\n \"to determine a *dynamic* expiration time for the cached function result. Example use\",\n \"self.name = name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler =\",\n \"thread or process is already running a creation function for this key against\",\n \"make_region() memcached_region = make_region() # regions are ready to use for function #\",\n \"the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses the invalidation time\",\n \"my_key_generator(namespace, fn): def generate_key(*arg, **kw): return \\\":\\\".join( [kw[k] for k in namespace] +\",\n \"= make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, } )\",\n \"hard: self._soft_invalidated = None self._hard_invalidated = time.time() else: self._soft_invalidated = time.time() self._hard_invalidated =\",\n \"function_key_generator: a function that will produce a \\\"cache key\\\". This function will supersede\",\n \"a cache key as follows:: myapp.tools:one|foo|3 4 The key generator will ignore an\",\n \"When ``asdict==True`` if the dictionary returned by the decorated function is missing keys,\",\n \"d_values.get(key_lookup[k], NO_VALUE) for k in keys] def wrap_cache_fn(value): if value is NO_VALUE: return\",\n \"the provided async_creation_runner callable implements. By default the async_creation_runner is disabled and is\",\n \"decorated function will also be a dictionary. If left at its default value\",\n \"present. :param expiration_time: Optional expiration time value which will supersede that configured on\",\n \"note that the decorator itself can't see the parent class on a function\",\n \"set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get decorate.original = fn\",\n \"k in keys] finally: for mutex in mutexes.values(): mutex.release() def _value(self, value): \\\"\\\"\\\"Return\",\n \"orig_key, mangled_key in orig_to_mangled.items(): with Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex:\",\n \"**kw): cache_keys = arg keys = key_generator(*arg, **kw) key_lookup = dict(zip(keys, cache_keys)) @wraps(fn)\",\n \"was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return (self._hard_invalidated and timestamp < self._hard_invalidated) def\",\n \"class CacheRegion(object): \\\"\\\"\\\"A front end to a particular cache backend. :param name: Optional,\",\n \"generate_something(x, y): return somedatabase.query(x, y) The decorated function can then be called normally,\",\n \"None self._hard_invalidated = None def invalidate(self, hard=None): if hard: self._soft_invalidated = None self._hard_invalidated\",\n \"timestamp to determine if it was soft invalidated. :return: Boolean. True if ``timestamp``\",\n \"% prefix, None), _config_argument_dict=config_dict, _config_prefix=\\\"%sarguments.\\\" % prefix, wrap=config_dict.get( \\\"%swrap\\\" % prefix, None), )\",\n \"of :meth:`.CacheRegion.cache_on_arguments`, combining the name of the function with the optional namespace and\",\n \"be pulled from the cache region unless a new value is needed:: result\",\n \"keys ] The decorated function can be called normally. The decorator will produce\",\n \"given key, or the token ``NO_VALUE`` if no such key exists:: value =\",\n \"function, if present. :param creator: function which creates a new value. :param expiration_time:\",\n \"decorated function. Similar to ``set()`` is ``refresh()``. This attribute will invoke the decorated\",\n \"prevent the decorator from having awareness of the ``MyClass`` and ``MyOtherClass`` names, as\",\n \"list of keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the decorated function is also provided\",\n \"can't see the parent class on a function as the class is being\",\n \"= key_generator(*arg, **kw) key_lookup = dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k] for\",\n \"injected into a :class:`.CacheRegion` at configure time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region =\",\n \"used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list of keys. For example:: def\",\n \").configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, } ) Remember that the\",\n \"to ultimately wrap the original backend, so that custom functionality augmentation can be\",\n \"def my_multi_key_generator(namespace, fn, **kw): namespace = fn.__name__ + (namespace or '') def generate_keys(*args):\",\n \"time.time(), \\\"v\\\": value_version }) def set(self, key, value): \\\"\\\"\\\"Place a new value in\",\n \"May be passed as an integer number of seconds, or as a ``datetime.timedelta``\",\n \"as returning that value:: newvalue = generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added ``refresh()``\",\n \"as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...a ``refresh()`` method, which will call\",\n \"as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string argument which will be\",\n \"threading.Lock\\\"\\\"\\\" def __init__(self): self.lock = threading.Lock() def acquire(self, wait=True): return self.lock.acquire(wait) def release(self):\",\n \"value is ignored and the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True``\",\n \"value_fn def get_multi(self, keys, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return multiple values from the cache, based\",\n \"Similar to ``function_key_generator`` parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return\",\n \"the order of the keys. The method uses the same approach as :meth:`.Region.get_multi`\",\n \"given value directly without calling the decorated function. The value to be cached\",\n \"[ somedatabase.query(key) for key in keys ] The decorated function can be called\",\n \"function_multi_key_generator from .api import NO_VALUE, CachedValue from .proxy import ProxyBackend from ..util import\",\n \"to be cached. .. versionadded:: 0.4.1 Added ``set()`` method to decorated function. Similar\",\n \"available. Usage of \\\"soft\\\" invalidation requires that the region or the method is\",\n \"of ``None``. By default, the configured expiration time of the :class:`.CacheRegion`, or alternatively\",\n \"need regeneration will be assembled into a new argument list, and the decorated\",\n \"will wait for. With \\\"soft\\\" invalidation, subsequent getters will return the \\\"old\\\" value\",\n \"\\\"cache.memcached.\\\") \\\"\\\"\\\" config_dict = coerce_string_conf(config_dict) return self.configure( config_dict[\\\"%sbackend\\\" % prefix], expiration_time=config_dict.get( \\\"%sexpiration_time\\\" %\",\n \"been configured via the :meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1 \\\"\\\"\\\" return 'backend'\",\n \"= key if self.key_mangler: key = self.key_mangler(key) def get_value(): value = self.backend.get(key) if\",\n \"\\\"\\\"\\\"Invalidate this :class:`.CacheRegion`. The default invalidation system works by setting a current timestamp\",\n \"= { \\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\", \\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\", \\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\", \\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1, 10.0.0.1\\\", } local_region.configure_from_config(myconfig, \\\"cache.local.\\\") memcached_region.configure_from_config(myconfig, \\\"cache.memcached.\\\") \\\"\\\"\\\"\",\n \"The returned result is a list:: result = generate_something(\\\"key1\\\", \\\"key2\\\", \\\"key3\\\") The decorator\",\n \"produce the same cache key of ``myapp.tools:one|foo|3 4`` - the name ``self`` is\",\n \"be called on each function argument in order to convert to a string.\",\n \"function_key_generator: Optional. A function that will produce a \\\"cache key\\\" given a data\",\n \"Keys which aren't present in the list are returned as the ``NO_VALUE`` token.\",\n \"which is needed when using a backend such as bsddb or dbm under\",\n \"= _backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend =\",\n \"method supports both \\\"hard\\\" and \\\"soft\\\" invalidation options. With \\\"hard\\\" invalidation, :meth:`.CacheRegion.get_or_create` will\",\n \"that method for additional behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only\",\n \"of keys. The behavior for generation of values based on keys corresponds to\",\n \"zip(gen_keys, keys)) ) def get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys\",\n \"{}) if not expiration_time or isinstance(expiration_time, Number): self.expiration_time = expiration_time elif isinstance(expiration_time, datetime.timedelta):\",\n \"''' # if we were passed a type rather than an instance then\",\n \"appropriate ''' def runner(): try: value = creator() cache.set(somekey, value) finally: mutex.release() thread\",\n \"= self.backend.get(key) value = self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration):\",\n \"key): \\\"\\\"\\\"Remove a value from the cache. This operation is idempotent (can be\",\n \"also given an attribute ``invalidate()``, which provides for invalidation of the value. Pass\",\n \"keys which may require key mangling before reaching the cache. .. versionadded:: 0.5.0\",\n \"values to set in the cache:: generate_something.set({\\\"k1\\\": \\\"value1\\\", \\\"k2\\\": \\\"value2\\\", \\\"k3\\\": \\\"value3\\\"}) ...an\",\n \"dict_create, timeout, wrap_cache_fn) result = dict( (k, v) for k, v in zip(cache_keys,\",\n \"make_region() # regions are ready to use for function # decorators, but not\",\n \"\\\"\\\"\\\" return 'backend' in self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return a value\",\n \"raise exception.ValidationError( 'expiration_time is not a number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler\",\n \"is used depends on if the *dogpile lock* can be acquired or not.\",\n \"is the \\\"multiple key\\\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys):\",\n \"mode. :return: Boolean. True if region was invalidated in hard mode. \\\"\\\"\\\" raise\",\n \"a region from a config file. :param function_key_generator: Optional. A function that will\",\n \"soft invalidated. :return: Boolean. True if ``timestamp`` is older than the last region\",\n \"expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \\\"\\\"\\\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion`\",\n \"key/value version \\\"\\\"\\\" orig_key = key if self.key_mangler: key = self.key_mangler(key) def get_value():\",\n \":meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" def get_value(key): value = values.get(key, NO_VALUE) if (value is NO_VALUE\",\n \":param expiration_time: Optional expiration time value which will supersede that configured on the\",\n \"} ) Remember that the first request for a key with no associated\",\n \"recognized by the backend or by the key_mangler function, if present. :param expiration_time:\",\n \"4)`` will produce a cache key as follows:: myapp.tools:one|foo|3 4 The key generator\",\n \"config is available myconfig = { \\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\", \\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\", \\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\", \\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1, 10.0.0.1\\\", } local_region.configure_from_config(myconfig,\",\n \"particular value:: generate_something.invalidate(5, 6) Another attribute ``set()`` is added to provide extra caching\",\n \"function itself is called, in caching or retrieving. Thus, this can be used\",\n \"cache, based on the given keys. Returns values as a list matching the\",\n \"is older than the last region invalidation time and region is invalidated in\",\n \"be called multiple times, or on a non-existent key, safely) .. versionadded:: 0.5.0\",\n \"if type(proxy) == type: proxy = proxy() if not issubclass(type(proxy), ProxyBackend): raise TypeError(\\\"Type\",\n \"method has been called, and the retrieved value's timestamp is older than the\",\n \"values will all require immediate regeneration; dogpile logic won't be used. If False,\",\n \"of keys to be retrieved. :param creator: function which accepts a sequence of\",\n \"runner(): try: value = creator() cache.set(somekey, value) finally: mutex.release() thread = threading.Thread(target=runner) thread.start()\",\n \"timestamp, the value is unconditionally prevented from being returned. The method will attempt\",\n \"return promptly. They will be refreshed by whatever asynchronous means the provided async_creation_runner\",\n \"only with a single function signature, one which takes a simple list of\",\n \"the new values, and return them:: values = generate_something.refresh(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...and a\",\n \"0.5.3 Added ``get()`` method to decorated function. Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the\",\n \"returned by the creator, and only if it returns True will that value\",\n \"cache_keys = arg keys = key_generator(*arg, **kw) key_lookup = dict(zip(keys, cache_keys)) @wraps(fn) def\",\n \"disambiguate functions of the same name within the same source file, such as\",\n \"= backend_cls(arguments or {}) if not expiration_time or isinstance(expiration_time, Number): self.expiration_time = expiration_time\",\n \"``function_key_generator`` argument present on :func:`.make_region` and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`. :param namespace:\",\n \"def get_value(key): value = values.get(key, NO_VALUE) if (value is NO_VALUE or value.metadata['v'] !=\",\n \"both \\\"hard\\\" and \\\"soft\\\" invalidation options. With \\\"hard\\\" invalidation, :meth:`.CacheRegion.get_or_create` will force an\",\n \"source file, such as those associated with classes - note that the decorator\",\n \"values as a list matching the keys given. E.g.:: values = region.get_multi([\\\"one\\\", \\\"two\\\",\",\n \"a in arg])) ) return values else: self.set_multi( dict(zip(keys, values)) ) return values\",\n \"refreshed by whatever asynchronous means the provided async_creation_runner callable implements. By default the\",\n \"mutex is not None: return mutex else: return self._LockWrapper() def invalidate(self, hard=True): \\\"\\\"\\\"Invalidate\",\n \"be cached. :param to_str: callable, will be called on each function argument in\",\n \"namespace + \\\"_\\\" + fname + \\\"_\\\".join(str(s) for s in arg) return generate_key\",\n \"value to be cached is passed as the first argument, and the arguments\",\n \"= None def invalidate(self, hard=None): if hard: self._soft_invalidated = None self._hard_invalidated = time.time()\",\n \"__future__ import with_statement from .. import Lock, NeedRegenerationException from ..util import NameRegistry from\",\n \"not should_cache_fn or \\\\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\\\"ct\\\"] if expiration_time is\",\n \"ignore an initial argument of ``self`` or ``cls``, making the decorator suitable (with\",\n \"+ b Above, calling ``one(3, 4)`` will produce a cache key as follows::\",\n \"the expiration time check. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not keys: return []\",\n \"the last region invalidation time and region is invalidated in hard mode. \\\"\\\"\\\"\",\n \"method to decorated function. Lastly, the ``get()`` method returns either the value cached\",\n \"4)`` will again produce the same cache key of ``myapp.tools:one|foo|3 4`` - the\",\n \"values, take note this function invokes ``.set_multi()`` for newly generated values using the\",\n \"convenience method for :meth:`.CacheRegion.set` which will store a given value directly without calling\",\n \"should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This function is given a value as returned by\",\n \"not :meth:`.invalidate` was called. .. versionadded:: 0.3.0 \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key)\",\n \"and timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return (self._hard_invalidated\",\n \"hard invalidated. :return: Boolean. True if ``timestamp`` is older than the last region\",\n \"was soft invalidated. :return: Boolean. True if ``timestamp`` is older than the last\",\n \"region from a config file. :param function_key_generator: Optional. A function that will produce\",\n \"is a stale value present in the cache. It will be passed the\",\n \"expired based on its creation time, the given creation function may or may\",\n \"fixed. To disable all key mangling, set to ``False``. Another typical mangler is\",\n \"strategy with custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \\\"\\\"\\\" if \\\"backend\\\" in\",\n \"the name ``self`` is skipped. The ``namespace`` parameter is optional, and is used\",\n \"function will also be a list. When ``asdict==True`` if the dictionary returned by\",\n \"of expensive creator functions to later points in the future by way of,\",\n \"methods. The method supports both \\\"hard\\\" and \\\"soft\\\" invalidation options. With \\\"hard\\\" invalidation,\",\n \"callable, will be called on each function argument in order to convert to\",\n \"self._hard_invalidated = None def invalidate(self, hard=None): if hard: self._soft_invalidated = None self._hard_invalidated =\",\n \"else: self.backend.set_multi(dict( (k, v) for k, v in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created)\",\n \"and the arguments which would normally be passed to the function should follow::\",\n \"the cache key. This may be needed to disambiguate functions of the same\",\n \"a certain date or time passes\\\". .. versionchanged:: 0.5.0 ``expiration_time`` may be passed\",\n \"to ``None``. .. versionadded:: 0.4.2 added the async_creation_runner feature. \\\"\\\"\\\" def __init__( self,\",\n \"value in the cache. Whether or not the function is used depends on\",\n \"use with instance or class methods. Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\\\"foo\\\") def\",\n \"cached value in terms of the current \\\"invalidation\\\" time as set by the\",\n \"stale value present in the cache. It will be passed the mutex and\",\n \"wrap the original backend, so that custom functionality augmentation can be applied. ..\",\n \"or will wait until the lock is released to return the new value.\",\n \") else: self.backend = backend_cls(arguments or {}) if not expiration_time or isinstance(expiration_time, Number):\",\n \"idempotent (can be called multiple times, or on a non-existent key, safely) ..\",\n \"a cached value of ``None``. By default, the configured expiration time of the\",\n \"cache. .. versionadded:: 0.5.0 :param function_key_generator: a function that will produce a \\\"cache\",\n \"only if it returns True will that value be placed in the cache.\",\n \"creator, and only if it returns True will that value be placed in\",\n \"for value in ( _unexpired_value_fn(value) for value in backend_values ) ] def get_or_create(\",\n \"(self._invalidated is not None and timestamp < self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is\",\n \"\\\"\\\" Above, the ``namespace`` parameter disambiguates between ``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python\",\n \"arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the decorated function is also provided with a ``set()`` method,\",\n \"an integer number of seconds, or as a ``datetime.timedelta`` value. .. versionadded 0.5.0\",\n \":class:`.CacheRegion`. The default invalidation system works by setting a current timestamp (using ``time.time()``)\",\n \"\\\"\\\"\\\"Return a sequence of cached values based on a sequence of keys. The\",\n \"self._hard_invalidated = time.time() else: self._soft_invalidated = time.time() self._hard_invalidated = None def is_invalidated(self, timestamp):\",\n \"of dogpile.cache can detect cached values from a previous, backwards-incompatible version. \\\"\\\"\\\" class\",\n \"overide the expiration time already configured on this :class:`.CacheRegion` if not None. To\",\n \"\\\"Non-None expiration time required \\\" \\\"for soft invalidation\\\") if expiration_time == -1: expiration_time\",\n \"def backend(self): raise exception.RegionNotConfigured( \\\"No backend is configured on this region.\\\") @property def\",\n \"-1. :param should_cache_fn: optional callable function which will receive each value returned by\",\n \"# \\\"the value is not available\\\", e.g. # _has_value() will return False. return\",\n \"the function itself and its arguments. The decorator internally makes use of the\",\n \"This is a convenience method for :meth:`.CacheRegion.set` which will store a given value\",\n \"passed to it. This method is the \\\"multiple key\\\" analogue to the :meth:`.CacheRegion.cache_on_arguments`\",\n \"of calling the decorated function will also be a dictionary. If left at\",\n \"self.async_creation_runner( self, orig_key, creator, mutex) else: async_creator = None with Lock( self._mutex(key), gen_value,\",\n \"rather than an instance then # initialize it. if type(proxy) == type: proxy\",\n \"here accepts a mapping of keys and values to set in the cache::\",\n \"from the function itself and the arguments passed to it. This method is\",\n \"value: return value def get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a sequence\",\n \"``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside this function, so\",\n \"if not None, will override the normal expiration time. May be specified as\",\n \"_LockWrapper(object): \\\"\\\"\\\"weakref-capable wrapper for threading.Lock\\\"\\\"\\\" def __init__(self): self.lock = threading.Lock() def acquire(self, wait=True):\",\n \"``get()`` method returns either the value cached for the given key, or the\",\n \"the value. Pass to ``invalidate()`` the same arguments you'd pass to the function\",\n \"present. :param creator: function which creates a new value. :param expiration_time: optional expiration\",\n \"mode. \\\"\\\"\\\" raise NotImplementedError() def is_soft_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it\",\n \"_unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration: return lambda value: value else: if expiration_time is\",\n \"as a dictionary of keys->values, and the final result of calling the decorated\",\n \"region): self.region = region # ... # ... region = CacheRegion() region =\",\n \"True if region was invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError() def was_hard_invalidated(self):\",\n \"be used. If False, the creation time of existing values will be pushed\",\n \"hard=None): if hard: self._soft_invalidated = None self._hard_invalidated = time.time() else: self._soft_invalidated = time.time()\",\n \"derived from the function itself and its arguments. The decorator internally makes use\",\n \"though is typically a dictionary. :param wrap: Optional. A list of :class:`.ProxyBackend` classes\",\n \":class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned. :param backend: Required. This is the name\",\n \"self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp): return\",\n \"- note that the decorator itself can't see the parent class on a\",\n \"configure time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation\",\n \"function ``str``, which can be used to convert non-string or Unicode keys to\",\n \"the normal expiration time. May be passed as an integer or a callable.\",\n \"-1: expiration_time = None mutexes = {} sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys\",\n \"of keys->values, and the final result of calling the decorated function will also\",\n \"configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.3.0 :param ignore_expiration: if ``True``, the\",\n \"import datetime from numbers import Number from functools import wraps import threading _backend_loader\",\n \"a value. Any retrieved value whose creation time is prior to this timestamp\",\n \"creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k], self._value(v)) for k, v in zip(keys_to_get, new_values) )\",\n \"before passing to the backend. Defaults to ``None``, in which case the key\",\n \"backend or by the key_mangler function, if present. :param expiration_time: Optional expiration time\",\n \"return [values[orig_to_mangled[k]].payload for k in keys] finally: for mutex in mutexes.values(): mutex.release() def\",\n \"optional \\\"namespace\\\" parameter in order to generate a cache key. Given a function\",\n \"By default the async_creation_runner is disabled and is set to ``None``. .. versionadded::\",\n \"generate_key Where the decorator might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b,\",\n \"if the return value is None, it won't be cached. .. versionadded:: 0.4.3\",\n \"combining the name of the function with the optional namespace and with the\",\n \"backend: Required. This is the name of the :class:`.CacheBackend` to use, and is\",\n \"\\\"k3\\\": \\\"value3\\\"}) ...an ``invalidate()`` method, which has the effect of deleting the given\",\n \"or :class:`.ProxyBackend` that modifies values, take note this function invokes ``.set_multi()`` for newly\",\n \"_backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend = backend_cls(arguments\",\n \"raise NotImplementedError() def is_soft_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was soft\",\n \"self.set_multi( dict(zip(keys, [values[a] for a in arg])) ) return values else: self.set_multi( dict(zip(keys,\",\n \"= region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that wish to have access to the :class:`.CacheRegion` itself\",\n \"if self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key) value = self._unexpired_value_fn( expiration_time, ignore_expiration)(value)\",\n \"is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside this function, so in\",\n \"= CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that wish to have access to\",\n \"those values which aren't generated or need regeneration will be assembled into a\",\n \"**kw) timeout = expiration_time() if expiration_time_is_callable \\\\ else expiration_time return self.get_or_create(key, creator, timeout,\",\n \"to bytestrings, which is needed when using a backend such as bsddb or\",\n \"backend will be used. A typical mangler is the SHA1 mangler found at\",\n \"x in arg] ) return generate_key Where the decorator might be used as::\",\n \"def __init__(self): self.lock = threading.Lock() def acquire(self, wait=True): return self.lock.acquire(wait) def release(self): self.lock.release()\",\n \":meth:`.invalidate` was called. .. versionadded:: 0.3.0 \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) value\",\n \".. versionadded:: 0.5.1 \\\"\\\"\\\" return 'backend' in self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False):\",\n \"time check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks the value's creation time against\",\n \"``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses the expiration time check.\",\n \"This function is given a value as returned by the creator, and only\",\n \"in fact can be of any form. For example, it can be passed\",\n \"return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result = dict( (k,\",\n \"by the ``expiration_time`` argument, is tested against the creation time of the retrieved\",\n \"of :meth:`.Region.get_or_create`, with the exception that the ``creator()`` function may be asked to\",\n \"the cache. It will be passed the mutex and is responsible releasing that\",\n \"value. The :meth:`.CacheRegion.get_or_create` method as well as the :meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not**\",\n \"is ``refresh()``. This attribute will invoke the decorated function and populate a new\",\n \"cache_keys)) @wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k] for k in keys_to_create]) timeout = expiration_time()\",\n \"values to a dictionary, use ``zip()``:: keys = [\\\"one\\\", \\\"two\\\", \\\"three\\\"] values =\",\n \"is needed:: result = generate_something(5, 6) The function is also given an attribute\",\n \"import ProxyBackend from ..util import compat import time import datetime from numbers import\",\n \"keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k], self._value(v)) for k,\",\n \"dogpile.core:Lock when appropriate ''' def runner(): try: value = creator() cache.set(somekey, value) finally:\",\n \":class:`.CacheRegion`. If defaults to :func:`.function_key_generator`. :param namespace: optional string argument which will be\",\n \"key.\\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping): \\\"\\\"\\\"Place new\",\n \"a new value is needed:: result = generate_something(5, 6) The function is also\",\n \"= generate_something.get(5, 6) .. versionadded:: 0.5.3 Added ``get()`` method to decorated function. The\",\n \"as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the decorated function is also provided with a ``set()``\",\n \"self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp <\",\n \"that generates the key based on the given arguments. Such as:: def my_key_generator(namespace,\",\n \"expiration_time: if not None, will override the normal expiration time. May be specified\",\n \"function_key_generator = self.function_key_generator def decorator(fn): if to_str is compat.string_type: # backwards compatible key_generator\",\n \"= dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in orig_to_mangled.items(): with Lock( self._mutex(mangled_key), gen_value, lambda:\",\n \"to decorated function. The default key generation will use the name of the\",\n \"name within the same module, as can occur when decorating instance or class\",\n \"``MyClass`` and ``MyOtherClass`` names, as the function is received by the decorator before\",\n \"the name of the function with the optional namespace and with the string\",\n \"The default key generation will use the name of the function, the module\",\n \"the keys given. E.g.:: values = region.get_multi([\\\"one\\\", \\\"two\\\", \\\"three\\\"]) To convert values to\",\n \"passed, as well as an optional \\\"namespace\\\" parameter in order to generate a\",\n \"import Lock, NeedRegenerationException from ..util import NameRegistry from . import exception from ..util\",\n \"import threading _backend_loader = PluginLoader(\\\"dogpile.cache\\\") register_backend = _backend_loader.register from . import backends #\",\n \"that will cache the return value of the function using a key derived\",\n \"populate a new value into the cache with the new value, as well\",\n \"creation time is prior to this timestamp is considered to be stale. It\",\n \"normally to disambiguate two functions of the same name within the same module,\",\n \"def is_hard_invalidated(self, timestamp): return (self._hard_invalidated and timestamp < self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated)\",\n \"a background thread like so:: import threading def async_creation_runner(cache, somekey, creator, mutex): '''\",\n \"be refreshed by whatever asynchronous means the provided async_creation_runner callable implements. By default\",\n \"propagated call. The default invalidation system works by setting a current timestamp (using\",\n \"key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return [\",\n \"to disambiguate two functions of the same name within the same module, as\",\n \"def delete(self, key): \\\"\\\"\\\"Remove a value from the cache. This operation is idempotent\",\n \"new value. :param expiration_time: optional expiration time which will overide the expiration time\",\n \"= self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure( self,\",\n \"else: return self._LockWrapper() def invalidate(self, hard=True): \\\"\\\"\\\"Invalidate this :class:`.CacheRegion`. The default invalidation system\",\n \"keys = [\\\"one\\\", \\\"two\\\", \\\"three\\\"] values = region.get_multi(keys) dictionary = dict(zip(keys, values)) Keys\",\n \"value): \\\"\\\"\\\"Return a :class:`.CachedValue` given a value.\\\"\\\"\\\" return CachedValue( value, { \\\"ct\\\": time.time(),\",\n \"is present, but its creation time is older than the current invalidation time,\",\n \"key exists:: value = generate_something.get(5, 6) .. versionadded:: 0.5.3 Added ``get()`` method to\",\n \"consult the cache using the same mechanism as that of :meth:`.CacheRegion.get_multi` to retrieve\",\n \") ] def get_or_create( self, key, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a cached value\",\n \"key_mangler: Function which will be used on all incoming keys before passing to\",\n \"include \\\"cache the result until the end of the day, week or time\",\n \"a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method as well as the :meth:`.CacheRegion.cache_on_arguments` decorator (though\",\n \"is typically a dictionary. :param wrap: Optional. A list of :class:`.ProxyBackend` classes and/or\",\n \"def _create_mutex(self, key): mutex = self.backend.get_mutex(key) if mutex is not None: return mutex\",\n \"a value from the cache. This operation is idempotent (can be called multiple\",\n \"provided with a ``set()`` method, which here accepts a mapping of keys and\",\n \"wrap_cache_fn) result = dict( (k, v) for k, v in zip(cache_keys, result) if\",\n \"versionadded:: 0.6.2 \\\"\\\"\\\" if \\\"backend\\\" in self.__dict__ and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \\\"This\",\n \"from ``None`` to distinguish between a cached value of ``None``. By default, the\",\n \"self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict, prefix): \\\"\\\"\\\"Configure from a configuration dictionary and a prefix.\",\n \"Such as:: def my_key_generator(namespace, fn, **kw): fname = fn.__name__ def generate_key(*arg): return namespace\",\n \"seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True, the existing cache backend will be replaced.\",\n \"on its creation time, the given creation function may or may not be\",\n \"each function argument in order to convert to a string. Defaults to ``str()``.\",\n \"given arguments. Such as:: def my_key_generator(namespace, fn, **kw): fname = fn.__name__ def generate_key(*arg):\",\n \"If False, the creation time of existing values will be pushed back before\",\n \"self.backend = backend_cls(arguments or {}) if not expiration_time or isinstance(expiration_time, Number): self.expiration_time =\",\n \"to ``None``, in which case the key mangling function recommended by the cache\",\n \"will be invoked. .. versionadded:: 0.5.1 \\\"\\\"\\\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict, prefix): \\\"\\\"\\\"Configure\",\n \"create_value, should_cache_fn=dont_cache_none) Above, the function returns the value of create_value() if the cache\",\n \"the mutex and is responsible releasing that mutex when finished. This can be\",\n \"key generator will ignore an initial argument of ``self`` or ``cls``, making the\",\n \"function_key_generator = my_key_generator ).configure( \\\"dogpile.cache.dbm\\\", expiration_time=300, arguments={ \\\"filename\\\":\\\"file.dbm\\\" } ) The ``namespace`` is\",\n \"] def get_or_create( self, key, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a cached value based\",\n \"the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\\\"foo\\\") def one(a, b): return a + b Above, calling\",\n \"return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \\\"\\\"\\\"A front end to a particular cache\",\n \"decorator from having awareness of the ``MyClass`` and ``MyOtherClass`` names, as the function\",\n \"= self.key_mangler(key) def get_value(): value = self.backend.get(key) if (value is NO_VALUE or value.metadata['v']\",\n \"self._soft_invalidated) The custom implementation is injected into a :class:`.CacheRegion` at configure time using\",\n \"its arguments. The decorator internally makes use of the :meth:`.CacheRegion.get_or_create` method to access\",\n \"return a + b The cache key above for ``MyClass().one(3, 4)`` will again\",\n \"is not a valid ProxyBackend\\\" % type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self, key):\",\n \"order to convert to a string. Defaults to ``str()``. If the function accepts\",\n \"coerces keys into a SHA1 hash, so that the string length is fixed.\",\n \"can be used to determine a *dynamic* expiration time for the cached function\",\n \"value) return value decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get\",\n \"def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return (self._hard_invalidated and timestamp < self._hard_invalidated)\",\n \"return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp):\",\n \"given key. If the value is not present, the method returns the token\",\n \"should construct the invalidator given the region as an argument:: class MyInvalidator(RegionInvalidationStrategy): def\",\n \"required \\\" \\\"for soft invalidation\\\") if expiration_time == -1: expiration_time = None mutexes\",\n \"decorate.refresh = refresh decorate.get = get decorate.original = fn return decorate return decorator\",\n \"data creation function, return a new function that generates the key based on\",\n \"from numbers import Number from functools import wraps import threading _backend_loader = PluginLoader(\\\"dogpile.cache\\\")\",\n \") Remember that the first request for a key with no associated value\",\n \"whether or not :meth:`.invalidate` was called. .. versionadded:: 0.3.0 \\\"\\\"\\\" if self.key_mangler: key\",\n \"that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside this function, so in fact\",\n \"key_mangler function, if present. :param creator: function which creates a new value. :param\",\n \"return True or False, indicating if the value should actually be cached or\",\n \"to produce the value ``3`` as the value to be cached. .. versionadded::\",\n \"# if we were passed a type rather than an instance then #\",\n \":meth:`.CacheRegion.get` methods. The method supports both \\\"hard\\\" and \\\"soft\\\" invalidation options. With \\\"hard\\\"\",\n \"timestamp < self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return (self._soft_invalidated and\",\n \"invalidation time and region is invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError() def\",\n \"function that will produce a list of keys. This function will supersede the\",\n \"background thread, a long-running queue, or a task manager system like Celery. For\",\n \"= dict(( self.key_mangler(k), self._value(v)) for k, v in mapping.items()) else: mapping = dict((k,\",\n \"configured expiration times or whether or not :meth:`.invalidate` was called. .. versionadded:: 0.3.0\",\n \"mapping.items()) else: mapping = dict((k, self._value(v)) for k, v in mapping.items()) self.backend.set_multi(mapping) def\",\n \"inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\\\"foo\\\") def one(a, b): return a + b Above,\",\n \"first request for a key with no associated value will always block; async_creator\",\n \"and \\\"cache until a certain date or time passes\\\". .. versionchanged:: 0.5.0 ``expiration_time``\",\n \"dictionary, use ``zip()``:: keys = [\\\"one\\\", \\\"two\\\", \\\"three\\\"] values = region.get_multi(keys) dictionary =\",\n \"= dict( (k, v) for k, v in zip(cache_keys, result) if v is\",\n \"cached is passed as the first argument, and the arguments which would normally\",\n \"available\\\", e.g. # _has_value() will return False. return value.payload, 0 else: ct =\",\n \"gen that also uses keyword arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter,\",\n \"released and a new value available. If a previous value is available, that\",\n \"``set()`` is ``refresh()``. This attribute will invoke the decorated function and populate a\",\n \"6) .. versionadded:: 0.5.3 Added ``get()`` method to decorated function. The default key\",\n \"via the ``.name`` parameter, helpful for configuring a region from a config file.\",\n \"on the given keys. Returns values as a list matching the keys given.\",\n \"then return True or False, indicating if the value should actually be cached\",\n \"return (self._soft_invalidated and timestamp < self._soft_invalidated) The custom implementation is injected into a\",\n \"in self.__dict__ and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \\\"This region is already \\\" \\\"configured\",\n \"key_mangler function, so can be of any type recognized by the backend or\",\n \"result of calling the decorated function will also be a list. When ``asdict==True``\",\n \"Above, calling ``one(3, 4)`` will produce a cache key as follows:: myapp.tools:one|foo|3 4\",\n \"is missing keys, those keys will not be cached. :param to_str: callable, will\",\n \"as a list of values, and the final result of calling the decorated\",\n \"result. Example use cases include \\\"cache the result until the end of the\",\n \"convert to a string. Defaults to ``str()``. If the function accepts non-ascii unicode\",\n \"method as well as the :meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not** the :meth:`.CacheRegion.get` method)\",\n \"value -1. :param should_cache_fn: optional callable function which will receive each value returned\",\n \"threading.Lock() def acquire(self, wait=True): return self.lock.acquire(wait) def release(self): self.lock.release() def _create_mutex(self, key): mutex\",\n \"value creation function after this time period has passed since the last generation.\",\n \"a *dynamic* expiration time for the cached function result. Example use cases include\",\n \"strategy interface Implement this interface and pass implementation instance to :meth:`.CacheRegion.configure` to override\",\n \"into a :class:`.CacheRegion` at configure time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion()\",\n \"in the cache under the given key.\\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.set(key,\",\n \":param to_str: callable, will be called on each function argument in order to\",\n \"class from the ``dogpile.cache`` entrypoint. :param expiration_time: Optional. The expiration time passed to\",\n \"mutex if expiration_time is None: expiration_time = self.expiration_time if (expiration_time is None and\",\n \"return values else: self.set_multi( dict(zip(keys, values)) ) return values decorate.set = set_ decorate.invalidate\",\n \"is_hard_invalidated(self, timestamp): return (self._hard_invalidated and timestamp < self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated) def\",\n \"parameter disambiguates between ``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python class declaration mechanics otherwise\",\n \"itself to represent a particular value:: generate_something.invalidate(5, 6) Another attribute ``set()`` is added\",\n \"decorated function can then be called normally, where data will be pulled from\",\n \"the decorated function. The value to be cached is passed as the first\",\n \"type: proxy = proxy() if not issubclass(type(proxy), ProxyBackend): raise TypeError(\\\"Type %s is not\",\n \"will all require immediate regeneration; dogpile logic won't be used. If False, the\",\n \"Lock( self._mutex(key), gen_value, get_value, expiration_time, async_creator) as value: return value def get_or_create_multi( self,\",\n \"this interface and pass implementation instance to :meth:`.CacheRegion.configure` to override default region invalidation.\",\n \"None, will override the normal expiration time. May be specified as a callable,\",\n \"not issubclass(type(proxy), ProxyBackend): raise TypeError(\\\"Type %s is not a valid ProxyBackend\\\" % type(proxy))\",\n \"generate_something.invalidate(5, 6) Another attribute ``set()`` is added to provide extra caching possibilities relative\",\n \"self.region_invalidator = region_invalidator return self def wrap(self, proxy): ''' Takes a ProxyBackend instance\",\n \"checks the value's creation time against the expiration time, rather than returning the\",\n \"NameRegistry from . import exception from ..util import PluginLoader, memoized_property, coerce_string_conf from .util\",\n \"versionadded:: 0.5.0 :param function_key_generator: a function that will produce a \\\"cache key\\\". This\",\n \"\\\"key3\\\") The decorator internally makes use of the :meth:`.CacheRegion.get_or_create_multi` method to access the\",\n \"exception.RegionAlreadyConfigured( \\\"This region is already \\\" \\\"configured with backend: %s. \\\" \\\"Specify replace_existing_backend=True\",\n \"the decorated function will also be a list. When ``asdict==True`` if the dictionary\",\n \"noqa value_version = 1 \\\"\\\"\\\"An integer placed in the :class:`.CachedValue` so that new\",\n \"compat import time import datetime from numbers import Number from functools import wraps\",\n \"- default key generator :func:`.kwarg_function_key_generator` - optional gen that also uses keyword arguments\",\n \"expiration time already configured on this :class:`.CacheRegion` if not None. To set no\",\n \"fn.__name__ def generate_key(*arg): return namespace + \\\"_\\\" + fname + \\\"_\\\".join(str(s) for s\",\n \"the computation of expensive creator functions to later points in the future by\",\n \"and the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses the expiration\",\n \"based on its creation time, the given creation function may or may not\",\n \"list. When ``asdict==True`` if the dictionary returned by the decorated function is missing\",\n \"the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \\\"\\\"\\\" expiration_time_is_callable =\",\n \"``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method as well as the :meth:`.CacheRegion.cache_on_arguments` decorator (though note:\",\n \"def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \\\"\\\"\\\"A function decorator that will\",\n \"will be refreshed by whatever asynchronous means the provided async_creation_runner callable implements. By\",\n \"deadlocks. # though haven't been able to simulate one anyway. keys_to_get = sorted(mutexes)\",\n \"def was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp < self._soft_invalidated)\",\n \"arg) return generate_key region = make_region( function_key_generator = my_key_generator ).configure( \\\"dogpile.cache.dbm\\\", expiration_time=300, arguments={\",\n \"down to the cache backend, before being optionally processed by the key_mangler function,\",\n \"invalidation\\\") if expiration_time == -1: expiration_time = None mutexes = {} sorted_unique_keys =\",\n \"will be established as part of the cache key. This may be needed\",\n \"on a function as the class is being declared. :param expiration_time: if not\",\n \"whenever the decorated function itself is called, in caching or retrieving. Thus, this\",\n \"return False elif not should_cache_fn: return True else: return should_cache_fn(value) result = self.get_or_create_multi(\",\n \"_unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload if value is not NO_VALUE\",\n \") return generate_key Where the decorator might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def\",\n \":param function_key_generator: a function that will produce a \\\"cache key\\\". This function will\",\n \"should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for k, v in values_w_created.items() if should_cache_fn(v[0])\",\n \"b Above, calling ``one(3, 4)`` will produce a cache key as follows:: myapp.tools:one|foo|3\",\n \".. versionadded:: 0.5.0 \\\"\\\"\\\" if not keys: return [] if self.key_mangler: keys =\",\n \"mangling function recommended by the cache backend will be used. A typical mangler\",\n \"arguments: Optional. The structure here is passed directly to the constructor of the\",\n \"cached values from a previous, backwards-incompatible version. \\\"\\\"\\\" class RegionInvalidationStrategy(object): \\\"\\\"\\\"Region invalidation strategy\",\n \"for this key against the cache. When the dogpile lock cannot be acquired,\",\n \"under the given keys. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not mapping: return if\",\n \"not None, will override the normal expiration time. May be specified as a\",\n \"if self.key_mangler: key = self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping): \\\"\\\"\\\"Place new values\",\n \"get(*arg, **kw): key = key_generator(*arg, **kw) return self.get(key) def refresh(*arg, **kw): key =\",\n \".. versionadded:: 0.5.0 :param function_key_generator: a function that will produce a \\\"cache key\\\".\",\n \"that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...a ``refresh()`` method, which will call the\",\n \"invalidator given the region as an argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self, region): self.region\",\n \"ProxyBackend instance or class and wraps the attached backend. ''' # if we\",\n \"a new argument list, and the decorated function is then called with that\",\n \"keys. The behavior for generation of values based on keys corresponds to that\",\n \"period has passed since the last generation. :param arguments: Optional. The structure here\",\n \"= key_generator(*arg, **kw) @wraps(fn) def creator(): return fn(*arg, **kw) timeout = expiration_time() if\",\n \"None def invalidate(self, hard=True): self._is_hard_invalidated = bool(hard) self._invalidated = time.time() def is_invalidated(self, timestamp):\",\n \".. versionadded:: 0.3.0 :param hard: if True, cache values will all require immediate\",\n \"a sequence of keys. The behavior for generation of values based on keys\",\n \"as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw): return my_data() .. seealso:: :func:`.function_key_generator` -\",\n \"day, week or time period\\\" and \\\"cache until a certain date or time\",\n \"idempotent (can be called multiple times, or on a non-existent key, safely) \\\"\\\"\\\"\",\n \"Optional. A function that will produce a \\\"cache key\\\" given a data creation\",\n \"\\\"k2\\\": \\\"value2\\\", \\\"k3\\\": \\\"value3\\\"}) ...an ``invalidate()`` method, which has the effect of deleting\",\n \"or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\\\"ct\\\"])): raise NeedRegenerationException() ct = value.metadata[\\\"ct\\\"] if\",\n \".. versionadded:: 0.6.2 \\\"\\\"\\\" if \\\"backend\\\" in self.__dict__ and not replace_existing_backend: raise exception.RegionAlreadyConfigured(\",\n \"``expiration_time``. This callable will be called whenever the decorated function itself is called,\",\n \"is separate from ``None`` to distinguish between a cached value of ``None``. By\",\n \".. versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \\\"\\\"\\\" def invalidate(self, hard=True): \\\"\\\"\\\"Region invalidation. :class:`.CacheRegion`\",\n \"rather than returning the value unconditionally. The method also interprets the cached value\",\n \"by the key_mangler function, so can be of any type recognized by the\",\n \"def get_or_create( self, key, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a cached value based on\",\n \"versionadded:: 0.5.0 Added ``refresh()`` method to decorated function. Lastly, the ``get()`` method returns\",\n \"= sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys] else: mangled_keys\",\n \"decorated function. The value to be cached is passed as the first argument,\",\n \"not expiration_time or isinstance(expiration_time, Number): self.expiration_time = expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time =\",\n \"return them:: values = generate_something.refresh(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...and a ``get()`` method, which will\",\n \"None and timestamp < self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is True def is_hard_invalidated(self,\",\n \"values in-place on the submitted ``mapping`` dict. :param keys: Sequence of keys to\",\n \"produce unicode cache keys which may require key mangling before reaching the cache.\",\n \"passed to the function should follow:: generate_something.set(3, 5, 6) The above example is\",\n \"``MyClass`` and ``MyOtherClass``. Python class declaration mechanics otherwise prevent the decorator from having\",\n \"see the parent class on a function as the class is being declared.\",\n \"and return them:: values = generate_something.refresh(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...and a ``get()`` method, which\",\n \"...an ``invalidate()`` method, which has the effect of deleting the given sequence of\",\n \".. versionadded:: 0.5.3 Added ``get()`` method to decorated function. Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments`\",\n \"initialize it. if type(proxy) == type: proxy = proxy() if not issubclass(type(proxy), ProxyBackend):\",\n \"else: async_creator = None with Lock( self._mutex(key), gen_value, get_value, expiration_time, async_creator) as value:\",\n \"parameter:: region = CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that wish to have\",\n \"from a config file. :param function_key_generator: Optional. A function that will produce a\",\n \"value as returned by the creator, and only if it returns True will\",\n \"Given a function ``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\\\"foo\\\") def one(a, b): return\",\n \"be optionally passed as a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method as well as\",\n \"of the same name within the same source file, such as those associated\",\n \"always block; async_creator will not be invoked. However, subsequent requests for cached-but-expired values\",\n \"value = creator() cache.set(somekey, value) finally: mutex.release() thread = threading.Thread(target=runner) thread.start() region =\",\n \"recreate the value and persist the newly generated value in the cache. Whether\",\n \"decorated function is missing keys, those keys will not be cached. :param to_str:\",\n \"won't be cached. .. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to\",\n \"on the given key. If the value does not exist or is considered\",\n \"a :class:`.CachedValue` given a value.\\\"\\\"\\\" return CachedValue( value, { \\\"ct\\\": time.time(), \\\"v\\\": value_version\",\n \"def somemethod(self, x, y): \\\"\\\" Above, the ``namespace`` parameter disambiguates between ``somemethod`` on\",\n \"async_creation_runner(cache, somekey, creator, mutex): ''' Used by dogpile.core:Lock when appropriate ''' def runner():\",\n \"or need regeneration will be assembled into a new argument list, and the\",\n \"the method returns the token ``NO_VALUE``. ``NO_VALUE`` evaluates to False, but is separate\",\n \"a string, it is ultimately passed directly down to the cache backend, before\",\n \"``NO_VALUE`` if no such key exists:: value = generate_something.get(5, 6) .. versionadded:: 0.5.3\",\n \"ignore_expiration): if ignore_expiration: return lambda value: value else: if expiration_time is None: expiration_time\",\n \"wait until the lock is released to return the new value. .. versionchanged::\",\n \"The expiration time passed to the dogpile system. May be passed as an\",\n \"prefix. Example:: local_region = make_region() memcached_region = make_region() # regions are ready to\",\n \"the :class:`.CacheRegion`, or alternatively the expiration time supplied by the ``expiration_time`` argument, is\",\n \"value which will supersede that configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.3.0\",\n \"timestamp): \\\"\\\"\\\"Check timestamp to determine if it was soft invalidated. :return: Boolean. True\",\n \"or whether or not :meth:`.invalidate` was called. .. versionadded:: 0.3.0 \\\"\\\"\\\" if self.key_mangler:\",\n \"self._value(v)) for k, v in mapping.items()) else: mapping = dict((k, self._value(v)) for k,\",\n \"decorated function will also be a list. When ``asdict==True`` if the dictionary returned\",\n \"def get(*arg, **kw): key = key_generator(*arg, **kw) return self.get(key) def refresh(*arg, **kw): key\",\n \"= PluginLoader(\\\"dogpile.cache\\\") register_backend = _backend_loader.register from . import backends # noqa value_version =\",\n \"will not be invoked. However, subsequent requests for cached-but-expired values will still return\",\n \"values will still return promptly. They will be refreshed by whatever asynchronous means\",\n \"value until the new one is available. Usage of \\\"soft\\\" invalidation requires that\",\n \"myconfig = { \\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\", \\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\", \\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\", \\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1, 10.0.0.1\\\", } local_region.configure_from_config(myconfig, \\\"cache.local.\\\") memcached_region.configure_from_config(myconfig, \\\"cache.memcached.\\\")\",\n \":meth:`.CacheRegion.get_or_create` method to access the cache and conditionally call the function. See that\",\n \"self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \\\"\\\"\\\"Construct a new :class:`.CacheRegion`.\\\"\\\"\\\" self.name =\",\n \"async_creator(key, mutex): mutexes[key] = mutex if expiration_time is None: expiration_time = self.expiration_time if\",\n \"newly generated value in the cache. Whether or not the function is used\",\n \"be used to defer the computation of expensive creator functions to later points\",\n \"invalidation system works by setting a current timestamp (using ``time.time()``) representing the \\\"minimum\",\n \":paramref:`.CacheRegion.configure.region_invalidator` \\\"\\\"\\\" def invalidate(self, hard=True): \\\"\\\"\\\"Region invalidation. :class:`.CacheRegion` propagated call. The default invalidation\",\n \"a stale value present in the cache. It will be passed the mutex\",\n \"being optionally processed by the key_mangler function, so can be of any type\",\n \"not affect the data in the cache in any way, and is also\",\n \"expiration time. May be passed as an integer or a callable. :param should_cache_fn:\",\n \"= key_generator(*arg, **kw) value = fn(*arg, **kw) self.set(key, value) return value decorate.set =\",\n \"which has the effect of deleting the given sequence of keys using the\",\n \").configure( \\\"dogpile.cache.dbm\\\", expiration_time=300, arguments={ \\\"filename\\\":\\\"file.dbm\\\" } ) The ``namespace`` is that passed to\",\n \"configure_from_config(self, config_dict, prefix): \\\"\\\"\\\"Configure from a configuration dictionary and a prefix. Example:: local_region\",\n \"is given a value as returned by the creator, and only if it\",\n \"``False``, the decorated function should return its result as a list of values,\",\n \":param region_invalidator: Optional. Override default invalidation strategy with custom implementation of :class:`.RegionInvalidationStrategy`. ..\",\n \"NotImplementedError() def is_hard_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was hard invalidated.\",\n \"v) for k, v in zip(cache_keys, result) if v is not NO_VALUE) else:\",\n \"async_creator will not be invoked. However, subsequent requests for cached-but-expired values will still\",\n \"not modify values in-place on the submitted ``mapping`` dict. :param keys: Sequence of\",\n \"value in terms of the current \\\"invalidation\\\" time as set by the :meth:`.invalidate`\",\n \"0 else: ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time -\",\n \"class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated = None self._invalidated = None def invalidate(self, hard=True):\",\n \"the token ``NO_VALUE`` if no such key exists:: value = generate_something.get(5, 6) ..\",\n \"value = generate_something.get(5, 6) .. versionadded:: 0.5.3 Added ``get()`` method to decorated function.\",\n \"that the decorator itself can't see the parent class on a function as\",\n \"self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and\",\n \"return self def wrap(self, proxy): ''' Takes a ProxyBackend instance or class and\",\n \"is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \\\"\\\"\\\"A front end to a\",\n \"key, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return a value from the cache, based on the given\",\n \"def runner(): try: value = creator() cache.set(somekey, value) finally: mutex.release() thread = threading.Thread(target=runner)\",\n \"or not. If it can't, it means a different thread or process is\",\n \"self.key_mangler(key) def get_value(): value = self.backend.get(key) if (value is NO_VALUE or value.metadata['v'] !=\",\n \"non-existent key, safely) .. versionadded:: 0.5.0 \\\"\\\"\\\" if self.key_mangler: keys = list(map(lambda key:\",\n \"mangler is the built-in Python function ``str``, which can be used to convert\",\n \"expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\\\"ct\\\"]): return NO_VALUE else: return value return value_fn\",\n \"values as a sequence corresponding to the order of the keys. The method\",\n \"def refresh(*arg): keys = key_generator(*arg) values = fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a]\",\n \"async_creation_runner=None, ): \\\"\\\"\\\"Construct a new :class:`.CacheRegion`.\\\"\\\"\\\" self.name = name self.function_key_generator = function_key_generator self.function_multi_key_generator\",\n \"the function using a key derived from the function itself and its arguments.\",\n \"the same module, as can occur when decorating instance or class methods as\",\n \":class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`. See that class for constructor\",\n \"last generation. :param arguments: Optional. The structure here is passed directly to the\",\n \"the ``MyClass`` and ``MyOtherClass`` names, as the function is received by the decorator\",\n \"originally passed keys corresponding to those values which aren't generated or need regeneration\",\n \"generated values using the same values it returns to the calling function. A\",\n \"seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` - optional gen that also uses\",\n \"class MyInvalidator(RegionInvalidationStrategy): def __init__(self, region): self.region = region # ... # ... region\",\n \"mutex): ''' Used by dogpile.core:Lock when appropriate ''' def runner(): try: value =\",\n \"understands a 0 here as # \\\"the value is not available\\\", e.g. #\",\n \"decorated function is also provided with a ``set()`` method, which here accepts a\",\n \"It does not affect the data in the cache in any way, and\",\n \"function is also provided with a ``set()`` method, which here accepts a mapping\",\n \"import exception from ..util import PluginLoader, memoized_property, coerce_string_conf from .util import function_key_generator, function_multi_key_generator\",\n \"instance or class methods. Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\\\"foo\\\") def one(self, a,\",\n \"The function key generation can be entirely replaced on a per-region basis using\",\n \"This function will supersede the one configured on the :class:`.CacheRegion` itself. .. versionadded::\",\n \"sequence corresponding to the order of the keys. The method uses the same\",\n \"as # \\\"the value is not available\\\", e.g. # _has_value() will return False.\",\n \"produce a \\\"cache key\\\". This function will supersede the one configured on the\",\n \"mangler found at :func:`.sha1_mangle_key` which coerces keys into a SHA1 hash, so that\",\n \"dbm under Python 2.x in conjunction with Unicode keys. :param async_creation_runner: A callable\",\n \"function signature, one which takes a simple list of keys as arguments. Like\",\n \"bool(hard) self._invalidated = time.time() def is_invalidated(self, timestamp): return (self._invalidated is not None and\",\n \"y): \\\"\\\" Above, the ``namespace`` parameter disambiguates between ``somemethod`` on ``MyClass`` and ``MyOtherClass``.\",\n \"for k, v in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \\\"\\\"\\\"Remove a value from\",\n \"dict(zip(keys, values)) ) return values decorate.set = set_ decorate.invalidate = invalidate decorate.refresh =\",\n \"is ultimately passed directly down to the cache backend, before being optionally processed\",\n \"key_lookup = dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k] for k in keys_to_create])\",\n \"of keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the decorated function is also provided with\",\n \"the decorated function should return its result as a dictionary of keys->values, and\",\n \"keys = list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in\",\n \"``timestamp`` is older than the last region invalidation time. \\\"\\\"\\\" raise NotImplementedError() def\",\n \"works by setting a current timestamp (using ``time.time()``) to consider all older timestamps\",\n \"backends # noqa value_version = 1 \\\"\\\"\\\"An integer placed in the :class:`.CachedValue` so\",\n \"-1. :param should_cache_fn: optional callable function which will receive the value returned by\",\n \"by dogpile.core:Lock when appropriate ''' def runner(): try: value = creator() cache.set(somekey, value)\",\n \"and persist the newly generated value in the cache. Whether or not the\",\n \"last call to :meth:`.invalidate`. :param key: Key to be retrieved. While it's typical\",\n \"already running a creation function for this key against the cache. When the\",\n \"This callable will be called whenever the decorated function itself is called, in\",\n \"to_str=compat.string_type, function_multi_key_generator=None): \\\"\\\"\\\"A function decorator that will cache multiple return values from the\",\n \":meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple\",\n \"to convert to a string. Defaults to ``str()``. If the function accepts non-ascii\",\n \"% prefix, wrap=config_dict.get( \\\"%swrap\\\" % prefix, None), ) @memoized_property def backend(self): raise exception.RegionNotConfigured(\",\n \"function. See that method for additional behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments`\",\n \"will overide the expiration time already configured on this :class:`.CacheRegion` if not None.\",\n \"argument, is tested against the creation time of the retrieved value versus the\",\n \"values else: self.set_multi( dict(zip(keys, values)) ) return values decorate.set = set_ decorate.invalidate =\",\n \":class:`.CacheRegion` itself should construct the invalidator given the region as an argument:: class\",\n \"current_time = time.time() def value_fn(value): if value is NO_VALUE: return value elif expiration_time\",\n \"creation time\\\" for a value. Any retrieved value whose creation time is prior\",\n \"for the region. This isn't used internally but can be accessed via the\",\n \"effect of deleting the given sequence of keys using the same mechanism as\",\n \"mutexes[key] = mutex if expiration_time is None: expiration_time = self.expiration_time if (expiration_time is\",\n \"its default value of ``False``, the decorated function should return its result as\",\n \"on this :class:`.CacheRegion` if not None. To set no expiration, use the value\",\n \".proxy import ProxyBackend from ..util import compat import time import datetime from numbers\",\n \"value to be cached. .. versionadded:: 0.4.1 Added ``set()`` method to decorated function.\",\n \"a backend such as bsddb or dbm under Python 2.x in conjunction with\",\n \"will cache the return value of the function using a key derived from\",\n \"backend_values ) ] def get_or_create( self, key, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a cached\",\n \"mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled =\",\n \"else: self.backend = backend_cls(arguments or {}) if not expiration_time or isinstance(expiration_time, Number): self.expiration_time\",\n \"function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue from .proxy import ProxyBackend from ..util\",\n \"def value_fn(value): if value is NO_VALUE: return value elif expiration_time is not None\",\n \"passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string argument which will be established as\",\n \"expiration_time or isinstance(expiration_time, Number): self.expiration_time = expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time = int(\",\n \"passed the mutex and is responsible releasing that mutex when finished. This can\",\n \"normally be passed to the function should follow:: generate_something.set(3, 5, 6) The above\",\n \"construct the invalidator given the region as an argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self,\",\n \"based on a sequence of keys. The behavior for generation of values based\",\n \"= self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload if value is\",\n \"of ``myapp.tools:one|foo|3 4`` - the name ``self`` is skipped. The ``namespace`` parameter is\",\n \"the value which all getters will wait for. With \\\"soft\\\" invalidation, subsequent getters\",\n \"skipped. The ``namespace`` parameter is optional, and is used normally to disambiguate two\",\n \"which may require key mangling before reaching the cache. .. versionadded:: 0.5.0 :param\",\n \"``set()`` method to decorated function. Similar to ``set()`` is ``refresh()``. This attribute will\",\n \"return fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable \\\\ else expiration_time return self.get_or_create(key,\",\n \"or a callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This function is given a\",\n \"the invalidation time check. .. versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param\",\n \"key, safely) .. versionadded:: 0.5.0 \\\"\\\"\\\" if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key),\",\n \"for a key to be a string, it is ultimately passed directly down\",\n \"and region is invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError() def is_invalidated(self, timestamp):\",\n \"the last call to :meth:`.invalidate`. :param key: Key to be retrieved. While it's\",\n \"return fn(*[key_lookup[k] for k in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\\\ else\",\n \") @memoized_property def backend(self): raise exception.RegionNotConfigured( \\\"No backend is configured on this region.\\\")\",\n \"_has_value() will return False. return value.payload, 0 else: ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct):\",\n \"method. If a value is present, but its creation time is older than\",\n \"lock is released and a new value available. If a previous value is\",\n \"replace_existing_backend=True to replace.\\\" % self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict(\",\n \"the given keys. Returns values as a list matching the keys given. E.g.::\",\n \"list matching the keys given. E.g.:: values = region.get_multi([\\\"one\\\", \\\"two\\\", \\\"three\\\"]) To convert\",\n \"this time period has passed since the last generation. :param arguments: Optional. The\",\n \"self.backend.set_multi(dict( (k, v) for k, v in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return\",\n \"function returns the value of create_value() if the cache is invalid, however if\",\n \"self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend = backend_cls(arguments or {}) if\",\n \"one(self, a, b): return a + b The cache key above for ``MyClass().one(3,\",\n \"= function_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key = key_generator(*arg, **kw)\",\n \"self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw):\",\n \"a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`. See that class\",\n \"self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys)\",\n \"keys = list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None,\",\n \"is returned immediately without blocking. If the :meth:`.invalidate` method has been called, and\",\n \"None def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated and\",\n \"a non-existent key, safely) .. versionadded:: 0.5.0 \\\"\\\"\\\" if self.key_mangler: keys = list(map(lambda\",\n \". import backends # noqa value_version = 1 \\\"\\\"\\\"An integer placed in the\",\n \"the region. This isn't used internally but can be accessed via the ``.name``\",\n \"on the given key. If the value is not present, the method returns\",\n \"to the order of the keys. The method uses the same approach as\",\n \"keys->values, and the final result of calling the decorated function will also be\",\n \"backend, before being optionally processed by the key_mangler function, so can be of\",\n \"'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, } ) Remember that the first\",\n \"idea is to prevent deadlocks. # though haven't been able to simulate one\",\n \"period\\\" and \\\"cache until a certain date or time passes\\\". .. versionchanged:: 0.5.0\",\n \"part of each cache key. :param expiration_time: if not None, will override the\",\n \"for k, v in zip(keys_to_get, new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict(\",\n \"return CachedValue( value, { \\\"ct\\\": time.time(), \\\"v\\\": value_version }) def set(self, key, value):\",\n \"keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \\\"\\\"\\\"A function decorator\",\n \"delete(self, key): \\\"\\\"\\\"Remove a value from the cache. This operation is idempotent (can\",\n \"extra caching possibilities relative to the function. This is a convenience method for\",\n \"= bool(hard) self._invalidated = time.time() def is_invalidated(self, timestamp): return (self._invalidated is not None\",\n \"before reaching the cache. .. versionadded:: 0.5.0 :param function_key_generator: a function that will\",\n \"Optional. Override default invalidation strategy with custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2\",\n \"for ``MyClass().one(3, 4)`` will again produce the same cache key of ``myapp.tools:one|foo|3 4``\",\n \"self.__dict__ and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \\\"This region is already \\\" \\\"configured with\",\n \"return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self):\",\n \"value is not None value = region.get_or_create(\\\"some key\\\", create_value, should_cache_fn=dont_cache_none) Above, the function\",\n \"def invalidate(self, hard=True): \\\"\\\"\\\"Invalidate this :class:`.CacheRegion`. The default invalidation system works by setting\",\n \"the cache. When the dogpile lock cannot be acquired, the method will block\",\n \"self.key_mangler: key = self.key_mangler(key) def get_value(): value = self.backend.get(key) if (value is NO_VALUE\",\n \"soft invalidation\\\") if expiration_time == -1: expiration_time = None if self.async_creation_runner: def async_creator(mutex):\",\n \"of keys derived from the function itself and the arguments passed to it.\",\n \"from the function itself and its arguments. The decorator internally makes use of\",\n \"flag, an exception is raised if a backend is already configured. .. versionadded::\",\n \"- expiration_time - .0001 return value.payload, ct def gen_value(): created_value = creator() value\",\n \"expiration_time, ignore_expiration): if ignore_expiration: return lambda value: value else: if expiration_time is None:\",\n \"cache, based on the given key. If the value is not present, the\",\n \"to recreate the value and persist the newly generated value in the cache.\",\n \"should follow:: generate_something.set(3, 5, 6) The above example is equivalent to calling ``generate_something(5,\",\n \"``time.time()``) to consider all older timestamps effectively invalidated. \\\"\\\"\\\" raise NotImplementedError() def is_hard_invalidated(self,\",\n \"fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key = key_generator(*arg, **kw) @wraps(fn) def creator():\",\n \"time.time() - expiration_time - .0001 return value.payload, ct def gen_value(): raise NotImplementedError() def\",\n \"value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration: return lambda value: value else: if\",\n \"function_key_generator is None: function_key_generator = self.function_key_generator def decorator(fn): if to_str is compat.string_type: #\",\n \"a function that will produce a list of keys. This function will supersede\",\n \"directly down to the cache backend, before being optionally processed by the key_mangler\",\n \"@someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key) for key in keys ] The decorated\",\n \"present, but its creation time is older than the current invalidation time, the\",\n \"should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\\\"ct\\\"] if expiration_time is None: expiration_time = self.expiration_time\",\n \"None with Lock( self._mutex(key), gen_value, get_value, expiration_time, async_creator) as value: return value def\",\n \":meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a single function signature, one which takes\",\n \"when appropriate ''' def runner(): try: value = creator() cache.set(somekey, value) finally: mutex.release()\",\n \"a passthrough to :class:`.CacheRegion`. See that class for constructor arguments. \\\"\\\"\\\" return CacheRegion(*arg,\",\n \"value unconditionally. The method also interprets the cached value in terms of the\",\n \"name: Optional, a string name for the region. This isn't used internally but\",\n \"present in the list are returned as the ``NO_VALUE`` token. ``NO_VALUE`` evaluates to\",\n \"be asked to generate any subset of the given keys. The list of\",\n \"were passed a type rather than an instance then # initialize it. if\",\n \"sequence of keys derived from the function itself and the arguments passed to\",\n \"function using a key derived from the function itself and its arguments. The\",\n \"versionadded:: 0.3.0 :param hard: if True, cache values will all require immediate regeneration;\",\n \"background thread like so:: import threading def async_creation_runner(cache, somekey, creator, mutex): ''' Used\",\n \"keys to be retrieved. :param creator: function which accepts a sequence of keys\",\n \"key of ``myapp.tools:one|foo|3 4`` - the name ``self`` is skipped. The ``namespace`` parameter\",\n \"keys: Sequence of keys to be retrieved. :param creator: function which accepts a\",\n \"method, which will call the creation function, cache the new values, and return\",\n \"function should return its result as a list of values, and the final\",\n \"thread like so:: import threading def async_creation_runner(cache, somekey, creator, mutex): ''' Used by\",\n \"return True else: return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result\",\n \"may be optionally passed as a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method as well\",\n \"value versus the current time (as reported by ``time.time()``). If stale, the cached\",\n \"will override the normal expiration time. May be passed as an integer or\",\n \"= self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg,\",\n \"Added ``refresh()`` method to decorated function. Lastly, the ``get()`` method returns either the\",\n \"def decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys\",\n \"or '') def generate_keys(*args): return [namespace + ':' + str(a) for a in\",\n \"to generate a cache key. Given a function ``one`` inside the module ``myapp.tools``::\",\n \"return value of the function using a key derived from the function itself\",\n \"function should return its result as a dictionary of keys->values, and the final\",\n \"would normally be passed to the function should follow:: generate_something.set(3, 5, 6) The\",\n \"computation of expensive creator functions to later points in the future by way\",\n \"be invoked. .. versionadded:: 0.5.1 \\\"\\\"\\\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict, prefix): \\\"\\\"\\\"Configure from\",\n \"on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" expiration_time_is_callable\",\n \"'y')) def my_function(a, b, **kw): return my_data() .. seealso:: :func:`.function_key_generator` - default key\",\n \"structure here is passed directly to the constructor of the :class:`.CacheBackend` in use,\",\n \"is configured on this region.\\\") @property def is_configured(self): \\\"\\\"\\\"Return True if the backend\",\n \"attribute will invoke the decorated function and populate a new value into the\",\n \"the keys. The method uses the same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to\",\n \"To convert values to a dictionary, use ``zip()``:: keys = [\\\"one\\\", \\\"two\\\", \\\"three\\\"]\",\n \"all incoming keys before passing to the backend. Defaults to ``None``, in which\",\n \"The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside this function,\",\n \"one is available. Usage of \\\"soft\\\" invalidation requires that the region or the\",\n \"\\\"old\\\" value until the new one is available. Usage of \\\"soft\\\" invalidation requires\",\n \"in a background thread like so:: import threading def async_creation_runner(cache, somekey, creator, mutex):\",\n \"# ... # ... region = CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2\",\n \"# sort the keys, the idea is to prevent deadlocks. # though haven't\",\n \"time required \\\" \\\"for soft invalidation\\\") if expiration_time == -1: expiration_time = None\",\n \"self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands a 0 here as # \\\"the value is\",\n \"get_value(): value = self.backend.get(key) if (value is NO_VALUE or value.metadata['v'] != value_version or\",\n \"mapping: return if self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v)) for k, v in\",\n \"function result. Example use cases include \\\"cache the result until the end of\",\n \"the given creation function may or may not be used to recreate the\",\n \"given arguments:: values = generate_something.get(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") .. versionadded:: 0.5.3 Added ``get()`` method\",\n \"a dictionary, use ``zip()``:: keys = [\\\"one\\\", \\\"two\\\", \\\"three\\\"] values = region.get_multi(keys) dictionary\",\n \"k in keys] def wrap_cache_fn(value): if value is NO_VALUE: return False elif not\",\n \"and timestamp < self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return (self._soft_invalidated\",\n \"type rather than an instance then # initialize it. if type(proxy) == type:\",\n \"require immediate regeneration; dogpile logic won't be used. If False, the creation time\",\n \"in zip(gen_keys, keys)) ) def get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg):\",\n \"self, key, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a cached value based on the given\",\n \".api import NO_VALUE, CachedValue from .proxy import ProxyBackend from ..util import compat import\",\n \"\\\"\\\"\\\"Place new values in the cache under the given keys. .. versionadded:: 0.5.0\",\n \"self.backend.delete(key) def delete_multi(self, keys): \\\"\\\"\\\"Remove multiple values from the cache. This operation is\",\n \"'__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return\",\n \"value, as well as returning that value:: newvalue = generate_something.refresh(5, 6) .. versionadded::\",\n \"the value returned by the \\\"creator\\\", and will then return True or False,\",\n \"calling the decorated function will also be a dictionary. If left at its\",\n \":return: Boolean. True if region was invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError()\",\n \"self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner =\",\n \"not a number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry =\",\n \"invalidation options. With \\\"hard\\\" invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate regeneration of the\",\n \"available myconfig = { \\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\", \\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\", \\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\", \\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1, 10.0.0.1\\\", } local_region.configure_from_config(myconfig, \\\"cache.local.\\\") memcached_region.configure_from_config(myconfig,\",\n \"the :meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1 \\\"\\\"\\\" return 'backend' in self.__dict__ def\",\n \"expiration_time() if expiration_time_is_callable \\\\ else expiration_time if asdict: def dict_create(*keys): d_values = creator(*keys)\",\n \"{ \\\"ct\\\": time.time(), \\\"v\\\": value_version }) def set(self, key, value): \\\"\\\"\\\"Place a new\",\n \"def one(a, b): return a + b Above, calling ``one(3, 4)`` will produce\",\n \"= dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k] for k in keys_to_create]) timeout\",\n \"mapping[key]) for gen_key, key in zip(gen_keys, keys)) ) def get(*arg): keys = key_generator(*arg)\",\n \"older than the last region invalidation time and region is invalidated in hard\",\n \"the given key. If the value does not exist or is considered to\",\n \"is optional, and is used normally to disambiguate two functions of the same\",\n \"'distributed_lock': True, } ) Remember that the first request for a key with\",\n \"the cache region unless a new value is needed:: result = generate_something(5, 6)\",\n \"if self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v)) for k, v in mapping.items()) else:\",\n \"should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \\\"\\\"\\\"A function decorator that will cache the return value of\",\n \"reaching the cache. .. versionadded:: 0.5.0 :param function_key_generator: a function that will produce\",\n \"not consulted outside this function, so in fact can be of any form.\",\n \"when specified, will be passed to and called by dogpile.lock when there is\",\n \"depends on if the *dogpile lock* can be acquired or not. If it\",\n \"of keys to be generated is passed to ``creator()``, and ``creator()`` should return\",\n \"raise exception.RegionNotConfigured( \\\"No backend is configured on this region.\\\") @property def is_configured(self): \\\"\\\"\\\"Return\",\n \"the cache, based on the given key. If the value is not present,\",\n \"mutexes: # sort the keys, the idea is to prevent deadlocks. # though\",\n \"is released to return the new value. .. versionchanged:: 0.3.0 The value is\",\n \"of the function, the module name for the function, the arguments passed, as\",\n \"final result of calling the decorated function will also be a list. When\",\n \"week or time period\\\" and \\\"cache until a certain date or time passes\\\".\",\n \"not mapping: return if self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v)) for k, v\",\n \"``self`` or ``cls``, making the decorator suitable (with caveats) for use with instance\",\n \"has passed since the last generation. :param arguments: Optional. The structure here is\",\n \"self._mutex(key), gen_value, get_value, expiration_time, async_creator) as value: return value def get_or_create_multi( self, keys,\",\n \"subset of the given keys. The list of keys to be generated is\",\n \"fn.__name__ + (namespace or '') def generate_keys(*args): return [namespace + ':' + str(a)\",\n \"invoked. However, subsequent requests for cached-but-expired values will still return promptly. They will\",\n \"ct = time.time() - expiration_time - .0001 return value.payload, ct def gen_value(): created_value\",\n \"def my_function(a, b, **kw): return my_data() .. seealso:: :func:`.function_key_generator` - default key generator\",\n \"mutexes = {} sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k) for k\",\n \"value is not available\\\", e.g. # _has_value() will return False. return value.payload, 0\",\n \"lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass try: if mutexes: #\",\n \"self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for k, v in values_w_created.items() if should_cache_fn(v[0]) ))\",\n \"a new value into the cache with the new value, as well as\",\n \"each key. It will then consult the cache using the same mechanism as\",\n \"fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys = arg keys = key_generator(*arg, **kw)\",\n \"= self.backend.get_mutex(key) if mutex is not None: return mutex else: return self._LockWrapper() def\",\n \"[self.key_mangler(k) for k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys))\",\n \"= time.time() self._hard_invalidated = None def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp <\",\n \"between ``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python class declaration mechanics otherwise prevent the\",\n \"self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return\",\n \"declared. :param expiration_time: if not None, will override the normal expiration time. May\",\n \"a previous, backwards-incompatible version. \\\"\\\"\\\" class RegionInvalidationStrategy(object): \\\"\\\"\\\"Region invalidation strategy interface Implement this\",\n \"\\\"\\\"\\\"Check timestamp to determine if it was soft invalidated. :return: Boolean. True if\",\n \"or class methods. Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\\\"foo\\\") def one(self, a, b):\",\n \"the creation time is older than the last call to :meth:`.invalidate`. :param key:\",\n \"been called, and the retrieved value's timestamp is older than the invalidation timestamp,\",\n \"specify arguments to pluck from \\\\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return\",\n \"but isn't cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" def get_value(key):\",\n \"timestamp): \\\"\\\"\\\"Check timestamp to determine if it was hard invalidated. :return: Boolean. True\",\n \"that the ``creator()`` function may be asked to generate any subset of the\",\n \"returns a sequence of new values. :param expiration_time: optional expiration time which will\",\n \"creator(): return fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable \\\\ else expiration_time return\",\n \"may be needed to disambiguate functions of the same name within the same\",\n \"be acquired or not. If it can't, it means a different thread or\",\n \"generate_something.set(3, 5, 6) The above example is equivalent to calling ``generate_something(5, 6)``, if\",\n \"\\\"filename\\\":\\\"file.dbm\\\" } ) The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted\",\n \"as a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method as well as the :meth:`.CacheRegion.cache_on_arguments` decorator\",\n \"namespace: optional string argument which will be established as part of the cache\",\n \"= get return decorate return decorator def make_region(*arg, **kw): \\\"\\\"\\\"Instantiate a new :class:`.CacheRegion`.\",\n \"subsequent getters will return the \\\"old\\\" value until the new one is available.\",\n \"until a certain date or time passes\\\". .. versionchanged:: 0.5.0 ``expiration_time`` may be\",\n \"is added to provide extra caching possibilities relative to the function. This is\",\n \"mangling, set to ``False``. Another typical mangler is the built-in Python function ``str``,\",\n \"can be acquired or not. If it can't, it means a different thread\",\n \"the cache using the same mechanism as that of :meth:`.CacheRegion.get_multi` to retrieve all\",\n \"Any retrieved value whose creation time is prior to this timestamp is considered\",\n \"expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a cached value based on the given key. If the\",\n \"}) def set(self, key, value): \\\"\\\"\\\"Place a new value in the cache under\",\n \"lock is released to return the new value. .. versionchanged:: 0.3.0 The value\",\n \"creator, mutex): ''' Used by dogpile.core:Lock when appropriate ''' def runner(): try: value\",\n \"the given keys. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not mapping: return if self.key_mangler:\",\n \"time and region is invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError() def is_soft_invalidated(self,\",\n \"present, the method returns the token ``NO_VALUE``. ``NO_VALUE`` evaluates to False, but is\",\n \"on a non-existent key, safely) \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.delete(key) def\",\n \"current values; the originally passed keys corresponding to those values which aren't generated\",\n \"one anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k], self._value(v))\",\n \"itself and the arguments passed to it. This method is the \\\"multiple key\\\"\",\n \"E.g.:: def dont_cache_none(value): return value is not None value = region.get_or_create(\\\"some key\\\", create_value,\",\n \"expiration_time == -1: expiration_time = None mutexes = {} sorted_unique_keys = sorted(set(keys)) if\",\n \"and is set to ``None``. .. versionadded:: 0.4.2 added the async_creation_runner feature. \\\"\\\"\\\"\",\n \"gen_value(): created_value = creator() value = self._value(created_value) if not should_cache_fn or \\\\ should_cache_fn(created_value):\",\n \"self._value(created_value) if not should_cache_fn or \\\\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\\\"ct\\\"] if\",\n \"v is not NO_VALUE) else: result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return\",\n \"in conjunction with Unicode keys. :param async_creation_runner: A callable that, when specified, will\",\n \"indicating if the value should actually be cached or not. If it returns\",\n \"optional namespace and with the string form of each key. It will then\",\n \"coerce_string_conf from .util import function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue from .proxy\",\n \"wrap_cache_fn(value): if value is NO_VALUE: return False elif not should_cache_fn: return True else:\",\n \"wish to have access to the :class:`.CacheRegion` itself should construct the invalidator given\",\n \"with Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass\",\n \"you are using a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies values, take note this\",\n \"configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\"\",\n \"def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is False\",\n \"method is the \\\"multiple key\\\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def\",\n \"the creator, and only if it returns True will that value be placed\",\n \"key): return self._lock_registry.get(key) class _LockWrapper(object): \\\"\\\"\\\"weakref-capable wrapper for threading.Lock\\\"\\\"\\\" def __init__(self): self.lock =\",\n \"return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp < self._soft_invalidated) The custom\",\n \"the given arguments:: values = generate_something.get(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") .. versionadded:: 0.5.3 Added ``get()``\",\n \"should_cache_fn) return result def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys =\",\n \"that modifies values, take note this function invokes ``.set_multi()`` for newly generated values\",\n \"or Unicode keys to bytestrings, which is needed when using a backend such\",\n \"True, } ) Remember that the first request for a key with no\",\n \"PluginLoader(\\\"dogpile.cache\\\") register_backend = _backend_loader.register from . import backends # noqa value_version = 1\",\n \"dogpile.lock when there is a stale value present in the cache. It will\",\n \"if True, the existing cache backend will be replaced. Without this flag, an\",\n \"else value for value in ( _unexpired_value_fn(value) for value in backend_values ) ]\",\n \"0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function using a decorator.\",\n \"the generated values as a sequence corresponding to the order of the keys.\",\n \"on keys corresponds to that of :meth:`.Region.get_or_create`, with the exception that the ``creator()``\",\n \"to_str=compat.string_type, function_key_generator=None): \\\"\\\"\\\"A function decorator that will cache the return value of the\",\n \"needed:: result = generate_something(5, 6) The function is also given an attribute ``invalidate()``,\",\n \"decorated function should return its result as a dictionary of keys->values, and the\",\n \"already configured on this :class:`.CacheRegion` if not None. To set no expiration, use\",\n \"the function returns the value of create_value() if the cache is invalid, however\",\n \"keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the decorated function is also provided with a\",\n \"config_dict[\\\"%sbackend\\\" % prefix], expiration_time=config_dict.get( \\\"%sexpiration_time\\\" % prefix, None), _config_argument_dict=config_dict, _config_prefix=\\\"%sarguments.\\\" % prefix, wrap=config_dict.get(\",\n \"given keys. The list of keys to be generated is passed to ``creator()``,\",\n \"until the end of the day, week or time period\\\" and \\\"cache until\",\n \"value decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get\",\n \"have access to the :class:`.CacheRegion` itself should construct the invalidator given the region\",\n \"check. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not keys: return [] if self.key_mangler: keys\",\n \"retrieved value's timestamp is older than the invalidation timestamp, the value is unconditionally\",\n \"6) .. versionadded:: 0.5.0 Added ``refresh()`` method to decorated function. Lastly, the ``get()``\",\n \"should actually be cached or not. If it returns False, the value is\",\n \"= None self._invalidated = None def invalidate(self, hard=True): self._is_hard_invalidated = bool(hard) self._invalidated =\",\n \":meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside this function, so in fact can be of\",\n \"is being declared. :param expiration_time: if not None, will override the normal expiration\",\n \"namespace: optional string argument which will be established as part of each cache\",\n \"\\\\ else expiration_time if asdict: def dict_create(*keys): d_values = creator(*keys) return [ d_values.get(key_lookup[k],\",\n \"class RegionInvalidationStrategy(object): \\\"\\\"\\\"Region invalidation strategy interface Implement this interface and pass implementation instance\",\n \"gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in zip(gen_keys, keys)) )\",\n \"against the cache. When the dogpile lock cannot be acquired, the method will\",\n \"for configuring a region from a config file. :param function_key_generator: Optional. A function\",\n \"= NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator:\",\n \"regardless of configured expiration times or whether or not :meth:`.invalidate` was called. ..\",\n \"it returns False, the value is still returned, but isn't cached. .. versionadded::\",\n \"when using the :meth:`.CacheRegion.cache_on_arguments` method. The structure of this function should be two\",\n \"as an optional \\\"namespace\\\" parameter in order to generate a cache key. Given\",\n \"to decorated function. Lastly, the ``get()`` method returns either the value cached for\",\n \"= set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get decorate.original =\",\n \"that also uses keyword arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but\",\n \"be called normally. The decorator will produce a list of cache keys using\",\n \"as those associated with classes - note that the decorator itself can't see\",\n \"to :func:`.function_key_generator`. :param namespace: optional string argument which will be established as part\",\n \"self._is_hard_invalidated = bool(hard) self._invalidated = time.time() def is_invalidated(self, timestamp): return (self._invalidated is not\",\n \"time, rather than returning the value unconditionally. The method also interprets the cached\",\n \"\\\"This region is already \\\" \\\"configured with backend: %s. \\\" \\\"Specify replace_existing_backend=True to\",\n \"which accepts a sequence of keys and returns a sequence of new values.\",\n \"\\\\ else expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key =\",\n \"(orig_to_mangled[k], self._value(v)) for k, v in zip(keys_to_get, new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created)\",\n \"in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \\\"\\\"\\\"Remove a value from the cache. This\",\n \"refresh(*arg, **kw): key = key_generator(*arg, **kw) value = fn(*arg, **kw) self.set(key, value) return\",\n \"invalidate decorate.refresh = refresh decorate.get = get decorate.original = fn return decorate return\",\n \"with a single function signature, one which takes a simple list of keys\",\n \"using the :meth:`.CacheRegion.cache_on_arguments` method. The structure of this function should be two levels:\",\n \"to that of :meth:`.Region.get_or_create`, with the exception that the ``creator()`` function may be\",\n \"a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of the function\",\n \"may or may not be used to recreate the value and persist the\",\n \"async_creation_runner callable implements. By default the async_creation_runner is disabled and is set to\",\n \"since the last generation. :param arguments: Optional. The structure here is passed directly\",\n \".. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator\",\n \"each of which will be applied in a chain to ultimately wrap the\",\n \"of the :meth:`.CacheRegion.get_or_create_multi` method to access the cache and conditionally call the function.\",\n \"is a passthrough to :class:`.CacheRegion`. See that class for constructor arguments. \\\"\\\"\\\" return\",\n \"def get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values\",\n \"system like Celery. For a specific example using async_creation_runner, new values can be\",\n \"expiration_time = self.expiration_time current_time = time.time() def value_fn(value): if value is NO_VALUE: return\",\n \"return list of keys. For example:: def my_multi_key_generator(namespace, fn, **kw): namespace = fn.__name__\",\n \"key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys = list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key])\",\n \"interface and pass implementation instance to :meth:`.CacheRegion.configure` to override default region invalidation. Example::\",\n \"of the current \\\"invalidation\\\" time as set by the :meth:`.invalidate` method. If a\",\n \"key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None, arguments=None,\",\n \"timestamp < self._soft_invalidated) The custom implementation is injected into a :class:`.CacheRegion` at configure\",\n \"and is resolved by loading the class from the ``dogpile.cache`` entrypoint. :param expiration_time:\",\n \"If a value is present, but its creation time is older than the\",\n \"\\\" \\\"configured with backend: %s. \\\" \\\"Specify replace_existing_backend=True to replace.\\\" % self.backend) backend_cls\",\n \"timestamp): return (self._hard_invalidated and timestamp < self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self,\",\n \"for a key with no associated value will always block; async_creator will not\",\n \"0.3.0 \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key) value = self._unexpired_value_fn(\",\n \"given keys. Returns values as a list matching the keys given. E.g.:: values\",\n \"but isn't cached. E.g.:: def dont_cache_none(value): return value is not None value =\",\n \"the method is given a non-None expiration time. .. versionadded:: 0.3.0 :param hard:\",\n \"if \\\"backend\\\" in self.__dict__ and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \\\"This region is already\",\n \"Python class declaration mechanics otherwise prevent the decorator from having awareness of the\",\n \"which here accepts a mapping of keys and values to set in the\",\n \"each cache key. :param expiration_time: if not None, will override the normal expiration\",\n \"value def get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a sequence of cached\",\n \"keys: return [] if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) backend_values =\",\n \"sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys] else: mangled_keys =\",\n \"value should actually be cached or not. If it returns False, the value\",\n \"new argument list, and the decorated function is then called with that subset\",\n \"function_multi_key_generator: a function that will produce a list of keys. This function will\",\n \"region unless a new value is needed:: result = generate_something(5, 6) The function\",\n \".. versionadded:: 0.5.0 :param function_multi_key_generator: a function that will produce a list of\",\n \"A correct implementation of ``.set_multi()`` will not modify values in-place on the submitted\",\n \"method, which has the effect of deleting the given sequence of keys using\",\n \"expiration time. .. versionadded:: 0.3.0 :param hard: if True, cache values will all\",\n \"the cache and conditionally call the function. See that method for additional behavioral\",\n \"key = key_generator(*arg, **kw) self.set(key, value) def get(*arg, **kw): key = key_generator(*arg, **kw)\",\n \"be a dictionary. If left at its default value of ``False``, the decorated\",\n \"to ``set()`` is ``refresh()``. This attribute will invoke the decorated function and populate\",\n \"available, until the lock is released and a new value available. If a\",\n \"or time period\\\" and \\\"cache until a certain date or time passes\\\". ..\",\n \"or process is already running a creation function for this key against the\",\n \"**kw): key = key_generator(*arg, **kw) return self.get(key) def refresh(*arg, **kw): key = key_generator(*arg,\",\n \"and conditionally call the function. See that method for additional behavioral details. E.g.::\",\n \"override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated = None self._hard_invalidated\",\n \"to replace.\\\" % self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict,\",\n \"Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`. See that class for constructor arguments.\",\n \"when config is available myconfig = { \\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\", \\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\", \\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\", \\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1, 10.0.0.1\\\", }\",\n \"= compat.callable(expiration_time) if function_key_generator is None: function_key_generator = self.function_key_generator def decorator(fn): if to_str\",\n \"multiple key/value version \\\"\\\"\\\" orig_key = key if self.key_mangler: key = self.key_mangler(key) def\",\n \"\\\"ct\\\": time.time(), \\\"v\\\": value_version }) def set(self, key, value): \\\"\\\"\\\"Place a new value\",\n \"without calling the decorated function. The value to be cached is passed as\",\n \"value = self._value(created_value) if not should_cache_fn or \\\\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload,\",\n \"into a SHA1 hash, so that the string length is fixed. To disable\",\n \"@region.cache_on_arguments(namespace=\\\"foo\\\") def one(a, b): return a + b Above, calling ``one(3, 4)`` will\",\n \"pass to the function itself to represent a particular value:: generate_something.invalidate(5, 6) Another\",\n \"the function itself and the arguments passed to it. This method is the\",\n \"and timestamp < self._soft_invalidated) or (self._hard_invalidated and timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return\",\n \"as bsddb or dbm under Python 2.x in conjunction with Unicode keys. :param\",\n \"older than the invalidation timestamp, the value is unconditionally prevented from being returned.\",\n \"dictionary returned by the decorated function is missing keys, those keys will not\",\n \"**kw) self.delete(key) def set_(value, *arg, **kw): key = key_generator(*arg, **kw) self.set(key, value) def\",\n \"which all getters will wait for. With \\\"soft\\\" invalidation, subsequent getters will return\",\n \"``ignore_expiration=True`` bypasses the expiration time check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks the\",\n \"if the function were to produce the value ``3`` as the value to\",\n \"This may be needed to disambiguate functions of the same name within the\",\n \"arguments to pluck from \\\\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return \\\":\\\".join(\",\n \"keys, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return multiple values from the cache, based on the given\",\n \"local to this instance of :class:`.CacheRegion`. Once set, the invalidation time is honored\",\n \"is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is False def\",\n \"is a list:: result = generate_something(\\\"key1\\\", \\\"key2\\\", \\\"key3\\\") The decorator internally makes use\",\n \"function is given a value as returned by the creator, and only if\",\n \"the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" expiration_time_is_callable =\",\n \"which will return values based on the given arguments:: values = generate_something.get(\\\"k1\\\", \\\"k2\\\",\",\n \"cache:: generate_something.set({\\\"k1\\\": \\\"value1\\\", \\\"k2\\\": \\\"value2\\\", \\\"k3\\\": \\\"value3\\\"}) ...an ``invalidate()`` method, which has the\",\n \"list of keys to be generated is passed to ``creator()``, and ``creator()`` should\",\n \"= make_region( function_key_generator = my_key_generator ).configure( \\\"dogpile.cache.dbm\\\", expiration_time=300, arguments={ \\\"filename\\\":\\\"file.dbm\\\" } ) The\",\n \"**kw): return \\\":\\\".join( [kw[k] for k in namespace] + [str(x) for x in\",\n \"backend. Defaults to ``None``, in which case the key mangling function recommended by\",\n \"default, the configured expiration time of the :class:`.CacheRegion`, or alternatively the expiration time\",\n \"def creator(): return fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable \\\\ else expiration_time\",\n \"return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\\\"ct\\\"]): return NO_VALUE else: return value return value_fn def\",\n \"a list. When ``asdict==True`` if the dictionary returned by the decorated function is\",\n \"a sequence corresponding to the order of the keys. The method uses the\",\n \"Where the decorator might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw):\",\n \"be called multiple times, or on a non-existent key, safely) \\\"\\\"\\\" if self.key_mangler:\",\n \"return generate_key Where the decorator might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a,\",\n \"Passing the flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionadded:: 0.5.0 \\\"\\\"\\\"\",\n \"key = key_generator(*arg, **kw) return self.get(key) def refresh(*arg, **kw): key = key_generator(*arg, **kw)\",\n \"self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping): \\\"\\\"\\\"Place new values in the cache under\",\n \"return values decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get =\",\n \"type recognized by the backend or by the key_mangler function, if present. :param\",\n \"of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \\\"\\\"\\\" if \\\"backend\\\" in self.__dict__ and not replace_existing_backend:\",\n \"the flag ``ignore_expiration=True`` bypasses the invalidation time check. .. versionadded:: 0.3.0 Support for\",\n \"the originally passed keys corresponding to those values which aren't generated or need\",\n \"is then called with that subset of arguments. The returned result is a\",\n \":meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable, will\",\n \"s in arg) return generate_key region = make_region( function_key_generator = my_key_generator ).configure( \\\"dogpile.cache.dbm\\\",\",\n \"to the dogpile system. May be passed as an integer number of seconds,\",\n \"a specific example using async_creation_runner, new values can be created in a background\",\n \"# though haven't been able to simulate one anyway. keys_to_get = sorted(mutexes) new_values\",\n \"string length is fixed. To disable all key mangling, set to ``False``. Another\",\n \"is the built-in Python function ``str``, which can be used to convert non-string\",\n \"an initial argument of ``self`` or ``cls``, making the decorator suitable (with caveats)\",\n \"b The cache key above for ``MyClass().one(3, 4)`` will again produce the same\",\n \"somemethod(self, x, y): \\\"\\\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y): \\\"\\\" Above,\",\n \"a + b The cache key above for ``MyClass().one(3, 4)`` will again produce\",\n \"is set to ``None``. .. versionadded:: 0.4.2 added the async_creation_runner feature. \\\"\\\"\\\" def\",\n \"__init__(self): self.lock = threading.Lock() def acquire(self, wait=True): return self.lock.acquire(wait) def release(self): self.lock.release() def\",\n \"is_soft_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was soft invalidated. :return: Boolean.\",\n \"lock cannot be acquired, the method will block if no previous value is\",\n \"acquired or not. If it can't, it means a different thread or process\",\n \"invalidated in soft mode. :return: Boolean. True if region was invalidated in soft\",\n \"should_cache_fn: return True else: return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn)\",\n \"was called. .. versionadded:: 0.3.0 \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) value =\",\n \"honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports both \\\"hard\\\"\",\n \"\\\"v\\\": value_version }) def set(self, key, value): \\\"\\\"\\\"Place a new value in the\",\n \") def get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg)\",\n \"value. Pass to ``invalidate()`` the same arguments you'd pass to the function itself\",\n \"= dict((k, self._value(v)) for k, v in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \\\"\\\"\\\"Remove\",\n \"the dictionary returned by the decorated function is missing keys, those keys will\",\n \"a valid ProxyBackend\\\" % type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self, key): return self._lock_registry.get(key)\",\n \"time is older than the current invalidation time, the ``NO_VALUE`` token is returned.\",\n \"_config_prefix=\\\"%sarguments.\\\" % prefix, wrap=config_dict.get( \\\"%swrap\\\" % prefix, None), ) @memoized_property def backend(self): raise\",\n \"\\\"invalidation\\\" time as set by the :meth:`.invalidate` method. If a value is present,\",\n \"Boolean. True if region was invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError() class\",\n \".. versionadded:: 0.3.0 \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key) value\",\n \"to calling ``generate_something(5, 6)``, if the function were to produce the value ``3``\",\n \"the decorator itself can't see the parent class on a function as the\",\n \"using a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of the\",\n \"the function accepts non-ascii unicode arguments on Python 2.x, the ``unicode()`` builtin can\",\n \"key. If the value does not exist or is considered to be expired\",\n \"*dynamic* expiration time for the cached function result. Example use cases include \\\"cache\",\n \"region as an argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self, region): self.region = region #\",\n \"default invalidation system works by setting a current timestamp (using ``time.time()``) to consider\",\n \"See that method for additional behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x, y): return\",\n \"than the last region invalidation time and region is invalidated in soft mode.\",\n \"\\\"backend\\\" in self.__dict__ and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \\\"This region is already \\\"\",\n \"a string name for the region. This isn't used internally but can be\",\n \"a backend is already configured. .. versionadded:: 0.5.7 :param region_invalidator: Optional. Override default\",\n \"be stale. It does not affect the data in the cache in any\",\n \"expiration time value which will supersede that configured on the :class:`.CacheRegion` itself. ..\",\n \"created_value = creator() value = self._value(created_value) if not should_cache_fn or \\\\ should_cache_fn(created_value): self.backend.set(key,\",\n \"v) for k, v in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for\",\n \"from the cache. This operation is idempotent (can be called multiple times, or\",\n \"requires that the region or the method is given a non-None expiration time.\",\n \"declaration mechanics otherwise prevent the decorator from having awareness of the ``MyClass`` and\",\n \"``get()`` method to decorated function. Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning\",\n \"\\\"cache key\\\". This function will supersede the one configured on the :class:`.CacheRegion` itself.\",\n \":meth:`.CacheRegion.cache_on_arguments`, combining the name of the function with the optional namespace and with\",\n \"Example use cases include \\\"cache the result until the end of the day,\",\n \"a new value. :param expiration_time: optional expiration time which will overide the expiration\",\n \"time.time() self._hard_invalidated = None def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated)\",\n \"\\\"_\\\" + fname + \\\"_\\\".join(str(s) for s in arg) return generate_key region =\",\n \"for the function, the arguments passed, as well as an optional \\\"namespace\\\" parameter\",\n \"decorate.get = get decorate.original = fn return decorate return decorator def cache_multi_on_arguments( self,\",\n \"backend. If you are using a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies values, take\",\n \"of the function with the optional namespace and with the string form of\",\n \"self._invalidated = time.time() def is_invalidated(self, timestamp): return (self._invalidated is not None and timestamp\",\n \"by the key_mangler function, if present. :param expiration_time: Optional expiration time value which\",\n \"is returned from the cache if present, regardless of configured expiration times or\",\n \".. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function using\",\n \"will ignore an initial argument of ``self`` or ``cls``, making the decorator suitable\",\n \"method) will call upon the value creation function after this time period has\",\n \"method to decorated function. Similar to ``set()`` is ``refresh()``. This attribute will invoke\",\n \"calling ``one(3, 4)`` will produce a cache key as follows:: myapp.tools:one|foo|3 4 The\",\n \"generation of values based on keys corresponds to that of :meth:`.Region.get_or_create`, with the\",\n \"returning that value:: newvalue = generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added ``refresh()`` method\",\n \"flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks\",\n \"decorator internally makes use of the :meth:`.CacheRegion.get_or_create` method to access the cache and\",\n \"creator, timeout, should_cache_fn) return result def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def set_(mapping):\",\n \"the cached value is ignored and the ``NO_VALUE`` token is returned. Passing the\",\n \"the :meth:`.invalidate` method has been called, and the retrieved value's timestamp is older\",\n \"generate_keys(*args): return [namespace + ':' + str(a) for a in args] return generate_keys\",\n \"so:: import threading def async_creation_runner(cache, somekey, creator, mutex): ''' Used by dogpile.core:Lock when\",\n \"same mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...a ``refresh()`` method, which\",\n \"returned. :param backend: Required. This is the name of the :class:`.CacheBackend` to use,\",\n \"on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \\\"\\\"\\\" expiration_time_is_callable\",\n \":func:`.make_region` and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`. :param namespace: optional string argument which\",\n \"from .. import Lock, NeedRegenerationException from ..util import NameRegistry from . import exception\",\n \"return [namespace + ':' + str(a) for a in args] return generate_keys :param\",\n \".0001 return value.payload, ct def gen_value(): raise NotImplementedError() def async_creator(key, mutex): mutexes[key] =\",\n \"to have access to the :class:`.CacheRegion` itself should construct the invalidator given the\",\n \"None self._invalidated = None def invalidate(self, hard=True): self._is_hard_invalidated = bool(hard) self._invalidated = time.time()\",\n \"implements. By default the async_creation_runner is disabled and is set to ``None``. ..\",\n \"the string form of each key. It will then consult the cache using\",\n \"the value does not exist or is considered to be expired based on\",\n \"constructor of the :class:`.CacheBackend` in use, though is typically a dictionary. :param wrap:\",\n \"int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time is not a number or timedelta.') if\",\n \"this :class:`.CacheRegion`. The default invalidation system works by setting a current timestamp (using\",\n \"already configured. .. versionadded:: 0.5.7 :param region_invalidator: Optional. Override default invalidation strategy with\",\n \":param ignore_expiration: if ``True``, the value is returned from the cache if present,\",\n \"k, v in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \\\"\\\"\\\"Remove a value from the\",\n \"NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated = None self._invalidated = None def invalidate(self,\",\n \"based on the given key. If the value is not present, the method\",\n \"its creation time is older than the current invalidation time, the ``NO_VALUE`` token\",\n \"for :meth:`.CacheRegion.set` which will store a given value directly without calling the decorated\",\n \"This attribute will invoke the decorated function and populate a new value into\",\n \"self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \\\"\\\"\\\"A function decorator that will cache\",\n \"those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string argument which will be established\",\n \"\\\":\\\".join( [kw[k] for k in namespace] + [str(x) for x in arg] )\",\n \"value, or will wait until the lock is released to return the new\",\n \"The decorated function can then be called normally, where data will be pulled\",\n \":meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable, will be called on each function\",\n \"function, so in fact can be of any form. For example, it can\",\n \"data in the cache in any way, and is also local to this\",\n \"use the name of the function, the module name for the function, the\",\n \"If it can't, it means a different thread or process is already running\",\n \"sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys] else:\",\n \"will not be cached. :param to_str: callable, will be called on each function\",\n \"\\\"\\\"\\\"Construct a new :class:`.CacheRegion`.\\\"\\\"\\\" self.name = name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator\",\n \"now checks the value's creation time against the expiration time, rather than returning\",\n \"in soft mode. \\\"\\\"\\\" raise NotImplementedError() def is_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine\",\n \"values based on keys corresponds to that of :meth:`.Region.get_or_create`, with the exception that\",\n \"decorated function and populate a new value into the cache with the new\",\n \"string argument which will be established as part of each cache key. :param\",\n \"of keys. This function will supersede the one configured on the :class:`.CacheRegion` itself.\",\n \"to the function itself to represent a particular value:: generate_something.invalidate(5, 6) Another attribute\",\n \"the module name for the function, the arguments passed, as well as an\",\n \"to pluck from \\\\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return \\\":\\\".join( [kw[k]\",\n \"as a sequence corresponding to the order of the keys. The method uses\",\n \"expiration time passed to the dogpile system. May be passed as an integer\",\n \"without blocking. If the :meth:`.invalidate` method has been called, and the retrieved value's\",\n \"then # initialize it. if type(proxy) == type: proxy = proxy() if not\",\n \"if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\\\"ct\\\"])): raise NeedRegenerationException()\",\n \"``NO_VALUE`` evaluates to False, but is separate from ``None`` to distinguish between a\",\n \"default the async_creation_runner is disabled and is set to ``None``. .. versionadded:: 0.4.2\",\n \"can be called normally. The decorator will produce a list of cache keys\",\n \"value.payload, value.metadata[\\\"ct\\\"] if expiration_time is None: expiration_time = self.expiration_time if (expiration_time is None\",\n \"like so:: import threading def async_creation_runner(cache, somekey, creator, mutex): ''' Used by dogpile.core:Lock\",\n \"for k in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\\\ else expiration_time if\",\n \"if a backend is already configured. .. versionadded:: 0.5.7 :param region_invalidator: Optional. Override\",\n \"will return the \\\"old\\\" value until the new one is available. Usage of\",\n \"cached for the given key, or the token ``NO_VALUE`` if no such key\",\n \"key mangling before reaching the cache. .. versionadded:: 0.5.0 :param function_multi_key_generator: a function\",\n \"is not NO_VALUE) else: result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result\",\n \"a different thread or process is already running a creation function for this\",\n \"def generate_something(*keys): return [ somedatabase.query(key) for key in keys ] The decorated function\",\n \"value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time - .0001 return value.payload, ct\",\n \"values which aren't generated or need regeneration will be assembled into a new\",\n \"NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands a 0\",\n \"pulled from the cache region unless a new value is needed:: result =\",\n \"fn(*arg, **kw) self.set(key, value) return value decorate.set = set_ decorate.invalidate = invalidate decorate.refresh\",\n \"used as the ``expiration_time``. This callable will be called whenever the decorated function\",\n \"dict. :param keys: Sequence of keys to be retrieved. :param creator: function which\",\n \"given a value as returned by the creator, and only if it returns\",\n \"and pass implementation instance to :meth:`.CacheRegion.configure` to override default region invalidation. Example:: class\",\n \"self.key_mangler: mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled\",\n \"given creation function may or may not be used to recreate the value\",\n \"and populate a new value into the cache with the new value, as\",\n \".. versionchanged:: 0.3.0 The value is unconditionally regenerated if the creation time is\",\n \"= region.get_or_create(\\\"some key\\\", create_value, should_cache_fn=dont_cache_none) Above, the function returns the value of create_value()\",\n \"is prior to this timestamp is considered to be stale. It does not\",\n \"be cached. .. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any\",\n \"an instance method. The function key generation can be entirely replaced on a\",\n \"be cached is passed as the first argument, and the arguments which would\",\n \"``None``. By default, the configured expiration time of the :class:`.CacheRegion`, or alternatively the\",\n \"the region was invalidated in soft mode. :return: Boolean. True if region was\",\n \"async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None,\",\n \"else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for\",\n \"ignore_expiration)(value) return value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration: return lambda value: value\",\n \"delete_multi(self, keys): \\\"\\\"\\\"Remove multiple values from the cache. This operation is idempotent (can\",\n \"instance to :meth:`.CacheRegion.configure` to override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self):\",\n \"\\\\ current_time - value.metadata[\\\"ct\\\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\\\"ct\\\"]): return NO_VALUE\",\n \"somedatabase.query(x, y) The decorated function can then be called normally, where data will\",\n \"passed to the dogpile system. May be passed as an integer number of\",\n \"will be established as part of each cache key. :param expiration_time: if not\",\n \"if hard: self._soft_invalidated = None self._hard_invalidated = time.time() else: self._soft_invalidated = time.time() self._hard_invalidated\",\n \"to specify arguments to pluck from \\\\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw):\",\n \"to the function should follow:: generate_something.set(3, 5, 6) The above example is equivalent\",\n \"cache is invalid, however if the return value is None, it won't be\",\n \"self, orig_key, creator, mutex) else: async_creator = None with Lock( self._mutex(key), gen_value, get_value,\",\n \"generate_something.get(5, 6) .. versionadded:: 0.5.3 Added ``get()`` method to decorated function. The default\",\n \"return decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \\\"\\\"\\\"A function\",\n \"already \\\" \\\"configured with backend: %s. \\\" \\\"Specify replace_existing_backend=True to replace.\\\" % self.backend)\",\n \"generator :func:`.kwarg_function_key_generator` - optional gen that also uses keyword arguments :param function_multi_key_generator: Optional.\",\n \"value = region.get_or_create(\\\"some key\\\", create_value, should_cache_fn=dont_cache_none) Above, the function returns the value of\",\n \"generate any subset of the given keys. The list of keys to be\",\n \"self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration: return lambda\",\n \"Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key) for key in keys ] The\",\n \"call the function. See that method for additional behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments`\",\n \"values decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get\",\n \"returned. Passing the flag ``ignore_expiration=True`` bypasses the invalidation time check. .. versionadded:: 0.3.0\",\n \"from ..util import PluginLoader, memoized_property, coerce_string_conf from .util import function_key_generator, function_multi_key_generator from .api\",\n \"function that generates the key based on the given arguments. Such as:: def\",\n \"generated values as a sequence corresponding to the order of the keys. The\",\n \"decorated function is then called with that subset of arguments. The returned result\",\n \"when finished. This can be used to defer the computation of expensive creator\",\n \"string argument which will be established as part of the cache key. This\",\n \"``None``. .. versionadded:: 0.4.2 added the async_creation_runner feature. \\\"\\\"\\\" def __init__( self, name=None,\",\n \"SHA1 hash, so that the string length is fixed. To disable all key\",\n \")) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k in keys] finally: for mutex in mutexes.values():\",\n \"configured on this region.\\\") @property def is_configured(self): \\\"\\\"\\\"Return True if the backend has\",\n \"operation is idempotent (can be called multiple times, or on a non-existent key,\",\n \"as a list matching the keys given. E.g.:: values = region.get_multi([\\\"one\\\", \\\"two\\\", \\\"three\\\"])\",\n \"configuration dictionary and a prefix. Example:: local_region = make_region() memcached_region = make_region() #\",\n \"value.payload, 0 else: ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time\",\n \"token ``NO_VALUE``. ``NO_VALUE`` evaluates to False, but is separate from ``None`` to distinguish\",\n \"\\\"three\\\"]) To convert values to a dictionary, use ``zip()``:: keys = [\\\"one\\\", \\\"two\\\",\",\n \"used normally to disambiguate two functions of the same name within the same\",\n \"conditionally call the function. See that method for additional behavioral details. E.g.:: @someregion.cache_on_arguments()\",\n \"the region was invalidated in hard mode. :return: Boolean. True if region was\",\n \"-1: expiration_time = None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self, orig_key, creator,\",\n \"thread.start() region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True,\",\n \"keys, the idea is to prevent deadlocks. # though haven't been able to\",\n \"is not None and timestamp < self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is True\",\n \"module, as can occur when decorating instance or class methods as below:: class\",\n \"self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False,\",\n \"region.\\\") @property def is_configured(self): \\\"\\\"\\\"Return True if the backend has been configured via\",\n \"wrap=None, replace_existing_backend=False, region_invalidator=None ): \\\"\\\"\\\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned. :param\",\n \"soft mode. :return: Boolean. True if region was invalidated in soft mode. \\\"\\\"\\\"\",\n \"implementation is injected into a :class:`.CacheRegion` at configure time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter::\",\n \"callable will be called whenever the decorated function itself is called, in caching\",\n \"method to access the cache and conditionally call the function. See that method\",\n \"argument, and the arguments which would normally be passed to the function should\",\n \"of :class:`.CacheRegion`. Once set, the invalidation time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi`\",\n \"= function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys = arg keys\",\n \"% type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self, key): return self._lock_registry.get(key) class _LockWrapper(object): \\\"\\\"\\\"weakref-capable\",\n \"the arguments passed, as well as an optional \\\"namespace\\\" parameter in order to\",\n \":meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...a ``refresh()`` method, which will call the creation function,\",\n \"invalidation time and region is invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError() def\",\n \".. versionadded:: 0.5.0 Added ``refresh()`` method to decorated function. Lastly, the ``get()`` method\",\n \"given a non-None expiration time. .. versionadded:: 0.3.0 :param hard: if True, cache\",\n \"which takes a simple list of keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the decorated\",\n \"a callable, taking no arguments, that returns a value to be used as\",\n \"\\\"k3\\\") ...and a ``get()`` method, which will return values based on the given\",\n \"None, will override the normal expiration time. May be passed as an integer\",\n \"replaced. Without this flag, an exception is raised if a backend is already\",\n \"returned result is a list:: result = generate_something(\\\"key1\\\", \\\"key2\\\", \\\"key3\\\") The decorator internally\",\n \"values from the cache. This operation is idempotent (can be called multiple times,\",\n \"region was invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self):\",\n \"the expiration time check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks the value's creation\",\n \"of any type recognized by the backend or by the key_mangler function, if\",\n \"value, { \\\"ct\\\": time.time(), \\\"v\\\": value_version }) def set(self, key, value): \\\"\\\"\\\"Place a\",\n \"attached backend. ''' # if we were passed a type rather than an\",\n \"same source file, such as those associated with classes - note that the\",\n \"invalidation of the value. Pass to ``invalidate()`` the same arguments you'd pass to\",\n \".. versionchanged:: 0.5.0 ``expiration_time`` may be passed as a callable to :meth:`.CacheRegion.cache_on_arguments`. :param\",\n \"which aren't present in the list are returned as the ``NO_VALUE`` token. ``NO_VALUE``\",\n \"generate_something(\\\"key1\\\", \\\"key2\\\", \\\"key3\\\") The decorator internally makes use of the :meth:`.CacheRegion.get_or_create_multi` method to\",\n \"builtin can be substituted, but note this will produce unicode cache keys which\",\n \"typical mangler is the SHA1 mangler found at :func:`.sha1_mangle_key` which coerces keys into\",\n \"will return False. return value.payload, 0 else: ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct\",\n \"based on the given key. If the value does not exist or is\",\n \"def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \\\"\\\"\\\"Construct a new :class:`.CacheRegion`.\\\"\\\"\\\"\",\n \"values.get(key, NO_VALUE) if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])):\",\n \"called, in caching or retrieving. Thus, this can be used to determine a\",\n \"class _LockWrapper(object): \\\"\\\"\\\"weakref-capable wrapper for threading.Lock\\\"\\\"\\\" def __init__(self): self.lock = threading.Lock() def acquire(self,\",\n \"the future by way of, for example, a background thread, a long-running queue,\",\n \"= set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get return decorate\",\n \"key. It will then consult the cache using the same mechanism as that\",\n \"interface Implement this interface and pass implementation instance to :meth:`.CacheRegion.configure` to override default\",\n \"if expiration_time is None: expiration_time = self.expiration_time current_time = time.time() def value_fn(value): if\",\n \"the calling function. A correct implementation of ``.set_multi()`` will not modify values in-place\",\n \"a value to be used as the ``expiration_time``. This callable will be called\",\n \"dogpile.core understands a 0 here as # \\\"the value is not available\\\", e.g.\",\n \"local_region = make_region() memcached_region = make_region() # regions are ready to use for\",\n \"NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\\\"ct\\\"]): return NO_VALUE else: return value return value_fn def get_multi(self,\",\n \"elif self.region_invalidator.is_invalidated( value.metadata[\\\"ct\\\"]): return NO_VALUE else: return value return value_fn def get_multi(self, keys,\",\n \"function invokes ``.set_multi()`` for newly generated values using the same values it returns\",\n \"new value. .. versionchanged:: 0.3.0 The value is unconditionally regenerated if the creation\",\n \"k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values =\",\n \"should_cache_fn or \\\\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\\\"ct\\\"] if expiration_time is None:\",\n \"which will receive the value returned by the \\\"creator\\\", and will then return\",\n \"def async_creator(key, mutex): mutexes[key] = mutex if expiration_time is None: expiration_time = self.expiration_time\",\n \"sorted(mutexes) new_values = creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k], self._value(v)) for k, v in\",\n \"key_generator(*arg, **kw) self.set(key, value) def get(*arg, **kw): key = key_generator(*arg, **kw) return self.get(key)\",\n \"getters will return the \\\"old\\\" value until the new one is available. Usage\",\n \"prefix, wrap=config_dict.get( \\\"%swrap\\\" % prefix, None), ) @memoized_property def backend(self): raise exception.RegionNotConfigured( \\\"No\",\n \"self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key) value = self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return\",\n \"expiration_time is not None and \\\\ current_time - value.metadata[\\\"ct\\\"] > expiration_time: return NO_VALUE\",\n \"orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in orig_to_mangled.items():\",\n \"is_configured(self): \\\"\\\"\\\"Return True if the backend has been configured via the :meth:`.CacheRegion.configure` method\",\n \"generate_something.refresh(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...and a ``get()`` method, which will return values based on\",\n \"5, 6) The above example is equivalent to calling ``generate_something(5, 6)``, if the\",\n \"same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string argument which\",\n \"called by dogpile.lock when there is a stale value present in the cache.\",\n \"0.5.0 ``expiration_time`` may be optionally passed as a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method\",\n \"(self._hard_invalidated and timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return\",\n \"2.x in conjunction with Unicode keys. :param async_creation_runner: A callable that, when specified,\",\n \"value's timestamp is older than the invalidation timestamp, the value is unconditionally prevented\",\n \"\\\"\\\"\\\"Indicate the region was invalidated in hard mode. :return: Boolean. True if region\",\n \"all older timestamps effectively invalidated. \\\"\\\"\\\" raise NotImplementedError() def is_hard_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp\",\n \"the SHA1 mangler found at :func:`.sha1_mangle_key` which coerces keys into a SHA1 hash,\",\n \"= None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self, orig_key, creator, mutex) else:\",\n \"the decorator before it becomes an instance method. The function key generation can\",\n \"passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param\",\n \"is ignored and the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses\",\n \"``str``, which can be used to convert non-string or Unicode keys to bytestrings,\",\n \"function should follow:: generate_something.set(3, 5, 6) The above example is equivalent to calling\",\n \"return [ somedatabase.query(key) for key in keys ] The decorated function can be\",\n \"is None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str)\",\n \"be substituted, but note this will produce unicode cache keys which may require\",\n \"import with_statement from .. import Lock, NeedRegenerationException from ..util import NameRegistry from .\",\n \"under Python 2.x in conjunction with Unicode keys. :param async_creation_runner: A callable that,\",\n \"function is used depends on if the *dogpile lock* can be acquired or\",\n \"key_mangler function, if present. :param expiration_time: Optional expiration time value which will supersede\",\n \"``mapping`` dict. :param keys: Sequence of keys to be retrieved. :param creator: function\",\n \"self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for wrapper in\",\n \"be passed to the function should follow:: generate_something.set(3, 5, 6) The above example\",\n \"creator functions to later points in the future by way of, for example,\",\n \"not None, will override the normal expiration time. May be passed as an\",\n \"= expiration_time() if expiration_time_is_callable \\\\ else expiration_time if asdict: def dict_create(*keys): d_values =\",\n \"and is used normally to disambiguate two functions of the same name within\",\n \"issubclass(type(proxy), ProxyBackend): raise TypeError(\\\"Type %s is not a valid ProxyBackend\\\" % type(proxy)) self.backend\",\n \"False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \\\"\\\"\\\"A front end\",\n \"non-string or Unicode keys to bytestrings, which is needed when using a backend\",\n \"default key generator :func:`.kwarg_function_key_generator` - optional gen that also uses keyword arguments :param\",\n \"in the cache. :param asdict: if ``True``, the decorated function should return its\",\n \"``time.time()``). If stale, the cached value is ignored and the ``NO_VALUE`` token is\",\n \":meth:`.CacheRegion.get` now checks the value's creation time against the expiration time, rather than\",\n \"versionchanged:: 0.5.0 ``expiration_time`` may be passed as a callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn:\",\n \"gen_value, get_value, expiration_time, async_creator) as value: return value def get_or_create_multi( self, keys, creator,\",\n \"def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return \\\":\\\".join( [kw[k] for k in namespace]\",\n \"in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k in keys] finally:\",\n \":paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that wish to\",\n \"passed as a ``datetime.timedelta`` value. The :meth:`.CacheRegion.get_or_create` method as well as the :meth:`.CacheRegion.cache_on_arguments`\",\n \"end of the day, week or time period\\\" and \\\"cache until a certain\",\n \"to those values which aren't generated or need regeneration will be assembled into\",\n \"``set()`` method, which here accepts a mapping of keys and values to set\",\n \"values = generate_something.refresh(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...and a ``get()`` method, which will return values\",\n \"used to specify arguments to pluck from \\\\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg,\",\n \"and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated()\",\n \"keyword arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but it's used in\",\n \"current timestamp (using ``time.time()``) to consider all older timestamps effectively invalidated. \\\"\\\"\\\" raise\",\n \":meth:`.CacheRegion.get_or_create` will force an immediate regeneration of the value which all getters will\",\n \"\\\"cache until a certain date or time passes\\\". .. versionchanged:: 0.5.0 ``expiration_time`` may\",\n \"passed as a tuple, used to specify arguments to pluck from \\\\**kw:: def\",\n \"and ``MyOtherClass`` names, as the function is received by the decorator before it\",\n \"parameter in order to generate a cache key. Given a function ``one`` inside\",\n \"using the ``function_key_generator`` argument present on :func:`.make_region` and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`.\",\n \".. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator\",\n \"flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not\",\n \"= creator() value = self._value(created_value) if not should_cache_fn or \\\\ should_cache_fn(created_value): self.backend.set(key, value)\",\n \":class:`.CacheRegion` propagated call. The default invalidation system works by setting a current timestamp\",\n \"for k in keys] def wrap_cache_fn(value): if value is NO_VALUE: return False elif\",\n \"as a callable, taking no arguments, that returns a value to be used\",\n \"to ``invalidate()`` the same arguments you'd pass to the function itself to represent\",\n \"the creation time of the retrieved value versus the current time (as reported\",\n \"fn): def generate_key(*arg, **kw): return \\\":\\\".join( [kw[k] for k in namespace] + [str(x)\",\n \"for k in keys] finally: for mutex in mutexes.values(): mutex.release() def _value(self, value):\",\n \"\\\"%swrap\\\" % prefix, None), ) @memoized_property def backend(self): raise exception.RegionNotConfigured( \\\"No backend is\",\n \"time.time() else: self._soft_invalidated = time.time() self._hard_invalidated = None def is_invalidated(self, timestamp): return ((self._soft_invalidated\",\n \"invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate regeneration of the value which all getters\",\n \"timestamp): \\\"\\\"\\\"Check timestamp to determine if it was invalidated. :return: Boolean. True if\",\n \"Unicode keys. :param async_creation_runner: A callable that, when specified, will be passed to\",\n \"is also local to this instance of :class:`.CacheRegion`. Once set, the invalidation time\",\n \"decorate.original = fn return decorate return decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None,\",\n \"time is older than the last call to :meth:`.invalidate`. :param key: Key to\",\n \"the same cache key of ``myapp.tools:one|foo|3 4`` - the name ``self`` is skipped.\",\n \"the lock is released and a new value available. If a previous value\",\n \"import wraps import threading _backend_loader = PluginLoader(\\\"dogpile.cache\\\") register_backend = _backend_loader.register from . import\",\n \"self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper)\",\n \"received by the decorator before it becomes an instance method. The function key\",\n \"returned by the decorated function is missing keys, those keys will not be\",\n \") return values decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get\",\n \"function which will receive each value returned by the \\\"creator\\\", and will then\",\n \"function, if present. :param expiration_time: Optional expiration time value which will supersede that\",\n \"be passed the mutex and is responsible releasing that mutex when finished. This\",\n \"cache. It will be passed the mutex and is responsible releasing that mutex\",\n \"cache backend, before being optionally processed by the key_mangler function, so can be\",\n \"- applies :meth:`.get_or_create` to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value\",\n \"= dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in orig_to_mangled.items(): with\",\n \"get(self, key, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return a value from the cache, based on the\",\n \"values in the cache under the given keys. .. versionadded:: 0.5.0 \\\"\\\"\\\" if\",\n \"else: return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result = dict(\",\n \"will produce unicode cache keys which may require key mangling before reaching the\",\n \"def was_hard_invalidated(self): return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp)\",\n \"from .api import NO_VALUE, CachedValue from .proxy import ProxyBackend from ..util import compat\",\n \"result of calling the decorated function will also be a dictionary. If left\",\n \"region is invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError() def is_soft_invalidated(self, timestamp): \\\"\\\"\\\"Check\",\n \"whatever asynchronous means the provided async_creation_runner callable implements. By default the async_creation_runner is\",\n \"value for value in ( _unexpired_value_fn(value) for value in backend_values ) ] def\",\n \"self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \\\"\\\"\\\"A function decorator that will cache the\",\n \"as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \\\"\\\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC')\",\n \"\\\"\\\"\\\"Remove multiple values from the cache. This operation is idempotent (can be called\",\n \"result until the end of the day, week or time period\\\" and \\\"cache\",\n \"The default invalidation system works by setting a current timestamp (using ``time.time()``) to\",\n \"dogpile lock cannot be acquired, the method will block if no previous value\",\n \"ignored and the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses the\",\n \"result = generate_something(5, 6) The function is also given an attribute ``invalidate()``, which\",\n \"function using a sequence of keys derived from the function itself and the\",\n \"of each cache key. :param expiration_time: if not None, will override the normal\",\n \"zip(cache_keys, result) if v is not NO_VALUE) else: result = self.get_or_create_multi( keys, creator,\",\n \"the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that wish\",\n \"to access the cache and conditionally call the function. See that method for\",\n \"for use with instance or class methods. Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\\\"foo\\\")\",\n \"use of the :meth:`.CacheRegion.get_or_create_multi` method to access the cache and conditionally call the\",\n \"sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys)))\",\n \"a :class:`.CacheRegion` at configure time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region\",\n \"note: **not** the :meth:`.CacheRegion.get` method) will call upon the value creation function after\",\n \"To disable all key mangling, set to ``False``. Another typical mangler is the\",\n \"number of seconds, or as a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time`` may\",\n \"\\\"k2\\\", \\\"k3\\\") ...and a ``get()`` method, which will return values based on the\",\n \":meth:`.CacheRegion.get_multi` to retrieve all current values; the originally passed keys corresponding to those\",\n \"last region invalidation time and region is invalidated in hard mode. \\\"\\\"\\\" raise\",\n \"the class from the ``dogpile.cache`` entrypoint. :param expiration_time: Optional. The expiration time passed\",\n \"proxy): ''' Takes a ProxyBackend instance or class and wraps the attached backend.\",\n \"@memoized_property def backend(self): raise exception.RegionNotConfigured( \\\"No backend is configured on this region.\\\") @property\",\n \"If the value is not present, the method returns the token ``NO_VALUE``. ``NO_VALUE``\",\n \"is_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was invalidated. :return: Boolean. True\",\n \"be invoked. However, subsequent requests for cached-but-expired values will still return promptly. They\",\n \"optionally processed by the key_mangler function, so can be of any type recognized\",\n \"that value is returned immediately without blocking. If the :meth:`.invalidate` method has been\",\n \"self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend,\",\n \"thread = threading.Thread(target=runner) thread.start() region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url':\",\n \"name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner\",\n \"the given keys. The list of keys to be generated is passed to\",\n \"relative to the function. This is a convenience method for :meth:`.CacheRegion.set` which will\",\n \"to the constructor of the :class:`.CacheBackend` in use, though is typically a dictionary.\",\n \"invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated = None self._hard_invalidated = None def\",\n \"but is separate from ``None`` to distinguish between a cached value of ``None``.\",\n \"in-place on the submitted ``mapping`` dict. :param keys: Sequence of keys to be\",\n \"acquire the dogpile lock to generate a new value, or will wait until\",\n \"sequence of cached values based on a sequence of keys. The behavior for\",\n \"module ``myapp.tools``:: @region.cache_on_arguments(namespace=\\\"foo\\\") def one(a, b): return a + b Above, calling ``one(3,\",\n \"makes use of the :meth:`.CacheRegion.get_or_create` method to access the cache and conditionally call\",\n \"True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is\",\n \"will produce a \\\"cache key\\\" given a data creation function and arguments, when\",\n \"be used to convert non-string or Unicode keys to bytestrings, which is needed\",\n \"of the cache key. This may be needed to disambiguate functions of the\",\n \"the ``expiration_time``. This callable will be called whenever the decorated function itself is\",\n \"async_creation_runner: A callable that, when specified, will be passed to and called by\",\n \"than the last region invalidation time. \\\"\\\"\\\" raise NotImplementedError() def was_soft_invalidated(self): \\\"\\\"\\\"Indicate the\",\n \"= fn.__name__ + (namespace or '') def generate_keys(*args): return [namespace + ':' +\",\n \"generate a new value, or will wait until the lock is released to\",\n \"process is already running a creation function for this key against the cache.\",\n \"value. .. versionchanged:: 0.3.0 The value is unconditionally regenerated if the creation time\",\n \"return namespace + \\\"_\\\" + fname + \\\"_\\\".join(str(s) for s in arg) return\",\n \"be acquired, the method will block if no previous value is available, until\",\n \"Optional. A list of :class:`.ProxyBackend` classes and/or instances, each of which will be\",\n \"isn't cached. E.g.:: def dont_cache_none(value): return value is not None value = region.get_or_create(\\\"some\",\n \"is to prevent deadlocks. # though haven't been able to simulate one anyway.\",\n \"Pass to ``invalidate()`` the same arguments you'd pass to the function itself to\",\n \"file, such as those associated with classes - note that the decorator itself\",\n \"be established as part of each cache key. :param expiration_time: if not None,\",\n \"same mechanism as that of :meth:`.CacheRegion.get_multi` to retrieve all current values; the originally\",\n \"(namespace or '') def generate_keys(*args): return [namespace + ':' + str(a) for a\",\n \"import Number from functools import wraps import threading _backend_loader = PluginLoader(\\\"dogpile.cache\\\") register_backend =\",\n \"... region = CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator`\",\n \"self.key_mangler(key) value = self.backend.get(key) value = self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload def _unexpired_value_fn(self,\",\n \"finally: for mutex in mutexes.values(): mutex.release() def _value(self, value): \\\"\\\"\\\"Return a :class:`.CachedValue` given\",\n \"a creation function for this key against the cache. When the dogpile lock\",\n \"to be expired based on its creation time, the given creation function may\",\n \"of calling the decorated function will also be a list. When ``asdict==True`` if\",\n \"None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn)\",\n \"Optional. Similar to ``function_key_generator`` parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should\",\n \"way of, for example, a background thread, a long-running queue, or a task\",\n \"make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, } ) Remember\",\n \"value of ``None``. By default, the configured expiration time of the :class:`.CacheRegion`, or\",\n \"sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in\",\n \"the invalidator given the region as an argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self, region):\",\n \"Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated = None self._hard_invalidated = None def invalidate(self,\",\n \"key derived from the function itself and its arguments. The decorator internally makes\",\n \"function should return list of keys. For example:: def my_multi_key_generator(namespace, fn, **kw): namespace\",\n \"return [] if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys)\",\n \"This operation is idempotent (can be called multiple times, or on a non-existent\",\n \"is_hard_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was hard invalidated. :return: Boolean.\",\n \"passed a type rather than an instance then # initialize it. if type(proxy)\",\n \"backend is configured on this region.\\\") @property def is_configured(self): \\\"\\\"\\\"Return True if the\",\n \"can be created in a background thread like so:: import threading def async_creation_runner(cache,\",\n \"async_creator(mutex): return self.async_creation_runner( self, orig_key, creator, mutex) else: async_creator = None with Lock(\",\n \"Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a single function signature, one\",\n \"for the cached function result. Example use cases include \\\"cache the result until\",\n \"\\\"cache.local.\\\") memcached_region.configure_from_config(myconfig, \\\"cache.memcached.\\\") \\\"\\\"\\\" config_dict = coerce_string_conf(config_dict) return self.configure( config_dict[\\\"%sbackend\\\" % prefix], expiration_time=config_dict.get(\",\n \"0.5.3 Added ``get()`` method to decorated function. The default key generation will use\",\n \"if ``timestamp`` is older than the last region invalidation time and region is\",\n \".. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" def get_value(key): value = values.get(key,\",\n \"conjunction with Unicode keys. :param async_creation_runner: A callable that, when specified, will be\",\n \"invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated =\",\n \"that wish to have access to the :class:`.CacheRegion` itself should construct the invalidator\",\n \"on the submitted ``mapping`` dict. :param keys: Sequence of keys to be retrieved.\",\n \"such as bsddb or dbm under Python 2.x in conjunction with Unicode keys.\",\n \"str(a) for a in args] return generate_keys :param key_mangler: Function which will be\",\n \"class and wraps the attached backend. ''' # if we were passed a\",\n \"to :meth:`.invalidate`. :param key: Key to be retrieved. While it's typical for a\",\n \"creator: function which creates a new value. :param expiration_time: optional expiration time which\",\n \"as an integer number of seconds, or as a ``datetime.timedelta`` value. .. versionadded\",\n \"= None with Lock( self._mutex(key), gen_value, get_value, expiration_time, async_creator) as value: return value\",\n \"for k, v in mapping.items()) else: mapping = dict((k, self._value(v)) for k, v\",\n \"expiration time for the cached function result. Example use cases include \\\"cache the\",\n \"if the cache is invalid, however if the return value is None, it\",\n \"and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \\\"Non-None expiration time required \\\" \\\"for soft invalidation\\\") if\",\n \"NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\\\"ct\\\"])): raise NeedRegenerationException() ct = value.metadata[\\\"ct\\\"]\",\n \"of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...a ``refresh()`` method, which will call the creation\",\n \"However, subsequent requests for cached-but-expired values will still return promptly. They will be\",\n \"represent a particular value:: generate_something.invalidate(5, 6) Another attribute ``set()`` is added to provide\",\n \"callable that, when specified, will be passed to and called by dogpile.lock when\",\n \"key to be a string, it is ultimately passed directly down to the\",\n \"\\\"multiple key\\\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [\",\n \"values, and the final result of calling the decorated function will also be\",\n \"'backend' in self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return a value from the\",\n \"that configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.3.0 :param ignore_expiration: if ``True``,\",\n \"% self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix )\",\n \"If a previous value is available, that value is returned immediately without blocking.\",\n \"True if the backend has been configured via the :meth:`.CacheRegion.configure` method already. ..\",\n \"function is received by the decorator before it becomes an instance method. The\",\n \"unless a new value is needed:: result = generate_something(5, 6) The function is\",\n \"function_key_generator=None): \\\"\\\"\\\"A function decorator that will cache the return value of the function\",\n \"function accepts non-ascii unicode arguments on Python 2.x, the ``unicode()`` builtin can be\",\n \"async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass try: if mutexes: # sort the keys,\",\n \"cache the new values, and return them:: values = generate_something.refresh(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...and\",\n \"a chain to ultimately wrap the original backend, so that custom functionality augmentation\",\n \"the :meth:`.CacheRegion.get_or_create` method to access the cache and conditionally call the function. See\",\n \"replace_existing_backend: raise exception.RegionAlreadyConfigured( \\\"This region is already \\\" \\\"configured with backend: %s. \\\"\",\n \"else: mapping = dict((k, self._value(v)) for k, v in mapping.items()) self.backend.set_multi(mapping) def delete(self,\",\n \"expiration_time() if expiration_time_is_callable \\\\ else expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg,\",\n \"exception.RegionNotConfigured( \\\"No backend is configured on this region.\\\") @property def is_configured(self): \\\"\\\"\\\"Return True\",\n \"time supplied by the ``expiration_time`` argument, is tested against the creation time of\",\n \"timestamp): return (self._invalidated is not None and timestamp < self._invalidated) def was_hard_invalidated(self): return\",\n \"should_cache_fn: optional callable function which will receive the value returned by the \\\"creator\\\",\",\n \":class:`.CacheRegion` at configure time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region =\",\n \":meth:`.CacheRegion.get` method) will call upon the value creation function after this time period\",\n \"# dogpile.core understands a 0 here as # \\\"the value is not available\\\",\",\n \"the retrieved value's timestamp is older than the invalidation timestamp, the value is\",\n \"a convenience method for :meth:`.CacheRegion.set` which will store a given value directly without\",\n \"``MyOtherClass``. Python class declaration mechanics otherwise prevent the decorator from having awareness of\",\n \"= backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend = backend_cls(arguments or {}) if not\",\n \"``namespace`` parameter disambiguates between ``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python class declaration mechanics\",\n \"def creator(*keys_to_create): return fn(*[key_lookup[k] for k in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable\",\n \":meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and set values from the backend. If you\",\n \"not should_cache_fn: return True else: return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout,\",\n \"for invalidation of the value. Pass to ``invalidate()`` the same arguments you'd pass\",\n \"return its result as a list of values, and the final result of\",\n \"ready to use for function # decorators, but not yet for actual caching\",\n \"to the calling function. A correct implementation of ``.set_multi()`` will not modify values\",\n \"should_cache_fn: optional callable function which will receive each value returned by the \\\"creator\\\",\",\n \"a sequence of keys and returns a sequence of new values. :param expiration_time:\",\n \"time passed to the dogpile system. May be passed as an integer number\",\n \"of :class:`.ProxyBackend` classes and/or instances, each of which will be applied in a\",\n \"them:: values = generate_something.refresh(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...and a ``get()`` method, which will return\",\n \"{} sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys]\",\n \"that method for additional behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x, y): return somedatabase.query(x,\",\n \":meth:`.CacheRegion.configure` to override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated =\",\n \"was invalidated in soft mode. :return: Boolean. True if region was invalidated in\",\n \"0.3.0 :param ignore_expiration: if ``True``, the value is returned from the cache if\",\n \"it was hard invalidated. :return: Boolean. True if ``timestamp`` is older than the\",\n \"if region was invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def\",\n \"or {}) if not expiration_time or isinstance(expiration_time, Number): self.expiration_time = expiration_time elif isinstance(expiration_time,\",\n \"= threading.Lock() def acquire(self, wait=True): return self.lock.acquire(wait) def release(self): self.lock.release() def _create_mutex(self, key):\",\n \"returned. Passing the flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionchanged:: 0.3.0\",\n \"the ``function_key_generator`` argument present on :func:`.make_region` and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`. :param\",\n \"not NO_VALUE else value for value in ( _unexpired_value_fn(value) for value in backend_values\",\n \":meth:`.invalidate`. :param key: Key to be retrieved. While it's typical for a key\",\n \"is idempotent (can be called multiple times, or on a non-existent key, safely)\",\n \"exception is raised if a backend is already configured. .. versionadded:: 0.5.7 :param\",\n \"from the ``dogpile.cache`` entrypoint. :param expiration_time: Optional. The expiration time passed to the\",\n \"for threading.Lock\\\"\\\"\\\" def __init__(self): self.lock = threading.Lock() def acquire(self, wait=True): return self.lock.acquire(wait) def\",\n \"list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None):\",\n \"argument list, and the decorated function is then called with that subset of\",\n \"in zip(keys_to_get, new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for\",\n \"function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def\",\n \"applied. .. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True, the existing\",\n \"region is already \\\" \\\"configured with backend: %s. \\\" \\\"Specify replace_existing_backend=True to replace.\\\"\",\n \"callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str:\",\n \"that, when specified, will be passed to and called by dogpile.lock when there\",\n \"be created in a background thread like so:: import threading def async_creation_runner(cache, somekey,\",\n \"the configured expiration time of the :class:`.CacheRegion`, or alternatively the expiration time supplied\",\n \"y): return somedatabase.query(x, y) The decorated function can then be called normally, where\",\n \"key generation will use the name of the function, the module name for\",\n \"specified, will be passed to and called by dogpile.lock when there is a\",\n \"\\\"configured with backend: %s. \\\" \\\"Specify replace_existing_backend=True to replace.\\\" % self.backend) backend_cls =\",\n \"itself should construct the invalidator given the region as an argument:: class MyInvalidator(RegionInvalidationStrategy):\",\n \"pluck from \\\\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return \\\":\\\".join( [kw[k] for\",\n \"store a given value directly without calling the decorated function. The value to\",\n \"value directly without calling the decorated function. The value to be cached is\",\n \"regeneration; dogpile logic won't be used. If False, the creation time of existing\",\n \"a value.\\\"\\\"\\\" return CachedValue( value, { \\\"ct\\\": time.time(), \\\"v\\\": value_version }) def set(self,\",\n \"value. Any retrieved value whose creation time is prior to this timestamp is\",\n \"function key generation can be entirely replaced on a per-region basis using the\",\n \"value in ( _unexpired_value_fn(value) for value in backend_values ) ] def get_or_create( self,\",\n \"lambda value: value else: if expiration_time is None: expiration_time = self.expiration_time current_time =\",\n \"alternatively the expiration time supplied by the ``expiration_time`` argument, is tested against the\",\n \"call the creation function, cache the new values, and return them:: values =\",\n \"to later points in the future by way of, for example, a background\",\n \"optional string argument which will be established as part of each cache key.\",\n \"of :meth:`.CacheRegion.get_multi` to retrieve all current values; the originally passed keys corresponding to\",\n \"the key_mangler function, if present. :param expiration_time: Optional expiration time value which will\",\n \"itself is called, in caching or retrieving. Thus, this can be used to\",\n \"first argument, and the arguments which would normally be passed to the function\",\n \"\\\"\\\"\\\"Region invalidation. :class:`.CacheRegion` propagated call. The default invalidation system works by setting a\",\n \"in the cache under the given keys. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not\",\n \"self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \\\"\\\"\\\"Remove multiple values from the cache. This operation\",\n \"should_cache_fn=None): \\\"\\\"\\\"Return a sequence of cached values based on a sequence of keys.\",\n \"**kw): key = key_generator(*arg, **kw) value = fn(*arg, **kw) self.set(key, value) return value\",\n \"existing values will be pushed back before the expiration time so that a\",\n \"None and \\\\ current_time - value.metadata[\\\"ct\\\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\\\"ct\\\"]):\",\n \"prior to this timestamp is considered to be stale. It does not affect\",\n \"prefix, None), ) @memoized_property def backend(self): raise exception.RegionNotConfigured( \\\"No backend is configured on\",\n \"new :class:`.CacheRegion`.\\\"\\\"\\\" self.name = name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler =\",\n \"value in backend_values ) ] def get_or_create( self, key, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return\",\n \"as the first argument, and the arguments which would normally be passed to\",\n \"the backend or by the key_mangler function, if present. :param creator: function which\",\n \"at its default value of ``False``, the decorated function should return its result\",\n \"the normal expiration time. May be specified as a callable, taking no arguments,\",\n \"getattr(wrap, '__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator\",\n \"not a valid ProxyBackend\\\" % type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self, key): return\",\n \"function can then be called normally, where data will be pulled from the\",\n \"by dogpile.lock when there is a stale value present in the cache. It\",\n \"or False, indicating if the value should actually be cached or not. If\",\n \"be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw): return my_data() .. seealso::\",\n \"use the value -1. :param should_cache_fn: optional callable function which will receive each\",\n \"invokes ``.set_multi()`` for newly generated values using the same values it returns to\",\n \"dict( (k, v) for k, v in zip(cache_keys, result) if v is not\",\n \"returns False, the value is still returned, but isn't cached. .. versionadded:: 0.5.0\",\n \"invalidate(self, hard=True): \\\"\\\"\\\"Region invalidation. :class:`.CacheRegion` propagated call. The default invalidation system works by\",\n \".. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi`\",\n \"in any way, and is also local to this instance of :class:`.CacheRegion`. Once\",\n \"a current timestamp (using ``time.time()``) representing the \\\"minimum creation time\\\" for a value.\",\n \":param should_cache_fn: optional callable function which will receive the value returned by the\",\n \"or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands a 0 here\",\n \"keys before passing to the backend. Defaults to ``None``, in which case the\",\n \"mutex = self.backend.get_mutex(key) if mutex is not None: return mutex else: return self._LockWrapper()\",\n \"long-running queue, or a task manager system like Celery. For a specific example\",\n \"dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in orig_to_mangled.items(): with Lock(\",\n \"expiration time. May be specified as a callable, taking no arguments, that returns\",\n \"keys = key_generator(*arg, **kw) key_lookup = dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k]\",\n \"creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key) def set_(value,\",\n \"def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys = list(mapping) gen_keys =\",\n \"\\\"namespace\\\" parameter in order to generate a cache key. Given a function ``one``\",\n \"dict(zip(keys, values)) Keys which aren't present in the list are returned as the\",\n \"is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp < self._soft_invalidated) The custom implementation is injected\",\n \"function decorator that will cache multiple return values from the function using a\",\n \"= self.expiration_time current_time = time.time() def value_fn(value): if value is NO_VALUE: return value\",\n \"..util import PluginLoader, memoized_property, coerce_string_conf from .util import function_key_generator, function_multi_key_generator from .api import\",\n \":param replace_existing_backend: if True, the existing cache backend will be replaced. Without this\",\n \"name for the region. This isn't used internally but can be accessed via\",\n \"keys to bytestrings, which is needed when using a backend such as bsddb\",\n \"'expiration_time is not a number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler\",\n \"the value should actually be cached or not. If it returns False, the\",\n \"and a prefix. Example:: local_region = make_region() memcached_region = make_region() # regions are\",\n \"If you are using a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies values, take note\",\n \"time.time() - expiration_time - .0001 return value.payload, ct def gen_value(): created_value = creator()\",\n \"is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated\",\n \"from \\\\**kw:: def my_key_generator(namespace, fn): def generate_key(*arg, **kw): return \\\":\\\".join( [kw[k] for k\",\n \"value is still returned, but isn't cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments`\",\n \"return the generated values as a sequence corresponding to the order of the\",\n \"def delete_multi(self, keys): \\\"\\\"\\\"Remove multiple values from the cache. This operation is idempotent\",\n \"awareness of the ``MyClass`` and ``MyOtherClass`` names, as the function is received by\",\n \"cached-but-expired values will still return promptly. They will be refreshed by whatever asynchronous\",\n \".. seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` - optional gen that also\",\n \"keys into a SHA1 hash, so that the string length is fixed. To\",\n \"the ``creator()`` function may be asked to generate any subset of the given\",\n \"but note this will produce unicode cache keys which may require key mangling\",\n \"function is also given an attribute ``invalidate()``, which provides for invalidation of the\",\n \"expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key = key_generator(*arg, **kw)\",\n \"normal expiration time. May be passed as an integer or a callable. :param\",\n \"hash, so that the string length is fixed. To disable all key mangling,\",\n \"= region.get_multi(keys) dictionary = dict(zip(keys, values)) Keys which aren't present in the list\",\n \"return values based on the given arguments:: values = generate_something.get(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ..\",\n \"feature. \\\"\\\"\\\" def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \\\"\\\"\\\"Construct a\",\n \"existing cache backend will be replaced. Without this flag, an exception is raised\",\n \"_config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend = backend_cls(arguments or {})\",\n \"not. If it returns False, the value is still returned, but isn't cached.\",\n \"value.metadata[\\\"ct\\\"])): raise NeedRegenerationException() ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time\",\n \"function with the optional namespace and with the string form of each key.\",\n \"is already configured. .. versionadded:: 0.5.7 :param region_invalidator: Optional. Override default invalidation strategy\",\n \"works only with a single function signature, one which takes a simple list\",\n \"value) return value.payload, value.metadata[\\\"ct\\\"] if expiration_time is None: expiration_time = self.expiration_time if (expiration_time\",\n \"= arg keys = key_generator(*arg, **kw) key_lookup = dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create):\",\n \"self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator =\",\n \"function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function\",\n \"needed when using a backend such as bsddb or dbm under Python 2.x\",\n \"later, when config is available myconfig = { \\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\", \\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\", \\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\", \\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1, 10.0.0.1\\\",\",\n \"check. .. versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param key: Key to\",\n \"\\\"for soft invalidation\\\") if expiration_time == -1: expiration_time = None if self.async_creation_runner: def\",\n \"# initialize it. if type(proxy) == type: proxy = proxy() if not issubclass(type(proxy),\",\n \"given an attribute ``invalidate()``, which provides for invalidation of the value. Pass to\",\n \"within the same source file, such as those associated with classes - note\",\n \"d_values = creator(*keys) return [ d_values.get(key_lookup[k], NO_VALUE) for k in keys] def wrap_cache_fn(value):\",\n \"the same values it returns to the calling function. A correct implementation of\",\n \"async_creation_runner feature. \\\"\\\"\\\" def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \\\"\\\"\\\"Construct\",\n \"generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added ``refresh()`` method to decorated function. Lastly, the\",\n \"in the cache in any way, and is also local to this instance\",\n \"key. :param expiration_time: if not None, will override the normal expiration time. May\",\n \"same cache key of ``myapp.tools:one|foo|3 4`` - the name ``self`` is skipped. The\",\n \"one which takes a simple list of keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the\",\n \"keys to be generated is passed to ``creator()``, and ``creator()`` should return the\",\n \"for a in args] return generate_keys :param key_mangler: Function which will be used\",\n \"replace.\\\" % self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix\",\n \"reaching the cache. .. versionadded:: 0.5.0 :param function_multi_key_generator: a function that will produce\",\n \"terms of the current \\\"invalidation\\\" time as set by the :meth:`.invalidate` method. If\",\n \"calling the decorated function. The value to be cached is passed as the\",\n \"``unicode()`` builtin can be substituted, but note this will produce unicode cache keys\",\n \"a number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex)\",\n \"time as set by the :meth:`.invalidate` method. If a value is present, but\",\n \"the first request for a key with no associated value will always block;\",\n \"= _backend_loader.register from . import backends # noqa value_version = 1 \\\"\\\"\\\"An integer\",\n \"using a backend such as bsddb or dbm under Python 2.x in conjunction\",\n \"'url': '127.0.0.1:11211', 'distributed_lock': True, } ) Remember that the first request for a\",\n \"typically a dictionary. :param wrap: Optional. A list of :class:`.ProxyBackend` classes and/or instances,\",\n \"local_region.configure_from_config(myconfig, \\\"cache.local.\\\") memcached_region.configure_from_config(myconfig, \\\"cache.memcached.\\\") \\\"\\\"\\\" config_dict = coerce_string_conf(config_dict) return self.configure( config_dict[\\\"%sbackend\\\" % prefix],\",\n \"called. .. versionadded:: 0.3.0 \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key)\",\n \"will force an immediate regeneration of the value which all getters will wait\",\n \"when there is a stale value present in the cache. It will be\",\n \"the dogpile lock cannot be acquired, the method will block if no previous\",\n \"function using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \\\"\\\"\\\" orig_key = key\",\n \"able to simulate one anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get) values_w_created =\",\n \"self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \\\"\\\"\\\"A\",\n \"decorator suitable (with caveats) for use with instance or class methods. Given the\",\n \"release(self): self.lock.release() def _create_mutex(self, key): mutex = self.backend.get_mutex(key) if mutex is not None:\",\n \"left at its default value of ``False``, the decorated function should return its\",\n \"tuple, used to specify arguments to pluck from \\\\**kw:: def my_key_generator(namespace, fn): def\",\n \"here is passed directly to the constructor of the :class:`.CacheBackend` in use, though\",\n \"passed directly to the constructor of the :class:`.CacheBackend` in use, though is typically\",\n \"dictionary = dict(zip(keys, values)) Keys which aren't present in the list are returned\",\n \"this :class:`.CacheRegion` if not None. To set no expiration, use the value -1.\",\n \"== -1: expiration_time = None mutexes = {} sorted_unique_keys = sorted(set(keys)) if self.key_mangler:\",\n \"(can be called multiple times, or on a non-existent key, safely) \\\"\\\"\\\" if\",\n \"arguments. The decorator internally makes use of the :meth:`.CacheRegion.get_or_create` method to access the\",\n \"which would normally be passed to the function should follow:: generate_something.set(3, 5, 6)\",\n \"should_cache_fn) def invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw):\",\n \"dict(zip(keys, [values[a] for a in arg])) ) return values else: self.set_multi( dict(zip(keys, values))\",\n \"to be retrieved. :param creator: function which accepts a sequence of keys and\",\n \"string, it is ultimately passed directly down to the cache backend, before being\",\n \"the decorated function should return its result as a list of values, and\",\n \"region. This isn't used internally but can be accessed via the ``.name`` parameter,\",\n \"def decorate(*arg, **kw): cache_keys = arg keys = key_generator(*arg, **kw) key_lookup = dict(zip(keys,\",\n \"is received by the decorator before it becomes an instance method. The function\",\n \"6) The function is also given an attribute ``invalidate()``, which provides for invalidation\",\n \"as part of each cache key. :param expiration_time: if not None, will override\",\n \"the :meth:`.invalidate` method. If a value is present, but its creation time is\",\n \"value's creation time against the expiration time, rather than returning the value unconditionally.\",\n \"being returned. The method will attempt to acquire the dogpile lock to generate\",\n \"in ( _unexpired_value_fn(value) for value in backend_values ) ] def get_or_create( self, key,\",\n \"= self.function_key_generator def decorator(fn): if to_str is compat.string_type: # backwards compatible key_generator =\",\n \"If the value does not exist or is considered to be expired based\",\n \"and timestamp < self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp):\",\n \"outside this function, so in fact can be of any form. For example,\",\n \"structure of this function should be two levels: given the data creation function,\",\n \"timestamp): return (self._soft_invalidated and timestamp < self._soft_invalidated) The custom implementation is injected into\",\n \"in args] return generate_keys :param key_mangler: Function which will be used on all\",\n \"expiration_time = None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self, orig_key, creator, mutex)\",\n \"generate_something.get(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") .. versionadded:: 0.5.3 Added ``get()`` method to decorated function. Parameters\",\n \"should_cache_fn=dont_cache_none) Above, the function returns the value of create_value() if the cache is\",\n \"arguments you'd pass to the function itself to represent a particular value:: generate_something.invalidate(5,\",\n \"versionchanged:: 0.3.0 The value is unconditionally regenerated if the creation time is older\",\n \"value whose creation time is prior to this timestamp is considered to be\",\n \"current \\\"invalidation\\\" time as set by the :meth:`.invalidate` method. If a value is\",\n \"Lastly, the ``get()`` method returns either the value cached for the given key,\",\n \":param key: Key to be retrieved. While it's typical for a key to\",\n \"return value.payload, ct def gen_value(): created_value = creator() value = self._value(created_value) if not\",\n \"keys and returns a sequence of new values. :param expiration_time: optional expiration time\",\n \"functionality augmentation can be applied. .. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend:\",\n \":func:`.make_region` is a passthrough to :class:`.CacheRegion`. See that class for constructor arguments. \\\"\\\"\\\"\",\n \"multiple values from the cache, based on the given keys. Returns values as\",\n \"two functions of the same name within the same module, as can occur\",\n \":meth:`.get_or_create` to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \\\"\\\"\\\"\",\n \"time check. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not keys: return [] if self.key_mangler:\",\n \"accepts a mapping of keys and values to set in the cache:: generate_something.set({\\\"k1\\\":\",\n \"if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend = backend_cls(arguments or\",\n \"= self.expiration_time if (expiration_time is None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \\\"Non-None expiration time\",\n \"custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \\\"\\\"\\\" if \\\"backend\\\" in self.__dict__ and\",\n \"actual caching # later, when config is available myconfig = { \\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\", \\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\",\",\n \"\\\"k3\\\") .. versionadded:: 0.5.3 Added ``get()`` method to decorated function. Parameters passed to\",\n \"if not None, will override the normal expiration time. May be passed as\",\n \"+ fname + \\\"_\\\".join(str(s) for s in arg) return generate_key region = make_region(\",\n \"block if no previous value is available, until the lock is released and\",\n \"to the backend. Defaults to ``None``, in which case the key mangling function\",\n \"0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is None:\",\n \"and the decorated function is then called with that subset of arguments. The\",\n \"self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload\",\n \"if v is not NO_VALUE) else: result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn)\",\n \"also provided with a ``set()`` method, which here accepts a mapping of keys\",\n \"new one is available. Usage of \\\"soft\\\" invalidation requires that the region or\",\n \"internally but can be accessed via the ``.name`` parameter, helpful for configuring a\",\n \"than returning the value unconditionally. The method also interprets the cached value in\",\n \"can be used to defer the computation of expensive creator functions to later\",\n \"is released and a new value available. If a previous value is available,\",\n \"implementation instance to :meth:`.CacheRegion.configure` to override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def\",\n \"invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError() def is_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to\",\n \"False. return value.payload, 0 else: ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time()\",\n \"cache region unless a new value is needed:: result = generate_something(5, 6) The\",\n \"NotImplementedError() def is_soft_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was soft invalidated.\",\n \"the same mechanism as that of :meth:`.CacheRegion.get_multi` to retrieve all current values; the\",\n \"its result as a list of values, and the final result of calling\",\n \"by the cache backend will be used. A typical mangler is the SHA1\",\n \"and \\\"soft\\\" invalidation options. With \\\"hard\\\" invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate regeneration\",\n \"value = self.backend.get(key) if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated(\",\n \"key mangling function recommended by the cache backend will be used. A typical\",\n \"sequence of keys. The behavior for generation of values based on keys corresponds\",\n \"method for additional behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with\",\n \"with the optional namespace and with the string form of each key. It\",\n \"method to decorated function. Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as\",\n \"= creator() cache.set(somekey, value) finally: mutex.release() thread = threading.Thread(target=runner) thread.start() region = make_region(\",\n \"= self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload if value is not NO_VALUE else\",\n \"value:: newvalue = generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added ``refresh()`` method to decorated\",\n \"value elif expiration_time is not None and \\\\ current_time - value.metadata[\\\"ct\\\"] > expiration_time:\",\n \".. versionadded:: 0.5.3 Added ``get()`` method to decorated function. The default key generation\",\n \"return ((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated and timestamp < self._hard_invalidated)) def\",\n \"value is available, until the lock is released and a new value available.\",\n \"value.metadata['v'])): # dogpile.core understands a 0 here as # \\\"the value is not\",\n \"region invalidation time and region is invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError()\",\n \"here as # \\\"the value is not available\\\", e.g. # _has_value() will return\",\n \"values from the cache, based on the given keys. Returns values as a\",\n \"key based on the given arguments. Such as:: def my_key_generator(namespace, fn, **kw): fname\",\n \"modify values in-place on the submitted ``mapping`` dict. :param keys: Sequence of keys\",\n \"decorated function itself is called, in caching or retrieving. Thus, this can be\",\n \"value is NO_VALUE: return False elif not should_cache_fn: return True else: return should_cache_fn(value)\",\n \"method already. .. versionadded:: 0.5.1 \\\"\\\"\\\" return 'backend' in self.__dict__ def get(self, key,\",\n \"that the first request for a key with no associated value will always\",\n \"**kw): key = key_generator(*arg, **kw) @wraps(fn) def creator(): return fn(*arg, **kw) timeout =\",\n \"versionadded:: 0.5.0 :param function_multi_key_generator: a function that will produce a list of keys.\",\n \"def gen_value(): raise NotImplementedError() def async_creator(key, mutex): mutexes[key] = mutex if expiration_time is\",\n \"default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated = None self._hard_invalidated =\",\n \"return self._LockWrapper() def invalidate(self, hard=True): \\\"\\\"\\\"Invalidate this :class:`.CacheRegion`. The default invalidation system works\",\n \"from ..util import compat import time import datetime from numbers import Number from\",\n \"region_invalidator: self.region_invalidator = region_invalidator return self def wrap(self, proxy): ''' Takes a ProxyBackend\",\n \"using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that\",\n \"such key exists:: value = generate_something.get(5, 6) .. versionadded:: 0.5.3 Added ``get()`` method\",\n \"to simulate one anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get) values_w_created = dict(\",\n \"**kw) key_lookup = dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k] for k in\",\n \"prevented from being returned. The method will attempt to acquire the dogpile lock\",\n \"if expiration_time is None: expiration_time = self.expiration_time if (expiration_time is None and self.region_invalidator.was_soft_invalidated()):\",\n \"in mapping.items()) else: mapping = dict((k, self._value(v)) for k, v in mapping.items()) self.backend.set_multi(mapping)\",\n \"is tested against the creation time of the retrieved value versus the current\",\n \"Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`.\",\n \"the :meth:`.CacheRegion.invalidate` method. :param key: Key to be retrieved. While it's typical for\",\n \"versionadded:: 0.3.0 :param ignore_expiration: if ``True``, the value is returned from the cache\",\n \"for actual caching # later, when config is available myconfig = { \\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\",\",\n \"not None and \\\\ current_time - value.metadata[\\\"ct\\\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated(\",\n \") return values else: self.set_multi( dict(zip(keys, values)) ) return values decorate.set = set_\",\n \"this flag, an exception is raised if a backend is already configured. ..\",\n \"of ``self`` or ``cls``, making the decorator suitable (with caveats) for use with\",\n \"disambiguate two functions of the same name within the same module, as can\",\n \"class methods as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \\\"\\\" class\",\n \"compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time is not a number or timedelta.') if not\",\n \"from . import backends # noqa value_version = 1 \\\"\\\"\\\"An integer placed in\",\n \"function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator\",\n \"the decorated function is then called with that subset of arguments. The returned\",\n \"into the cache with the new value, as well as returning that value::\",\n \"\\\"\\\"\\\"Configure from a configuration dictionary and a prefix. Example:: local_region = make_region() memcached_region\",\n \"function_multi_key_generator=None): \\\"\\\"\\\"A function decorator that will cache multiple return values from the function\",\n \"== type: proxy = proxy() if not issubclass(type(proxy), ProxyBackend): raise TypeError(\\\"Type %s is\",\n \":meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key) for key in keys\",\n \"than the invalidation timestamp, the value is unconditionally prevented from being returned. The\",\n \"optional, and is used normally to disambiguate two functions of the same name\",\n \"will produce a \\\"cache key\\\". This function will supersede the one configured on\",\n \"NO_VALUE: return value elif expiration_time is not None and \\\\ current_time - value.metadata[\\\"ct\\\"]\",\n \"is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports both\",\n \"should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result = dict( (k, v)\",\n \"optional gen that also uses keyword arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator``\",\n \"``None``, in which case the key mangling function recommended by the cache backend\",\n \"which coerces keys into a SHA1 hash, so that the string length is\",\n \"if (expiration_time is None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \\\"Non-None expiration time required \\\"\",\n \"invalidation time, the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses the\",\n \":meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \\\"\\\"\\\" orig_key = key if self.key_mangler: key =\",\n \"cache. .. versionadded:: 0.5.0 :param function_multi_key_generator: a function that will produce a list\",\n \"= creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k], self._value(v)) for k, v in zip(keys_to_get, new_values)\",\n \"cached. .. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function\",\n \"return generate_keys :param key_mangler: Function which will be used on all incoming keys\",\n \"..util import NameRegistry from . import exception from ..util import PluginLoader, memoized_property, coerce_string_conf\",\n \"to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside this function, so in fact can be\",\n \"bytestrings, which is needed when using a backend such as bsddb or dbm\",\n \"unconditionally regenerated if the creation time is older than the last call to\",\n \"return mutex else: return self._LockWrapper() def invalidate(self, hard=True): \\\"\\\"\\\"Invalidate this :class:`.CacheRegion`. The default\",\n \"and :meth:`.Region.set_multi` to get and set values from the backend. If you are\",\n \"implementation of ``.set_multi()`` will not modify values in-place on the submitted ``mapping`` dict.\",\n \"if the backend has been configured via the :meth:`.CacheRegion.configure` method already. .. versionadded::\",\n \"calling ``generate_something(5, 6)``, if the function were to produce the value ``3`` as\",\n \"NeedRegenerationException from ..util import NameRegistry from . import exception from ..util import PluginLoader,\",\n \"key\\\". This function will supersede the one configured on the :class:`.CacheRegion` itself. ..\",\n \".. versionadded:: 0.4.2 added the async_creation_runner feature. \\\"\\\"\\\" def __init__( self, name=None, function_key_generator=function_key_generator,\",\n \"expiration_time=config_dict.get( \\\"%sexpiration_time\\\" % prefix, None), _config_argument_dict=config_dict, _config_prefix=\\\"%sarguments.\\\" % prefix, wrap=config_dict.get( \\\"%swrap\\\" % prefix,\",\n \"ignore_expiration=False): \\\"\\\"\\\"Return a value from the cache, based on the given key. If\",\n \"is given a non-None expiration time. .. versionadded:: 0.3.0 :param hard: if True,\",\n \"interprets the cached value in terms of the current \\\"invalidation\\\" time as set\",\n \"subsequent requests for cached-but-expired values will still return promptly. They will be refreshed\",\n \"somedatabase.query(key) for key in keys ] The decorated function can be called normally.\",\n \"exist or is considered to be expired based on its creation time, the\",\n \"the ``.name`` parameter, helpful for configuring a region from a config file. :param\",\n \"typical mangler is the built-in Python function ``str``, which can be used to\",\n \"for additional behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x, y): return somedatabase.query(x, y) The\",\n \"raise exception.RegionAlreadyConfigured( \\\"This region is already \\\" \\\"configured with backend: %s. \\\" \\\"Specify\",\n \":meth:`.invalidate` method has been called, and the retrieved value's timestamp is older than\",\n \"will be passed to and called by dogpile.lock when there is a stale\",\n \"a key derived from the function itself and its arguments. The decorator internally\",\n \"chain to ultimately wrap the original backend, so that custom functionality augmentation can\",\n \"a new value, or will wait until the lock is released to return\",\n \"the key_mangler function, so can be of any type recognized by the backend\",\n \"hard mode. :return: Boolean. True if region was invalidated in hard mode. \\\"\\\"\\\"\",\n \"function. The value to be cached is passed as the first argument, and\",\n \"times, or on a non-existent key, safely) .. versionadded:: 0.5.0 \\\"\\\"\\\" if self.key_mangler:\",\n \"in self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return a value from the cache,\",\n \"invalid, however if the return value is None, it won't be cached. ..\",\n \"key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in zip(gen_keys, keys)) ) def get(*arg):\",\n \"yet for actual caching # later, when config is available myconfig = {\",\n \"which aren't generated or need regeneration will be assembled into a new argument\",\n \"``invalidate()`` method, which has the effect of deleting the given sequence of keys\",\n \"of the :class:`.CacheBackend` to use, and is resolved by loading the class from\",\n \"keys. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not mapping: return if self.key_mangler: mapping =\",\n \"functions of the same name within the same module, as can occur when\",\n \"the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a single function signature, one which\",\n \"with backend: %s. \\\" \\\"Specify replace_existing_backend=True to replace.\\\" % self.backend) backend_cls = _backend_loader.load(backend)\",\n \"produce a cache key as follows:: myapp.tools:one|foo|3 4 The key generator will ignore\",\n \"a value is present, but its creation time is older than the current\",\n \"for k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values\",\n \"return value_fn def get_multi(self, keys, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return multiple values from the cache,\",\n \"result = generate_something(\\\"key1\\\", \\\"key2\\\", \\\"key3\\\") The decorator internally makes use of the :meth:`.CacheRegion.get_or_create_multi`\",\n \"make_region(*arg, **kw): \\\"\\\"\\\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`.\",\n \"= time.time() def is_invalidated(self, timestamp): return (self._invalidated is not None and timestamp <\",\n \"you'd pass to the function itself to represent a particular value:: generate_something.invalidate(5, 6)\",\n \"those associated with classes - note that the decorator itself can't see the\",\n \"def is_hard_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was hard invalidated. :return:\",\n \"key in zip(gen_keys, keys)) ) def get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def\",\n \"an optional \\\"namespace\\\" parameter in order to generate a cache key. Given a\",\n \"then consult the cache using the same mechanism as that of :meth:`.CacheRegion.get_multi` to\",\n \"so in fact can be of any form. For example, it can be\",\n \"Python 2.x, the ``unicode()`` builtin can be substituted, but note this will produce\",\n \"creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a sequence of cached values based on a sequence\",\n \"def set_(mapping): keys = list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key,\",\n \"method will block if no previous value is available, until the lock is\",\n \"normal expiration time. May be specified as a callable, taking no arguments, that\",\n \"\\\\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\\\"ct\\\"] if expiration_time is None: expiration_time =\",\n \"< self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return (self._hard_invalidated and timestamp\",\n \"Example:: local_region = make_region() memcached_region = make_region() # regions are ready to use\",\n \"regenerated if the creation time is older than the last call to :meth:`.invalidate`.\",\n \"set no expiration, use the value -1. :param should_cache_fn: optional callable function which\",\n \"+ \\\"_\\\" + fname + \\\"_\\\".join(str(s) for s in arg) return generate_key region\",\n \".. versionadded 0.5.0 ``expiration_time`` may be optionally passed as a ``datetime.timedelta`` value. The\",\n \"else: return value return value_fn def get_multi(self, keys, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return multiple values\",\n \"keys, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a sequence of cached values based on a\",\n \"provides for invalidation of the value. Pass to ``invalidate()`` the same arguments you'd\",\n \"``True``, the value is returned from the cache if present, regardless of configured\",\n \"decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \\\"\\\"\\\"A function decorator\",\n \"to determine if it was soft invalidated. :return: Boolean. True if ``timestamp`` is\",\n \"the cache. .. versionadded:: 0.5.0 :param function_key_generator: a function that will produce a\",\n \"Returns values as a list matching the keys given. E.g.:: values = region.get_multi([\\\"one\\\",\",\n \"passed keys corresponding to those values which aren't generated or need regeneration will\",\n \"not None: return mutex else: return self._LockWrapper() def invalidate(self, hard=True): \\\"\\\"\\\"Invalidate this :class:`.CacheRegion`.\",\n \"aren't present in the list are returned as the ``NO_VALUE`` token. ``NO_VALUE`` evaluates\",\n \"values will be pushed back before the expiration time so that a return+regen\",\n \"_backend_loader = PluginLoader(\\\"dogpile.cache\\\") register_backend = _backend_loader.register from . import backends # noqa value_version\",\n \"NotImplementedError() def async_creator(key, mutex): mutexes[key] = mutex if expiration_time is None: expiration_time =\",\n \"for x in arg] ) return generate_key Where the decorator might be used\",\n \"(value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\\\"ct\\\"])): raise NeedRegenerationException() ct\",\n \"= self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result def invalidate(*arg): keys = key_generator(*arg)\",\n \"\\\"\\\"\\\"Region invalidation strategy interface Implement this interface and pass implementation instance to :meth:`.CacheRegion.configure`\",\n \"timestamp (using ``time.time()``) to consider all older timestamps effectively invalidated. \\\"\\\"\\\" raise NotImplementedError()\",\n \"``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\\\"foo\\\") def one(a, b): return a + b\",\n \"of keys using the same mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\")\",\n \"key = key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw): key = key_generator(*arg, **kw)\",\n \"takes a simple list of keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`, the decorated function\",\n \"_config_prefix ) else: self.backend = backend_cls(arguments or {}) if not expiration_time or isinstance(expiration_time,\",\n \"generates the key based on the given arguments. Such as:: def my_key_generator(namespace, fn,\",\n \"new value in the cache under the given key.\\\"\\\"\\\" if self.key_mangler: key =\",\n \"helpful for configuring a region from a config file. :param function_key_generator: Optional. A\",\n \"A callable that, when specified, will be passed to and called by dogpile.lock\",\n \"Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\\\"foo\\\") def one(self, a, b): return a +\",\n \"the decorated function is also provided with a ``set()`` method, which here accepts\",\n \"the exception that the ``creator()`` function may be asked to generate any subset\",\n \"It will be passed the mutex and is responsible releasing that mutex when\",\n \"def invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw): key\",\n \"the same source file, such as those associated with classes - note that\",\n \"``get()`` method, which will return values based on the given arguments:: values =\",\n \"backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend = backend_cls.from_config_dict( _config_argument_dict, _config_prefix ) else: self.backend\",\n \"region_invalidator=None ): \\\"\\\"\\\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned. :param backend: Required.\",\n \":param function_key_generator: Optional. A function that will produce a \\\"cache key\\\" given a\",\n \"keys given. E.g.:: values = region.get_multi([\\\"one\\\", \\\"two\\\", \\\"three\\\"]) To convert values to a\",\n \"self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in zip(gen_keys, keys)) ) def get(*arg): keys\",\n \"is injected into a :class:`.CacheRegion` at configure time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region\",\n \"to be a string, it is ultimately passed directly down to the cache\",\n \"time. .. versionadded:: 0.3.0 :param hard: if True, cache values will all require\",\n \"mangler is the SHA1 mangler found at :func:`.sha1_mangle_key` which coerces keys into a\",\n \"Usage of \\\"soft\\\" invalidation requires that the region or the method is given\",\n \"self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload if value is not\",\n \"be two levels: given the data creation function, return a new function that\",\n \":class:`.CacheRegion`.\\\"\\\"\\\" self.name = name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler\",\n \"a non-None expiration time. .. versionadded:: 0.3.0 :param hard: if True, cache values\",\n \"mutex.release() def _value(self, value): \\\"\\\"\\\"Return a :class:`.CachedValue` given a value.\\\"\\\"\\\" return CachedValue( value,\",\n \"cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" def get_value(key): value =\",\n \"force an immediate regeneration of the value which all getters will wait for.\",\n \"built-in Python function ``str``, which can be used to convert non-string or Unicode\",\n \"= name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler\",\n \"the value is returned from the cache if present, regardless of configured expiration\",\n \"was invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError() def was_hard_invalidated(self): \\\"\\\"\\\"Indicate the region\",\n \"the value is unconditionally prevented from being returned. The method will attempt to\",\n \"an integer or a callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This function is\",\n \"SHA1 mangler found at :func:`.sha1_mangle_key` which coerces keys into a SHA1 hash, so\",\n \"be replaced. Without this flag, an exception is raised if a backend is\",\n \"a function ``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\\\"foo\\\") def one(a, b): return a\",\n \"this will produce unicode cache keys which may require key mangling before reaching\",\n \"set values from the backend. If you are using a :class:`.CacheBackend` or :class:`.ProxyBackend`\",\n \"multiple return values from the function using a sequence of keys derived from\",\n \"the final result of calling the decorated function will also be a list.\",\n \"callable implements. By default the async_creation_runner is disabled and is set to ``None``.\",\n \"on the given arguments:: values = generate_something.get(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") .. versionadded:: 0.5.3 Added\",\n \"\\\"\\\"\\\" if \\\"backend\\\" in self.__dict__ and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \\\"This region is\",\n \"versions of dogpile.cache can detect cached values from a previous, backwards-incompatible version. \\\"\\\"\\\"\",\n \":meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports both \\\"hard\\\" and \\\"soft\\\" invalidation\",\n \"passed directly down to the cache backend, before being optionally processed by the\",\n \"an exception is raised if a backend is already configured. .. versionadded:: 0.5.7\",\n \"expensive creator functions to later points in the future by way of, for\",\n \"passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable, will be called on\",\n \"not the function is used depends on if the *dogpile lock* can be\",\n \"@region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \\\"\\\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y):\",\n \"returned as the ``NO_VALUE`` token. ``NO_VALUE`` evaluates to False, but is separate from\",\n \"def was_soft_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in soft mode. :return: Boolean. True\",\n \"will be called on each function argument in order to convert to a\",\n \"be called whenever the decorated function itself is called, in caching or retrieving.\",\n \"for cached-but-expired values will still return promptly. They will be refreshed by whatever\",\n \"a single function signature, one which takes a simple list of keys as\",\n \"the cache:: generate_something.set({\\\"k1\\\": \\\"value1\\\", \\\"k2\\\": \\\"value2\\\", \\\"k3\\\": \\\"value3\\\"}) ...an ``invalidate()`` method, which has\",\n \":param expiration_time: Optional. The expiration time passed to the dogpile system. May be\",\n \"but not yet for actual caching # later, when config is available myconfig\",\n \"0.4.2 added the async_creation_runner feature. \\\"\\\"\\\" def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None,\",\n \"current_time - value.metadata[\\\"ct\\\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\\\"ct\\\"]): return NO_VALUE else:\",\n \"multiple values from the cache. This operation is idempotent (can be called multiple\",\n \"(can be called multiple times, or on a non-existent key, safely) .. versionadded::\",\n \"new value, as well as returning that value:: newvalue = generate_something.refresh(5, 6) ..\",\n \"is already \\\" \\\"configured with backend: %s. \\\" \\\"Specify replace_existing_backend=True to replace.\\\" %\",\n \"if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for k, v in values_w_created.items()\",\n \"with Unicode keys. :param async_creation_runner: A callable that, when specified, will be passed\",\n \"as the value to be cached. .. versionadded:: 0.4.1 Added ``set()`` method to\",\n \"of the ``MyClass`` and ``MyOtherClass`` names, as the function is received by the\",\n \"(gen_key, mapping[key]) for gen_key, key in zip(gen_keys, keys)) ) def get(*arg): keys =\",\n \"it. if type(proxy) == type: proxy = proxy() if not issubclass(type(proxy), ProxyBackend): raise\",\n \"''' Takes a ProxyBackend instance or class and wraps the attached backend. '''\",\n \"or not :meth:`.invalidate` was called. .. versionadded:: 0.3.0 \\\"\\\"\\\" if self.key_mangler: key =\",\n \"argument in order to convert to a string. Defaults to ``str()``. If the\",\n \"of cached values based on a sequence of keys. The behavior for generation\",\n \"a key with no associated value will always block; async_creator will not be\",\n \"def set(self, key, value): \\\"\\\"\\\"Place a new value in the cache under the\",\n \"responsible releasing that mutex when finished. This can be used to defer the\",\n \"value will always block; async_creator will not be invoked. However, subsequent requests for\",\n \"for newly generated values using the same values it returns to the calling\",\n \":param should_cache_fn: optional callable function which will receive each value returned by the\",\n \"time\\\" for a value. Any retrieved value whose creation time is prior to\",\n \"value ``3`` as the value to be cached. .. versionadded:: 0.4.1 Added ``set()``\",\n \"equivalent to calling ``generate_something(5, 6)``, if the function were to produce the value\",\n \"the function is received by the decorator before it becomes an instance method.\",\n \"The decorator internally makes use of the :meth:`.CacheRegion.get_or_create_multi` method to access the cache\",\n \"pass try: if mutexes: # sort the keys, the idea is to prevent\",\n \"values = generate_something.get(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") .. versionadded:: 0.5.3 Added ``get()`` method to decorated\",\n \"otherwise prevent the decorator from having awareness of the ``MyClass`` and ``MyOtherClass`` names,\",\n \"be placed in the cache. :param asdict: if ``True``, the decorated function should\",\n \".. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \\\"\\\"\\\" def invalidate(self, hard=True): \\\"\\\"\\\"Region invalidation. :class:`.CacheRegion` propagated call. The\",\n \"any type recognized by the backend or by the key_mangler function, if present.\",\n \"the value creation function after this time period has passed since the last\",\n \"same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and set values from the\",\n \"[] if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn\",\n \"corresponding to those values which aren't generated or need regeneration will be assembled\",\n \"= generate_something.refresh(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...and a ``get()`` method, which will return values based\",\n \"by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports both \\\"hard\\\" and\",\n \"evaluates to False, but is separate from ``None`` to distinguish between a cached\",\n \"a callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param\",\n \"as returned by the creator, and only if it returns True will that\",\n \"requests for cached-but-expired values will still return promptly. They will be refreshed by\",\n \"attempt to acquire the dogpile lock to generate a new value, or will\",\n \"wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return self def wrap(self,\",\n \"return value elif expiration_time is not None and \\\\ current_time - value.metadata[\\\"ct\\\"] >\",\n \"behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a single function\",\n \"a list of values, and the final result of calling the decorated function\",\n \"is still returned, but isn't cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create`\",\n \"return False. return value.payload, 0 else: ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct =\",\n \"if self.key_mangler: mangled_keys = [self.key_mangler(k) for k in sorted_unique_keys] else: mangled_keys = sorted_unique_keys\",\n \"each value returned by the \\\"creator\\\", and will then return True or False,\",\n \"before the expiration time so that a return+regen will be invoked. .. versionadded::\",\n \"seconds, or as a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time`` may be optionally\",\n \"with a ``set()`` method, which here accepts a mapping of keys and values\",\n \"invalidated in hard mode. \\\"\\\"\\\" raise NotImplementedError() def is_soft_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to\",\n \"the cache if present, regardless of configured expiration times or whether or not\",\n \"is unconditionally prevented from being returned. The method will attempt to acquire the\",\n \"is still returned, but isn't cached. E.g.:: def dont_cache_none(value): return value is not\",\n \"to be used as the ``expiration_time``. This callable will be called whenever the\",\n \"values using the same values it returns to the calling function. A correct\",\n \"region_invalidator: Optional. Override default invalidation strategy with custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded::\",\n \"this key against the cache. When the dogpile lock cannot be acquired, the\",\n \"use cases include \\\"cache the result until the end of the day, week\",\n \"signature, one which takes a simple list of keys as arguments. Like :meth:`.CacheRegion.cache_on_arguments`,\",\n \"the same mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...a ``refresh()`` method,\",\n \"arguments on Python 2.x, the ``unicode()`` builtin can be substituted, but note this\",\n \"but can be accessed via the ``.name`` parameter, helpful for configuring a region\",\n \"import PluginLoader, memoized_property, coerce_string_conf from .util import function_key_generator, function_multi_key_generator from .api import NO_VALUE,\",\n \"- value.metadata[\\\"ct\\\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\\\"ct\\\"]): return NO_VALUE else: return\",\n \"namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \\\"\\\"\\\"A function decorator that will cache multiple\",\n \"version \\\"\\\"\\\" orig_key = key if self.key_mangler: key = self.key_mangler(key) def get_value(): value\",\n \"``invalidate()`` the same arguments you'd pass to the function itself to represent a\",\n \"fname + \\\"_\\\".join(str(s) for s in arg) return generate_key region = make_region( function_key_generator\",\n \"key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw): key = key_generator(*arg, **kw) self.set(key, value)\",\n \"self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and\",\n \"a ProxyBackend instance or class and wraps the attached backend. ''' # if\",\n \"is not None: return mutex else: return self._LockWrapper() def invalidate(self, hard=True): \\\"\\\"\\\"Invalidate this\",\n \"Passing the flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionchanged:: 0.3.0 :meth:`.CacheRegion.get`\",\n \"will override the normal expiration time. May be specified as a callable, taking\",\n \"mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of the function with\",\n \"soft mode. \\\"\\\"\\\" raise NotImplementedError() def was_hard_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in\",\n \"backend. :param name: Optional, a string name for the region. This isn't used\",\n \"means the provided async_creation_runner callable implements. By default the async_creation_runner is disabled and\",\n \"detect cached values from a previous, backwards-incompatible version. \\\"\\\"\\\" class RegionInvalidationStrategy(object): \\\"\\\"\\\"Region invalidation\",\n \"= self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for wrapper in reversed(wrap):\",\n \"ignore_expiration: if ``True``, the value is returned from the cache if present, regardless\",\n \"6) The above example is equivalent to calling ``generate_something(5, 6)``, if the function\",\n \"optional string argument which will be established as part of the cache key.\",\n \"keys will not be cached. :param to_str: callable, will be called on each\",\n \"cache backend will be replaced. Without this flag, an exception is raised if\",\n \"called on each function argument in order to convert to a string. Defaults\",\n \"list of keys. For example:: def my_multi_key_generator(namespace, fn, **kw): namespace = fn.__name__ +\",\n \"in keys] finally: for mutex in mutexes.values(): mutex.release() def _value(self, value): \\\"\\\"\\\"Return a\",\n \"v in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \\\"\\\"\\\"Remove a value from the cache.\",\n \"using a key derived from the function itself and its arguments. The decorator\",\n \"backwards compatible key_generator = function_key_generator(namespace, fn) else: key_generator = function_key_generator( namespace, fn, to_str=to_str)\",\n \"region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, }\",\n \"system works by setting a current timestamp (using ``time.time()``) representing the \\\"minimum creation\",\n \"the constructor of the :class:`.CacheBackend` in use, though is typically a dictionary. :param\",\n \"is needed when using a backend such as bsddb or dbm under Python\",\n \"simulate one anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k],\",\n \"on the given arguments. Such as:: def my_key_generator(namespace, fn, **kw): fname = fn.__name__\",\n \"is passed to ``creator()``, and ``creator()`` should return the generated values as a\",\n \"making the decorator suitable (with caveats) for use with instance or class methods.\",\n \"callable function which will receive each value returned by the \\\"creator\\\", and will\",\n \"instances, each of which will be applied in a chain to ultimately wrap\",\n \"``NO_VALUE``. ``NO_VALUE`` evaluates to False, but is separate from ``None`` to distinguish between\",\n \"None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self, orig_key, creator, mutex) else: async_creator\",\n \"for function # decorators, but not yet for actual caching # later, when\",\n \"method. The structure of this function should be two levels: given the data\",\n \"mode. \\\"\\\"\\\" raise NotImplementedError() def was_hard_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in hard\",\n \"callable, taking no arguments, that returns a value to be used as the\",\n \"returned, but isn't cached. E.g.:: def dont_cache_none(value): return value is not None value\",\n \"from __future__ import with_statement from .. import Lock, NeedRegenerationException from ..util import NameRegistry\",\n \"the name of the :class:`.CacheBackend` to use, and is resolved by loading the\",\n \"[values[orig_to_mangled[k]].payload for k in keys] finally: for mutex in mutexes.values(): mutex.release() def _value(self,\",\n \"that value:: newvalue = generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added ``refresh()`` method to\",\n \"async_creation_runner, new values can be created in a background thread like so:: import\",\n \".. versionadded:: 0.5.0 \\\"\\\"\\\" if not mapping: return if self.key_mangler: mapping = dict((\",\n \":meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string argument which will be established as part of\",\n \"my_multi_key_generator(namespace, fn, **kw): namespace = fn.__name__ + (namespace or '') def generate_keys(*args): return\",\n \"= coerce_string_conf(config_dict) return self.configure( config_dict[\\\"%sbackend\\\" % prefix], expiration_time=config_dict.get( \\\"%sexpiration_time\\\" % prefix, None), _config_argument_dict=config_dict,\",\n \"Similar to ``set()`` is ``refresh()``. This attribute will invoke the decorated function and\",\n \"unconditionally. The method also interprets the cached value in terms of the current\",\n \"region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \\\"\\\"\\\" def invalidate(self, hard=True):\",\n \"``None`` to distinguish between a cached value of ``None``. By default, the configured\",\n \"it's typical for a key to be a string, it is ultimately passed\",\n \"\\\"\\\"\\\"Return multiple values from the cache, based on the given keys. Returns values\",\n \"keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload if\",\n \"import compat import time import datetime from numbers import Number from functools import\",\n \"on a sequence of keys. The behavior for generation of values based on\",\n \"keys, those keys will not be cached. :param to_str: callable, will be called\",\n \"in hard mode. :return: Boolean. True if region was invalidated in hard mode.\",\n \".util import function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue from .proxy import ProxyBackend\",\n \"there is a stale value present in the cache. It will be passed\",\n \"'') def generate_keys(*args): return [namespace + ':' + str(a) for a in args]\",\n \"particular cache backend. :param name: Optional, a string name for the region. This\",\n \"generate_something(*keys): return [ somedatabase.query(key) for key in keys ] The decorated function can\",\n \"Used by dogpile.core:Lock when appropriate ''' def runner(): try: value = creator() cache.set(somekey,\",\n \"= region_invalidator return self def wrap(self, proxy): ''' Takes a ProxyBackend instance or\",\n \"should return list of keys. For example:: def my_multi_key_generator(namespace, fn, **kw): namespace =\",\n \"value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\\\"ct\\\"])): raise NeedRegenerationException() ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct):\",\n \"method also interprets the cached value in terms of the current \\\"invalidation\\\" time\",\n \"value_fn(value): if value is NO_VALUE: return value elif expiration_time is not None and\",\n \"if ``True``, the decorated function should return its result as a dictionary of\",\n \"given a data creation function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method. The\",\n \"\\\"two\\\", \\\"three\\\"]) To convert values to a dictionary, use ``zip()``:: keys = [\\\"one\\\",\",\n \"in order to convert to a string. Defaults to ``str()``. If the function\",\n \"\\\"\\\"\\\"A function decorator that will cache multiple return values from the function using\",\n \"def invalidate(self, hard=True): \\\"\\\"\\\"Region invalidation. :class:`.CacheRegion` propagated call. The default invalidation system works\",\n \"can't, it means a different thread or process is already running a creation\",\n \"is also provided with a ``set()`` method, which here accepts a mapping of\",\n \"return generate_key region = make_region( function_key_generator = my_key_generator ).configure( \\\"dogpile.cache.dbm\\\", expiration_time=300, arguments={ \\\"filename\\\":\\\"file.dbm\\\"\",\n \"= self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \\\"\\\"\\\"Remove multiple values from the cache. This\",\n \"from the cache, based on the given key. If the value is not\",\n \"function itself and its arguments. The decorator internally makes use of the :meth:`.CacheRegion.get_or_create`\",\n \"= key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values = fn(*arg) if\",\n \"should be two levels: given the data creation function, return a new function\",\n \"to :meth:`.CacheRegion.configure` to override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._soft_invalidated\",\n \"self.delete_multi(keys) def set_(mapping): keys = list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for\",\n \"the string length is fixed. To disable all key mangling, set to ``False``.\",\n \"was invalidated. :return: Boolean. True if ``timestamp`` is older than the last region\",\n \"While it's typical for a key to be a string, it is ultimately\",\n \"0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" def get_value(key): value = values.get(key, NO_VALUE) if\",\n \"called whenever the decorated function itself is called, in caching or retrieving. Thus,\",\n \"to use, and is resolved by loading the class from the ``dogpile.cache`` entrypoint.\",\n \"async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5, arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, } ) Remember that\",\n \"which provides for invalidation of the value. Pass to ``invalidate()`` the same arguments\",\n \"my_data() .. seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` - optional gen that\",\n \"key\\\" given a data creation function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method.\",\n \"time. May be specified as a callable, taking no arguments, that returns a\",\n \"keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\\\ else expiration_time if asdict: def dict_create(*keys):\",\n \"versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is\",\n \"of this function should be two levels: given the data creation function, return\",\n \"None: return mutex else: return self._LockWrapper() def invalidate(self, hard=True): \\\"\\\"\\\"Invalidate this :class:`.CacheRegion`. The\",\n \"False, the value is still returned, but isn't cached. E.g.:: def dont_cache_none(value): return\",\n \"mutex and is responsible releasing that mutex when finished. This can be used\",\n \"the retrieved value versus the current time (as reported by ``time.time()``). If stale,\",\n \"namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \\\"\\\"\\\"A function decorator that will cache the return\",\n \"may not be used to recreate the value and persist the newly generated\",\n \"%s. \\\" \\\"Specify replace_existing_backend=True to replace.\\\" % self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict:\",\n \"fn return decorate return decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type,\",\n \"\\\"hard\\\" and \\\"soft\\\" invalidation options. With \\\"hard\\\" invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate\",\n \"region was invalidated in hard mode. :return: Boolean. True if region was invalidated\",\n \"if not keys: return [] if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys))\",\n \"exception from ..util import PluginLoader, memoized_property, coerce_string_conf from .util import function_key_generator, function_multi_key_generator from\",\n \"to determine if it was invalidated. :return: Boolean. True if ``timestamp`` is older\",\n \"the value ``3`` as the value to be cached. .. versionadded:: 0.4.1 Added\",\n \"value.metadata[\\\"ct\\\"] > expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\\\"ct\\\"]): return NO_VALUE else: return value\",\n \"method, which will return values based on the given arguments:: values = generate_something.get(\\\"k1\\\",\",\n \"is a convenience method for :meth:`.CacheRegion.set` which will store a given value directly\",\n \"the decorated function is missing keys, those keys will not be cached. :param\",\n \"similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of the function with the\",\n \"value is not present, the method returns the token ``NO_VALUE``. ``NO_VALUE`` evaluates to\",\n \"key_generator(*arg, **kw) return self.get(key) def refresh(*arg, **kw): key = key_generator(*arg, **kw) value =\",\n \"a sequence of cached values based on a sequence of keys. The behavior\",\n \"the :meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not** the :meth:`.CacheRegion.get` method) will call upon the\",\n \"a cached value based on the given key. If the value does not\",\n \"if not None. To set no expiration, use the value -1. :param should_cache_fn:\",\n \"safely) .. versionadded:: 0.5.0 \\\"\\\"\\\" if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys))\",\n \"decorator will produce a list of cache keys using a mechanism similar to\",\n \"it was invalidated. :return: Boolean. True if ``timestamp`` is older than the last\",\n \":class:`.CacheBackend` to use, and is resolved by loading the class from the ``dogpile.cache``\",\n \"wraps import threading _backend_loader = PluginLoader(\\\"dogpile.cache\\\") register_backend = _backend_loader.register from . import backends\",\n \"a long-running queue, or a task manager system like Celery. For a specific\",\n \"invalidation strategy with custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \\\"\\\"\\\" if \\\"backend\\\"\",\n \"same arguments you'd pass to the function itself to represent a particular value::\",\n \"from functools import wraps import threading _backend_loader = PluginLoader(\\\"dogpile.cache\\\") register_backend = _backend_loader.register from\",\n \"class methods. Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\\\"foo\\\") def one(self, a, b): return\",\n \"decorate return decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \\\"\\\"\\\"A\",\n \"config file. :param function_key_generator: Optional. A function that will produce a \\\"cache key\\\"\",\n \"determine if it was soft invalidated. :return: Boolean. True if ``timestamp`` is older\",\n \"generate_keys :param key_mangler: Function which will be used on all incoming keys before\",\n \"previous, backwards-incompatible version. \\\"\\\"\\\" class RegionInvalidationStrategy(object): \\\"\\\"\\\"Region invalidation strategy interface Implement this interface\",\n \"thread, a long-running queue, or a task manager system like Celery. For a\",\n \"for key in keys ] The decorated function can be called normally. The\",\n \"def release(self): self.lock.release() def _create_mutex(self, key): mutex = self.backend.get_mutex(key) if mutex is not\",\n \"later points in the future by way of, for example, a background thread,\",\n \"this can be used to determine a *dynamic* expiration time for the cached\",\n \"The method supports both \\\"hard\\\" and \\\"soft\\\" invalidation options. With \\\"hard\\\" invalidation, :meth:`.CacheRegion.get_or_create`\",\n \"else: self._soft_invalidated = time.time() self._hard_invalidated = None def is_invalidated(self, timestamp): return ((self._soft_invalidated and\",\n \"considered to be expired based on its creation time, the given creation function\",\n \"when using a backend such as bsddb or dbm under Python 2.x in\",\n \"retrieved value versus the current time (as reported by ``time.time()``). If stale, the\",\n \"backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return [ value.payload if value\",\n \"The above example is equivalent to calling ``generate_something(5, 6)``, if the function were\",\n \"this timestamp is considered to be stale. It does not affect the data\",\n \"and the arguments passed to it. This method is the \\\"multiple key\\\" analogue\",\n \"a value as returned by the creator, and only if it returns True\",\n \"separate from ``None`` to distinguish between a cached value of ``None``. By default,\",\n \"region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \\\"\\\"\\\" def invalidate(self, hard=True): \\\"\\\"\\\"Region invalidation.\",\n \"A list of :class:`.ProxyBackend` classes and/or instances, each of which will be applied\",\n \"keys. :param async_creation_runner: A callable that, when specified, will be passed to and\",\n \"creation function for this key against the cache. When the dogpile lock cannot\",\n \"as part of the cache key. This may be needed to disambiguate functions\",\n \"as:: def my_key_generator(namespace, fn, **kw): fname = fn.__name__ def generate_key(*arg): return namespace +\",\n \"numbers import Number from functools import wraps import threading _backend_loader = PluginLoader(\\\"dogpile.cache\\\") register_backend\",\n \"by ``time.time()``). If stale, the cached value is ignored and the ``NO_VALUE`` token\",\n \"string name for the region. This isn't used internally but can be accessed\",\n \"of ``False``, the decorated function should return its result as a list of\",\n \".. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is None: function_multi_key_generator\",\n \"previous value is available, that value is returned immediately without blocking. If the\",\n \"NeedRegenerationException() ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time - .0001\",\n \"use of the :meth:`.CacheRegion.get_or_create` method to access the cache and conditionally call the\",\n \"on if the *dogpile lock* can be acquired or not. If it can't,\",\n \"invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw): key =\",\n \"stale, the cached value is ignored and the ``NO_VALUE`` token is returned. Passing\",\n \"invalidate(self, hard=None): if hard: self._soft_invalidated = None self._hard_invalidated = time.time() else: self._soft_invalidated =\",\n \"\\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\", \\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1, 10.0.0.1\\\", } local_region.configure_from_config(myconfig, \\\"cache.local.\\\") memcached_region.configure_from_config(myconfig, \\\"cache.memcached.\\\") \\\"\\\"\\\" config_dict = coerce_string_conf(config_dict) return\",\n \"is the SHA1 mangler found at :func:`.sha1_mangle_key` which coerces keys into a SHA1\",\n \"invalidation time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method\",\n \"accessed via the ``.name`` parameter, helpful for configuring a region from a config\",\n \"value is available, that value is returned immediately without blocking. If the :meth:`.invalidate`\",\n \"the result until the end of the day, week or time period\\\" and\",\n \"(as reported by ``time.time()``). If stale, the cached value is ignored and the\",\n \"versionadded:: 0.3.0 \\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key) value =\",\n \"expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return a value from the cache, based on the given key.\",\n \"set by the :meth:`.invalidate` method. If a value is present, but its creation\",\n \"result as a list of values, and the final result of calling the\",\n \"\\\"\\\"\\\"Check timestamp to determine if it was hard invalidated. :return: Boolean. True if\",\n \"not None value = region.get_or_create(\\\"some key\\\", create_value, should_cache_fn=dont_cache_none) Above, the function returns the\",\n \"prefix): \\\"\\\"\\\"Configure from a configuration dictionary and a prefix. Example:: local_region = make_region()\",\n \"value:: generate_something.invalidate(5, 6) Another attribute ``set()`` is added to provide extra caching possibilities\",\n \"self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \\\"\\\"\\\"A front end to a particular cache backend.\",\n \"args] return generate_keys :param key_mangler: Function which will be used on all incoming\",\n \"self.key_mangler: key = self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \\\"\\\"\\\"Remove multiple values from the\",\n \"= self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result = dict( (k, v) for k,\",\n \"that the string length is fixed. To disable all key mangling, set to\",\n \"def __init__(self, region): self.region = region # ... # ... region = CacheRegion()\",\n \"value else: if expiration_time is None: expiration_time = self.expiration_time current_time = time.time() def\",\n \"different thread or process is already running a creation function for this key\",\n \"as a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time`` may be optionally passed as\",\n \"that will cache multiple return values from the function using a sequence of\",\n \"override the normal expiration time. May be passed as an integer or a\",\n \"cache key above for ``MyClass().one(3, 4)`` will again produce the same cache key\",\n \"It's not consulted outside this function, so in fact can be of any\",\n \"also be a list. When ``asdict==True`` if the dictionary returned by the decorated\",\n \"will be called whenever the decorated function itself is called, in caching or\",\n \"generate_key(*arg): return namespace + \\\"_\\\" + fname + \\\"_\\\".join(str(s) for s in arg)\",\n \"be of any form. For example, it can be passed as a tuple,\",\n \"Celery. For a specific example using async_creation_runner, new values can be created in\",\n \") The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside this\",\n \"my_function(a, b, **kw): return my_data() .. seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator`\",\n \"available, that value is returned immediately without blocking. If the :meth:`.invalidate` method has\",\n \"supersede that configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.3.0 :param ignore_expiration: if\",\n \"ignore_expiration) return [ value.payload if value is not NO_VALUE else value for value\",\n \"if ignore_expiration: return lambda value: value else: if expiration_time is None: expiration_time =\",\n \"arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`.\",\n \"called with that subset of arguments. The returned result is a list:: result\",\n \"the \\\"creator\\\", and will then return True or False, indicating if the value\",\n \"\\\"\\\"\\\"Remove a value from the cache. This operation is idempotent (can be called\",\n \"the token ``NO_VALUE``. ``NO_VALUE`` evaluates to False, but is separate from ``None`` to\",\n \"the same name within the same module, as can occur when decorating instance\",\n \"for orig_key, mangled_key in orig_to_mangled.items(): with Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda\",\n \"decorator that will cache the return value of the function using a key\",\n \"to generate a new value, or will wait until the lock is released\",\n \"versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks the value's creation time against the expiration time,\",\n \"value.metadata[\\\"ct\\\"]): return NO_VALUE else: return value return value_fn def get_multi(self, keys, expiration_time=None, ignore_expiration=False):\",\n \"so that the string length is fixed. To disable all key mangling, set\",\n \"corresponds to that of :meth:`.Region.get_or_create`, with the exception that the ``creator()`` function may\",\n \"optional callable function which will receive each value returned by the \\\"creator\\\", and\",\n \"a particular value:: generate_something.invalidate(5, 6) Another attribute ``set()`` is added to provide extra\",\n \"caveats) for use with instance or class methods. Given the example:: class MyClass(object):\",\n \"provided async_creation_runner callable implements. By default the async_creation_runner is disabled and is set\",\n \"to represent a particular value:: generate_something.invalidate(5, 6) Another attribute ``set()`` is added to\",\n \"the final result of calling the decorated function will also be a dictionary.\",\n \"Optional. The structure here is passed directly to the constructor of the :class:`.CacheBackend`\",\n \"of the same name within the same module, as can occur when decorating\",\n \"for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return self def\",\n \"value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core understands a 0 here as # \\\"the\",\n \"is used normally to disambiguate two functions of the same name within the\",\n \"part of the cache key. This may be needed to disambiguate functions of\",\n \"region.get_multi([\\\"one\\\", \\\"two\\\", \\\"three\\\"]) To convert values to a dictionary, use ``zip()``:: keys =\",\n \":return: Boolean. True if ``timestamp`` is older than the last region invalidation time\",\n \"under the given key.\\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self,\",\n \"mapping): \\\"\\\"\\\"Place new values in the cache under the given keys. .. versionadded::\",\n \"key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \\\"\\\"\\\"A\",\n \"= generate_something(\\\"key1\\\", \\\"key2\\\", \\\"key3\\\") The decorator internally makes use of the :meth:`.CacheRegion.get_or_create_multi` method\",\n \"was_soft_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in soft mode. :return: Boolean. True if\",\n \"\\\"k2\\\", \\\"k3\\\") .. versionadded:: 0.5.3 Added ``get()`` method to decorated function. Parameters passed\",\n \"This isn't used internally but can be accessed via the ``.name`` parameter, helpful\",\n \"means a different thread or process is already running a creation function for\",\n \"self._soft_invalidated = None self._hard_invalidated = time.time() else: self._soft_invalidated = time.time() self._hard_invalidated = None\",\n \"established as part of each cache key. :param expiration_time: if not None, will\",\n \"and not replace_existing_backend: raise exception.RegionAlreadyConfigured( \\\"This region is already \\\" \\\"configured with backend:\",\n \"should_cache_fn=None): \\\"\\\"\\\"Return a cached value based on the given key. If the value\",\n \"cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \\\"\\\"\\\"A function decorator that will cache\",\n \"If left at its default value of ``False``, the decorated function should return\",\n \"not exist or is considered to be expired based on its creation time,\",\n \"mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \\\"\\\"\\\"Remove a value from the cache. This operation\",\n \"that subset of arguments. The returned result is a list:: result = generate_something(\\\"key1\\\",\",\n \"to be cached is passed as the first argument, and the arguments which\",\n \"self._soft_invalidated) or (self._hard_invalidated and timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self,\",\n \"in soft mode. \\\"\\\"\\\" raise NotImplementedError() def was_hard_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated\",\n \"self._LockWrapper() def invalidate(self, hard=True): \\\"\\\"\\\"Invalidate this :class:`.CacheRegion`. The default invalidation system works by\",\n \"versionadded:: 0.5.0 \\\"\\\"\\\" if not keys: return [] if self.key_mangler: keys = list(map(lambda\",\n \"it can be passed as a tuple, used to specify arguments to pluck\",\n \"return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values = fn(*arg) if asdict: self.set_multi(\",\n \"(with caveats) for use with instance or class methods. Given the example:: class\",\n \"decorator def make_region(*arg, **kw): \\\"\\\"\\\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough\",\n \"the expiration time already configured on this :class:`.CacheRegion` if not None. To set\",\n \"no previous value is available, until the lock is released and a new\",\n \"for. With \\\"soft\\\" invalidation, subsequent getters will return the \\\"old\\\" value until the\",\n \"used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw): return my_data() .. seealso:: :func:`.function_key_generator`\",\n \"invalidate(self, hard=True): \\\"\\\"\\\"Invalidate this :class:`.CacheRegion`. The default invalidation system works by setting a\",\n \"0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is None:\",\n \"refresh decorate.get = get decorate.original = fn return decorate return decorator def cache_multi_on_arguments(\",\n \"function which accepts a sequence of keys and returns a sequence of new\",\n \"False, indicating if the value should actually be cached or not. If it\",\n \"will produce a cache key as follows:: myapp.tools:one|foo|3 4 The key generator will\",\n \"The structure of this function should be two levels: given the data creation\",\n \"method returns the token ``NO_VALUE``. ``NO_VALUE`` evaluates to False, but is separate from\",\n \"time already configured on this :class:`.CacheRegion` if not None. To set no expiration,\",\n \"returns False, the value is still returned, but isn't cached. E.g.:: def dont_cache_none(value):\",\n \"def get_multi(self, keys, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return multiple values from the cache, based on\",\n \"being declared. :param expiration_time: if not None, will override the normal expiration time.\",\n \"is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \\\"\\\"\\\"A front\",\n \"the value to be cached. .. versionadded:: 0.4.1 Added ``set()`` method to decorated\",\n \"versionadded:: 0.4.3 :param to_str: callable, will be called on each function argument in\",\n \"@wraps(fn) def decorate(*arg, **kw): key = key_generator(*arg, **kw) @wraps(fn) def creator(): return fn(*arg,\",\n \"\\\"value1\\\", \\\"k2\\\": \\\"value2\\\", \\\"k3\\\": \\\"value3\\\"}) ...an ``invalidate()`` method, which has the effect of\",\n \"key, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a cached value based on the given key.\",\n \"on the :class:`.CacheRegion` itself. .. versionadded:: 0.3.0 :param ignore_expiration: if ``True``, the value\",\n \"timestamp to determine if it was invalidated. :return: Boolean. True if ``timestamp`` is\",\n \"return its result as a dictionary of keys->values, and the final result of\",\n \"affect the data in the cache in any way, and is also local\",\n \"no arguments, that returns a value to be used as the ``expiration_time``. This\",\n \"creator(*keys_to_create): return fn(*[key_lookup[k] for k in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\\\\",\n \"ProxyBackend\\\" % type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self, key): return self._lock_registry.get(key) class _LockWrapper(object):\",\n \"..util import compat import time import datetime from numbers import Number from functools\",\n \"The behavior for generation of values based on keys corresponds to that of\",\n \":func:`.function_key_generator`. :param namespace: optional string argument which will be established as part of\",\n \"replaced on a per-region basis using the ``function_key_generator`` argument present on :func:`.make_region` and\",\n \":param async_creation_runner: A callable that, when specified, will be passed to and called\",\n \"that a return+regen will be invoked. .. versionadded:: 0.5.1 \\\"\\\"\\\" self.region_invalidator.invalidate(hard) def configure_from_config(self,\",\n \"no associated value will always block; async_creator will not be invoked. However, subsequent\",\n \"the name of the function, the module name for the function, the arguments\",\n \"value does not exist or is considered to be expired based on its\",\n \"will be used on all incoming keys before passing to the backend. Defaults\",\n \"with the exception that the ``creator()`` function may be asked to generate any\",\n \"to disambiguate functions of the same name within the same source file, such\",\n \"k, v in zip(keys_to_get, new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k,\",\n \"@region.cache_on_arguments(namespace=\\\"foo\\\") def one(self, a, b): return a + b The cache key above\",\n \"front end to a particular cache backend. :param name: Optional, a string name\",\n \"if the dictionary returned by the decorated function is missing keys, those keys\",\n \"k in namespace] + [str(x) for x in arg] ) return generate_key Where\",\n \"is invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError() def is_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp\",\n \"value to be used as the ``expiration_time``. This callable will be called whenever\",\n \"argument present on :func:`.make_region` and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`. :param namespace: optional\",\n \"such as those associated with classes - note that the decorator itself can't\",\n \"retrieving. Thus, this can be used to determine a *dynamic* expiration time for\",\n \"if value is not NO_VALUE else value for value in ( _unexpired_value_fn(value) for\",\n \"of values based on keys corresponds to that of :meth:`.Region.get_or_create`, with the exception\",\n \"or alternatively the expiration time supplied by the ``expiration_time`` argument, is tested against\",\n \"timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object): \\\"\\\"\\\"A front end to a particular\",\n \"values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k in keys] finally: for\",\n \"the same arguments you'd pass to the function itself to represent a particular\",\n \"namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys = arg keys = key_generator(*arg,\",\n \"refresh decorate.get = get return decorate return decorator def make_region(*arg, **kw): \\\"\\\"\\\"Instantiate a\",\n \"lock to generate a new value, or will wait until the lock is\",\n \"if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self, orig_key, creator, mutex) else: async_creator =\",\n \"if present. :param creator: function which creates a new value. :param expiration_time: optional\",\n \"get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass try: if mutexes: # sort\",\n \"value from the cache, based on the given key. If the value is\",\n \"Whether or not the function is used depends on if the *dogpile lock*\",\n \"decorator(fn): key_generator = function_multi_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): cache_keys =\",\n \"time.time() def is_invalidated(self, timestamp): return (self._invalidated is not None and timestamp < self._invalidated)\",\n \"= None mutexes = {} sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k)\",\n \"``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python class declaration mechanics otherwise prevent the decorator\",\n \"decorator itself can't see the parent class on a function as the class\",\n \"def dict_create(*keys): d_values = creator(*keys) return [ d_values.get(key_lookup[k], NO_VALUE) for k in keys]\",\n \"= make_region() # regions are ready to use for function # decorators, but\",\n \"if ``True``, the value is returned from the cache if present, regardless of\",\n \"hard: if True, cache values will all require immediate regeneration; dogpile logic won't\",\n \"value) def get(*arg, **kw): key = key_generator(*arg, **kw) return self.get(key) def refresh(*arg, **kw):\",\n \":meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not** the :meth:`.CacheRegion.get` method) will call upon the value\",\n \"setting a current timestamp (using ``time.time()``) representing the \\\"minimum creation time\\\" for a\",\n \"the last generation. :param arguments: Optional. The structure here is passed directly to\",\n \"= make_region() memcached_region = make_region() # regions are ready to use for function\",\n \"used to recreate the value and persist the newly generated value in the\",\n \"and conditionally call the function. See that method for additional behavioral details. Unlike\",\n \"time using the :paramref:`.CacheRegion.configure.region_invalidator` parameter:: region = CacheRegion() region = region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies\",\n \"parameter, helpful for configuring a region from a config file. :param function_key_generator: Optional.\",\n \"returned immediately without blocking. If the :meth:`.invalidate` method has been called, and the\",\n \".. versionadded:: 0.4.3 :param to_str: callable, will be called on each function argument\",\n \":meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list of keys. For example:: def my_multi_key_generator(namespace, fn,\",\n \"region.configure(region_invalidator=CustomInvalidationStrategy()) Invalidation strategies that wish to have access to the :class:`.CacheRegion` itself should\",\n \"in orig_to_mangled.items(): with Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex)\",\n \"token is returned. Passing the flag ``ignore_expiration=True`` bypasses the expiration time check. ..\",\n \"a config file. :param function_key_generator: Optional. A function that will produce a \\\"cache\",\n \"timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__',\",\n \"{ \\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\", \\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\", \\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\", \\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1, 10.0.0.1\\\", } local_region.configure_from_config(myconfig, \\\"cache.local.\\\") memcached_region.configure_from_config(myconfig, \\\"cache.memcached.\\\") \\\"\\\"\\\" config_dict\",\n \"Defaults to ``None``, in which case the key mangling function recommended by the\",\n \"Support for the :meth:`.CacheRegion.invalidate` method. :param key: Key to be retrieved. While it's\",\n \"be of any type recognized by the backend or by the key_mangler function,\",\n \"value) finally: mutex.release() thread = threading.Thread(target=runner) thread.start() region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached',\",\n \"name ``self`` is skipped. The ``namespace`` parameter is optional, and is used normally\",\n \"value. :param expiration_time: optional expiration time which will overide the expiration time already\",\n \"Boolean. True if ``timestamp`` is older than the last region invalidation time and\",\n \"expiration time supplied by the ``expiration_time`` argument, is tested against the creation time\",\n \"mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key in orig_to_mangled.items(): with Lock( self._mutex(mangled_key),\",\n \"pass implementation instance to :meth:`.CacheRegion.configure` to override default region invalidation. Example:: class CustomInvalidationStrategy(RegionInvalidationStrategy):\",\n \"the key_mangler function, if present. :param creator: function which creates a new value.\",\n \"return self.get(key) def refresh(*arg, **kw): key = key_generator(*arg, **kw) value = fn(*arg, **kw)\",\n \"if self.key_mangler: key = self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \\\"\\\"\\\"Remove multiple values from\",\n \"a function as the class is being declared. :param expiration_time: if not None,\",\n \"the cached value in terms of the current \\\"invalidation\\\" time as set by\",\n \"key = self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \\\"\\\"\\\"Remove multiple values from the cache.\",\n \"get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values =\",\n \"values)) ) return values decorate.set = set_ decorate.invalidate = invalidate decorate.refresh = refresh\",\n \"timestamp is considered to be stale. It does not affect the data in\",\n \"``NO_VALUE`` token. ``NO_VALUE`` evaluates to False, but is separate from ``None`` to distinguish\",\n \"**kw) value = fn(*arg, **kw) self.set(key, value) return value decorate.set = set_ decorate.invalidate\",\n \"_config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \\\"\\\"\\\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is\",\n \"return value def get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a sequence of\",\n \"``generate_something(5, 6)``, if the function were to produce the value ``3`` as the\",\n \"is the name of the :class:`.CacheBackend` to use, and is resolved by loading\",\n \"was invalidated in hard mode. :return: Boolean. True if region was invalidated in\",\n \"= key_generator(*arg, **kw) self.set(key, value) def get(*arg, **kw): key = key_generator(*arg, **kw) return\",\n \"to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key) for key\",\n \"``ignore_expiration=True`` bypasses the expiration time check. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not keys:\",\n \"for generation of values based on keys corresponds to that of :meth:`.Region.get_or_create`, with\",\n \"Boolean. True if region was invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError() def\",\n \"ProxyBackend): raise TypeError(\\\"Type %s is not a valid ProxyBackend\\\" % type(proxy)) self.backend =\",\n \"E.g.:: values = region.get_multi([\\\"one\\\", \\\"two\\\", \\\"three\\\"]) To convert values to a dictionary, use\",\n \"} ) The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not consulted outside\",\n \"if expiration_time == -1: expiration_time = None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner(\",\n \"deleting the given sequence of keys using the same mechanism as that of\",\n \"to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable,\",\n \"which will supersede that configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.3.0 :param\",\n \"be used to determine a *dynamic* expiration time for the cached function result.\",\n \"itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if\",\n \"region was invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError() def was_hard_invalidated(self): \\\"\\\"\\\"Indicate the\",\n \"new_values = creator(*keys_to_get) values_w_created = dict( (orig_to_mangled[k], self._value(v)) for k, v in zip(keys_to_get,\",\n \"timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated and timestamp < self._hard_invalidated))\",\n \"time so that a return+regen will be invoked. .. versionadded:: 0.5.1 \\\"\\\"\\\" self.region_invalidator.invalidate(hard)\",\n \"cache the return value of the function using a key derived from the\",\n \"and :meth:`.CacheRegion.get` methods. The method supports both \\\"hard\\\" and \\\"soft\\\" invalidation options. With\",\n \"timestamp < self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return\",\n \"May be specified as a callable, taking no arguments, that returns a value\",\n \"decorate.refresh = refresh decorate.get = get return decorate return decorator def make_region(*arg, **kw):\",\n \"function will also be a dictionary. If left at its default value of\",\n \"key_generator(*arg) values = fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for a in arg]))\",\n \"set_ decorate.invalidate = invalidate decorate.refresh = refresh decorate.get = get return decorate return\",\n \"in backend_values ) ] def get_or_create( self, key, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a\",\n \"self._lock_registry.get(key) class _LockWrapper(object): \\\"\\\"\\\"weakref-capable wrapper for threading.Lock\\\"\\\"\\\" def __init__(self): self.lock = threading.Lock() def\",\n \"is None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \\\"Non-None expiration time required \\\" \\\"for soft\",\n \"generated or need regeneration will be assembled into a new argument list, and\",\n \"on all incoming keys before passing to the backend. Defaults to ``None``, in\",\n \"specific example using async_creation_runner, new values can be created in a background thread\",\n \"\\\"\\\"\\\" def get_value(key): value = values.get(key, NO_VALUE) if (value is NO_VALUE or value.metadata['v']\",\n \"function will supersede the one configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5\",\n \"receive each value returned by the \\\"creator\\\", and will then return True or\",\n \"will receive the value returned by the \\\"creator\\\", and will then return True\",\n \"expiration_time if asdict: def dict_create(*keys): d_values = creator(*keys) return [ d_values.get(key_lookup[k], NO_VALUE) for\",\n \"< self._soft_invalidated) or (self._hard_invalidated and timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def\",\n \"last region invalidation time and region is invalidated in soft mode. \\\"\\\"\\\" raise\",\n \"NotImplementedError() def was_hard_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in hard mode. :return: Boolean.\",\n \"return self.lock.acquire(wait) def release(self): self.lock.release() def _create_mutex(self, key): mutex = self.backend.get_mutex(key) if mutex\",\n \"on this region.\\\") @property def is_configured(self): \\\"\\\"\\\"Return True if the backend has been\",\n \"the backend has been configured via the :meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1\",\n \"all getters will wait for. With \\\"soft\\\" invalidation, subsequent getters will return the\",\n \"be generated is passed to ``creator()``, and ``creator()`` should return the generated values\",\n \"as well as the :meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not** the :meth:`.CacheRegion.get` method) will\",\n \"won't be used. If False, the creation time of existing values will be\",\n \"override the normal expiration time. May be specified as a callable, taking no\",\n \"the parent class on a function as the class is being declared. :param\",\n \"expiration_time_is_callable \\\\ else expiration_time if asdict: def dict_create(*keys): d_values = creator(*keys) return [\",\n \"(self._hard_invalidated and timestamp < self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return\",\n \"NO_VALUE: return False elif not should_cache_fn: return True else: return should_cache_fn(value) result =\",\n \"It will then consult the cache using the same mechanism as that of\",\n \"(self._soft_invalidated and timestamp < self._soft_invalidated) The custom implementation is injected into a :class:`.CacheRegion`\",\n \"Once set, the invalidation time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get`\",\n \"timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def was_soft_invalidated(self): return self._is_hard_invalidated is False def is_soft_invalidated(self,\",\n \"\\\"\\\"\\\" if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self,\",\n \"require key mangling before reaching the cache. .. versionadded:: 0.5.0 :param function_key_generator: a\",\n \"invalidation. :class:`.CacheRegion` propagated call. The default invalidation system works by setting a current\",\n \"keys = list(map(lambda key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time,\",\n \"use for function # decorators, but not yet for actual caching # later,\",\n \":param asdict: if ``True``, the decorated function should return its result as a\",\n \"and is responsible releasing that mutex when finished. This can be used to\",\n \"should return its result as a list of values, and the final result\",\n \"is skipped. The ``namespace`` parameter is optional, and is used normally to disambiguate\",\n \"name of the function with the optional namespace and with the string form\",\n \"use the value -1. :param should_cache_fn: optional callable function which will receive the\",\n \"if not should_cache_fn or \\\\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\\\"ct\\\"] if expiration_time\",\n \":meth:`.Region.set_multi` to get and set values from the backend. If you are using\",\n \"to prevent deadlocks. # though haven't been able to simulate one anyway. keys_to_get\",\n \"haven't been able to simulate one anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get)\",\n \"not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for k, v in values_w_created.items() if\",\n \"be passed as an integer number of seconds, or as a ``datetime.timedelta`` value.\",\n \"0.5.1 \\\"\\\"\\\" return 'backend' in self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return a\",\n \"it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list of keys. For example::\",\n \"the value is not present, the method returns the token ``NO_VALUE``. ``NO_VALUE`` evaluates\",\n \"its creation time, the given creation function may or may not be used\",\n \"prefix], expiration_time=config_dict.get( \\\"%sexpiration_time\\\" % prefix, None), _config_argument_dict=config_dict, _config_prefix=\\\"%sarguments.\\\" % prefix, wrap=config_dict.get( \\\"%swrap\\\" %\",\n \"before being optionally processed by the key_mangler function, so can be of any\",\n \"If the :meth:`.invalidate` method has been called, and the retrieved value's timestamp is\",\n \"note this will produce unicode cache keys which may require key mangling before\",\n \"itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if\",\n \"the cache with the new value, as well as returning that value:: newvalue\",\n \"= compat.callable(expiration_time) if function_multi_key_generator is None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator =\",\n \"refresh(*arg): keys = key_generator(*arg) values = fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for\",\n \"my_key_generator ).configure( \\\"dogpile.cache.dbm\\\", expiration_time=300, arguments={ \\\"filename\\\":\\\"file.dbm\\\" } ) The ``namespace`` is that passed\",\n \"mechanics otherwise prevent the decorator from having awareness of the ``MyClass`` and ``MyOtherClass``\",\n \"if not issubclass(type(proxy), ProxyBackend): raise TypeError(\\\"Type %s is not a valid ProxyBackend\\\" %\",\n \"arg])) ) return values else: self.set_multi( dict(zip(keys, values)) ) return values decorate.set =\",\n \"\\\"\\\"\\\"Return a value from the cache, based on the given key. If the\",\n \"is None: expiration_time = self.expiration_time current_time = time.time() def value_fn(value): if value is\",\n \"will call upon the value creation function after this time period has passed\",\n \"``expiration_time`` may be passed as a callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to\",\n \"will be pulled from the cache region unless a new value is needed::\",\n \"= key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None,\",\n \"a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time`` may be optionally passed as a\",\n \"versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param key: Key to be retrieved.\",\n \"return value.payload, 0 else: ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() -\",\n \"substituted, but note this will produce unicode cache keys which may require key\",\n \"is available, that value is returned immediately without blocking. If the :meth:`.invalidate` method\",\n \"new values can be created in a background thread like so:: import threading\",\n \"self.key_mangler(k), self._value(v)) for k, v in mapping.items()) else: mapping = dict((k, self._value(v)) for\",\n \"\\\"value2\\\", \\\"k3\\\": \\\"value3\\\"}) ...an ``invalidate()`` method, which has the effect of deleting the\",\n \"self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return self def wrap(self, proxy): ''' Takes\",\n \"else: result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result def invalidate(*arg): keys\",\n \"receive the value returned by the \\\"creator\\\", and will then return True or\",\n \"``False``. Another typical mangler is the built-in Python function ``str``, which can be\",\n \"\\\"\\\"\\\" if not mapping: return if self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v)) for\",\n \":func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` - optional gen that also uses keyword\",\n \"NotImplementedError() def was_soft_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in soft mode. :return: Boolean.\",\n \"backend. ''' # if we were passed a type rather than an instance\",\n \"from the cache region unless a new value is needed:: result = generate_something(5,\",\n \"e.g. # _has_value() will return False. return value.payload, 0 else: ct = value.metadata[\\\"ct\\\"]\",\n \"self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \\\"\\\"\\\"Configure a :class:`.CacheRegion`.\",\n \"needed to disambiguate functions of the same name within the same source file,\",\n \"or timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap,\",\n \"``asdict==True`` if the dictionary returned by the decorated function is missing keys, those\",\n \"the function itself to represent a particular value:: generate_something.invalidate(5, 6) Another attribute ``set()``\",\n \"same name within the same source file, such as those associated with classes\",\n \"that of :meth:`.CacheRegion.get_multi` to retrieve all current values; the originally passed keys corresponding\",\n \") if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for k, v in\",\n \"as the function is received by the decorator before it becomes an instance\",\n \"with the string form of each key. It will then consult the cache\",\n \"> expiration_time: return NO_VALUE elif self.region_invalidator.is_invalidated( value.metadata[\\\"ct\\\"]): return NO_VALUE else: return value return\",\n \"else: key_generator = function_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key =\",\n \"timestamp (using ``time.time()``) representing the \\\"minimum creation time\\\" for a value. Any retrieved\",\n \"time value which will supersede that configured on the :class:`.CacheRegion` itself. .. versionadded::\",\n \"\\\" \\\"for soft invalidation\\\") if expiration_time == -1: expiration_time = None mutexes =\",\n \"return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return (self._hard_invalidated and timestamp < self._hard_invalidated) def was_soft_invalidated(self):\",\n \"a new value available. If a previous value is available, that value is\",\n \"with instance or class methods. Given the example:: class MyClass(object): @region.cache_on_arguments(namespace=\\\"foo\\\") def one(self,\",\n \"(k, v) for k, v in zip(cache_keys, result) if v is not NO_VALUE)\",\n \"or as a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time`` may be optionally passed\",\n \"last region invalidation time. \\\"\\\"\\\" raise NotImplementedError() def was_soft_invalidated(self): \\\"\\\"\\\"Indicate the region was\",\n \"previous value is available, until the lock is released and a new value\",\n \"passed as the first argument, and the arguments which would normally be passed\",\n \"time.time() def value_fn(value): if value is NO_VALUE: return value elif expiration_time is not\",\n \"regeneration will be assembled into a new argument list, and the decorated function\",\n \"using async_creation_runner, new values can be created in a background thread like so::\",\n \"the ``expiration_time`` argument, is tested against the creation time of the retrieved value\",\n \"a ``set()`` method, which here accepts a mapping of keys and values to\",\n \"the data creation function, return a new function that generates the key based\",\n \"backend has been configured via the :meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1 \\\"\\\"\\\"\",\n \"= function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner\",\n \"values can be created in a background thread like so:: import threading def\",\n \"backend: %s. \\\" \\\"Specify replace_existing_backend=True to replace.\\\" % self.backend) backend_cls = _backend_loader.load(backend) if\",\n \"time. May be passed as an integer or a callable. :param should_cache_fn: passed\",\n \"values it returns to the calling function. A correct implementation of ``.set_multi()`` will\",\n \"None mutexes = {} sorted_unique_keys = sorted(set(keys)) if self.key_mangler: mangled_keys = [self.key_mangler(k) for\",\n \"y) The decorated function can then be called normally, where data will be\",\n \"value is unconditionally prevented from being returned. The method will attempt to acquire\",\n \"The ``namespace`` parameter is optional, and is used normally to disambiguate two functions\",\n \"for a value. Any retrieved value whose creation time is prior to this\",\n \"the :class:`.CacheRegion` itself should construct the invalidator given the region as an argument::\",\n \"for k, v in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k\",\n \"b, **kw): return my_data() .. seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` -\",\n \"hard=True): self._is_hard_invalidated = bool(hard) self._invalidated = time.time() def is_invalidated(self, timestamp): return (self._invalidated is\",\n \"creates a new value. :param expiration_time: optional expiration time which will overide the\",\n \"before it becomes an instance method. The function key generation can be entirely\",\n \"the function, the arguments passed, as well as an optional \\\"namespace\\\" parameter in\",\n \"be assembled into a new argument list, and the decorated function is then\",\n \"def was_soft_invalidated(self): return self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp)\",\n \"a configuration dictionary and a prefix. Example:: local_region = make_region() memcached_region = make_region()\",\n \"will again produce the same cache key of ``myapp.tools:one|foo|3 4`` - the name\",\n \"time, the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses the invalidation\",\n \"= proxy.wrap(self.backend) def _mutex(self, key): return self._lock_registry.get(key) class _LockWrapper(object): \\\"\\\"\\\"weakref-capable wrapper for threading.Lock\\\"\\\"\\\"\",\n \"attribute ``set()`` is added to provide extra caching possibilities relative to the function.\",\n \"entirely replaced on a per-region basis using the ``function_key_generator`` argument present on :func:`.make_region`\",\n \"instance or class and wraps the attached backend. ''' # if we were\",\n \"def configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \\\"\\\"\\\"Configure\",\n \"def was_hard_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in hard mode. :return: Boolean. True\",\n \"present, regardless of configured expiration times or whether or not :meth:`.invalidate` was called.\",\n \"= dict(zip(keys, values)) Keys which aren't present in the list are returned as\",\n \"invalidation system works by setting a current timestamp (using ``time.time()``) to consider all\",\n \"self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \\\"\\\"\\\"A function\",\n \"0.5.0 Added ``refresh()`` method to decorated function. Lastly, the ``get()`` method returns either\",\n \"4`` - the name ``self`` is skipped. The ``namespace`` parameter is optional, and\",\n \"get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a sequence of cached values based\",\n \"will be used. A typical mangler is the SHA1 mangler found at :func:`.sha1_mangle_key`\",\n \"key_generator(*arg, **kw) @wraps(fn) def creator(): return fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable\",\n \"will block if no previous value is available, until the lock is released\",\n \"cached value based on the given key. If the value does not exist\",\n \"from the backend. If you are using a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies\",\n \"to determine if it was hard invalidated. :return: Boolean. True if ``timestamp`` is\",\n \"dictionary of keys->values, and the final result of calling the decorated function will\",\n \"versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function using a\",\n \"function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \\\"\\\"\\\"Construct a new :class:`.CacheRegion`.\\\"\\\"\\\" self.name = name self.function_key_generator =\",\n \"may require key mangling before reaching the cache. .. versionadded:: 0.5.0 :param function_multi_key_generator:\",\n \"self.key_mangler: key = self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping): \\\"\\\"\\\"Place new values in\",\n \"__init__(self): self._soft_invalidated = None self._hard_invalidated = None def invalidate(self, hard=None): if hard: self._soft_invalidated\",\n \"__init__(self): self._is_hard_invalidated = None self._invalidated = None def invalidate(self, hard=True): self._is_hard_invalidated = bool(hard)\",\n \"def one(self, a, b): return a + b The cache key above for\",\n \"None and self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \\\"Non-None expiration time required \\\" \\\"for soft invalidation\\\")\",\n \"determine if it was hard invalidated. :return: Boolean. True if ``timestamp`` is older\",\n \"called normally. The decorator will produce a list of cache keys using a\",\n \"functools import wraps import threading _backend_loader = PluginLoader(\\\"dogpile.cache\\\") register_backend = _backend_loader.register from .\",\n \"= self.key_mangler(key) value = self.backend.get(key) value = self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload def\",\n \"initial argument of ``self`` or ``cls``, making the decorator suitable (with caveats) for\",\n \"expiration_time: if not None, will override the normal expiration time. May be passed\",\n \".. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is None: function_key_generator\",\n \"expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator\",\n \"keys = key_generator(*arg) values = fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for a\",\n \"``.set_multi()`` for newly generated values using the same values it returns to the\",\n \"decorated function can be called normally. The decorator will produce a list of\",\n \"time. \\\"\\\"\\\" raise NotImplementedError() def was_soft_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in soft\",\n \"the invalidation time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The\",\n \"instance or class methods as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y):\",\n \"MyInvalidator(RegionInvalidationStrategy): def __init__(self, region): self.region = region # ... # ... region =\",\n \"is not a number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry\",\n \"decorator might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw): return my_data()\",\n \"datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time is not a number\",\n \"value. .. versionadded 0.5.0 ``expiration_time`` may be optionally passed as a ``datetime.timedelta`` value.\",\n \"strategies that wish to have access to the :class:`.CacheRegion` itself should construct the\",\n \"by the decorated function is missing keys, those keys will not be cached.\",\n \"key): mutex = self.backend.get_mutex(key) if mutex is not None: return mutex else: return\",\n \"form of each key. It will then consult the cache using the same\",\n \"**kw) return self.get(key) def refresh(*arg, **kw): key = key_generator(*arg, **kw) value = fn(*arg,\",\n \"times or whether or not :meth:`.invalidate` was called. .. versionadded:: 0.3.0 \\\"\\\"\\\" if\",\n \"fact can be of any form. For example, it can be passed as\",\n \"0.5.7 :param region_invalidator: Optional. Override default invalidation strategy with custom implementation of :class:`.RegionInvalidationStrategy`.\",\n \"passed to :meth:`.CacheRegion.get_or_create_multi`. This function is given a value as returned by the\",\n \"releasing that mutex when finished. This can be used to defer the computation\",\n \"the function should follow:: generate_something.set(3, 5, 6) The above example is equivalent to\",\n \"seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create` to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi` -\",\n \"a type rather than an instance then # initialize it. if type(proxy) ==\",\n \"not yet for actual caching # later, when config is available myconfig =\",\n \"above example is equivalent to calling ``generate_something(5, 6)``, if the function were to\",\n \"new value available. If a previous value is available, that value is returned\",\n \"not None and timestamp < self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is True def\",\n \"[ d_values.get(key_lookup[k], NO_VALUE) for k in keys] def wrap_cache_fn(value): if value is NO_VALUE:\",\n \"behavior for generation of values based on keys corresponds to that of :meth:`.Region.get_or_create`,\",\n \":param keys: Sequence of keys to be retrieved. :param creator: function which accepts\",\n \"Defaults to ``str()``. If the function accepts non-ascii unicode arguments on Python 2.x,\",\n \"= None def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated\",\n \"but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list of keys. For\",\n \"result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result = dict( (k, v) for\",\n \"\\\"\\\"\\\"Place a new value in the cache under the given key.\\\"\\\"\\\" if self.key_mangler:\",\n \"set_(mapping): keys = list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key\",\n \"arguments:: values = generate_something.get(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") .. versionadded:: 0.5.3 Added ``get()`` method to\",\n \"be cached or not. If it returns False, the value is still returned,\",\n \"on a non-existent key, safely) .. versionadded:: 0.5.0 \\\"\\\"\\\" if self.key_mangler: keys =\",\n \"mode. :return: Boolean. True if region was invalidated in soft mode. \\\"\\\"\\\" raise\",\n \"to a particular cache backend. :param name: Optional, a string name for the\",\n \"cached. .. versionadded:: 0.4.1 Added ``set()`` method to decorated function. Similar to ``set()``\",\n \"key_generator(*arg, **kw) value = fn(*arg, **kw) self.set(key, value) return value decorate.set = set_\",\n \"as value: return value def get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a\",\n \"key with no associated value will always block; async_creator will not be invoked.\",\n \"not. If it can't, it means a different thread or process is already\",\n \"Python function ``str``, which can be used to convert non-string or Unicode keys\",\n \"self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure(\",\n \"CachedValue from .proxy import ProxyBackend from ..util import compat import time import datetime\",\n \"be applied in a chain to ultimately wrap the original backend, so that\",\n \"**kw): return my_data() .. seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` - optional\",\n \"non-ascii unicode arguments on Python 2.x, the ``unicode()`` builtin can be substituted, but\",\n \"value is None, it won't be cached. .. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments`\",\n \"): \\\"\\\"\\\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned. :param backend: Required. This\",\n \"get_multi(self, keys, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return multiple values from the cache, based on the\",\n \"to acquire the dogpile lock to generate a new value, or will wait\",\n \"the function. See that method for additional behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x,\",\n \":class:`.CacheRegion`. Once set, the invalidation time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and\",\n \"where data will be pulled from the cache region unless a new value\",\n \"**kw) self.set(key, value) def get(*arg, **kw): key = key_generator(*arg, **kw) return self.get(key) def\",\n \"key_generator = function_key_generator(namespace, fn) else: key_generator = function_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def\",\n \"return my_data() .. seealso:: :func:`.function_key_generator` - default key generator :func:`.kwarg_function_key_generator` - optional gen\",\n \"value of the function using a key derived from the function itself and\",\n \"function_multi_key_generator self.key_mangler = self._user_defined_key_mangler = key_mangler self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def\",\n \"use, and is resolved by loading the class from the ``dogpile.cache`` entrypoint. :param\",\n \":meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is None: function_key_generator = self.function_key_generator def\",\n \"a callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This function is given a value\",\n \"the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports both \\\"hard\\\" and \\\"soft\\\"\",\n \"back before the expiration time so that a return+regen will be invoked. ..\",\n \"True else: return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create, timeout, wrap_cache_fn) result =\",\n \"arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method. The structure of this function should be\",\n \":param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable, will be\",\n \"See that method for additional behavioral details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works\",\n \"= key_generator(*arg) values = fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for a in\",\n \"\\\" \\\"for soft invalidation\\\") if expiration_time == -1: expiration_time = None if self.async_creation_runner:\",\n \"def set_(value, *arg, **kw): key = key_generator(*arg, **kw) self.set(key, value) def get(*arg, **kw):\",\n \"import function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue from .proxy import ProxyBackend from\",\n \"__init__(self, region): self.region = region # ... # ... region = CacheRegion() region\",\n \"invalidated in soft mode. \\\"\\\"\\\" raise NotImplementedError() def was_hard_invalidated(self): \\\"\\\"\\\"Indicate the region was\",\n \"0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True, the existing cache backend will\",\n \"expiration_time is None: expiration_time = self.expiration_time if (expiration_time is None and self.region_invalidator.was_soft_invalidated()): raise\",\n \"versionadded:: 0.5.1 \\\"\\\"\\\" return 'backend' in self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return\",\n \"used on all incoming keys before passing to the backend. Defaults to ``None``,\",\n \"be retrieved. :param creator: function which accepts a sequence of keys and returns\",\n \"else: if expiration_time is None: expiration_time = self.expiration_time current_time = time.time() def value_fn(value):\",\n \"function. The default key generation will use the name of the function, the\",\n \"logic won't be used. If False, the creation time of existing values will\",\n \"0.5.0 :param function_multi_key_generator: a function that will produce a list of keys. This\",\n \"timeout, wrap_cache_fn) result = dict( (k, v) for k, v in zip(cache_keys, result)\",\n \"a :class:`.CacheBackend` or :class:`.ProxyBackend` that modifies values, take note this function invokes ``.set_multi()``\",\n \"For a specific example using async_creation_runner, new values can be created in a\",\n \"compat.string_type: # backwards compatible key_generator = function_key_generator(namespace, fn) else: key_generator = function_key_generator( namespace,\",\n \"is returned. :param backend: Required. This is the name of the :class:`.CacheBackend` to\",\n \"Optional. The expiration time passed to the dogpile system. May be passed as\",\n \"proxy = proxy() if not issubclass(type(proxy), ProxyBackend): raise TypeError(\\\"Type %s is not a\",\n \"if asdict: self.set_multi( dict(zip(keys, [values[a] for a in arg])) ) return values else:\",\n \"soft mode. \\\"\\\"\\\" raise NotImplementedError() def is_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if\",\n \"returned, but isn't cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" def\",\n \"\\\"\\\"\\\"A function decorator that will cache the return value of the function using\",\n \"expiration time check. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not keys: return [] if\",\n \"region_invalidator return self def wrap(self, proxy): ''' Takes a ProxyBackend instance or class\",\n \"name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \\\"\\\"\\\"Construct a new :class:`.CacheRegion`.\\\"\\\"\\\" self.name = name\",\n \"function # decorators, but not yet for actual caching # later, when config\",\n \"method for additional behavioral details. E.g.:: @someregion.cache_on_arguments() def generate_something(x, y): return somedatabase.query(x, y)\",\n \"\\\"soft\\\" invalidation, subsequent getters will return the \\\"old\\\" value until the new one\",\n \"a function that will produce a \\\"cache key\\\". This function will supersede the\",\n \"sort the keys, the idea is to prevent deadlocks. # though haven't been\",\n \"retrieved. :param creator: function which accepts a sequence of keys and returns a\",\n \"the cache. This operation is idempotent (can be called multiple times, or on\",\n \"keys using a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of\",\n \"used. If False, the creation time of existing values will be pushed back\",\n \"keys)) ) def get(*arg): keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys =\",\n \"finally: mutex.release() thread = threading.Thread(target=runner) thread.start() region = make_region( async_creation_runner=async_creation_runner, ).configure( 'dogpile.cache.memcached', expiration_time=5,\",\n \"pushed back before the expiration time so that a return+regen will be invoked.\",\n \"this function should be two levels: given the data creation function, return a\",\n \"invalidated. :return: Boolean. True if ``timestamp`` is older than the last region invalidation\",\n \"fn, **kw): fname = fn.__name__ def generate_key(*arg): return namespace + \\\"_\\\" + fname\",\n \"a task manager system like Celery. For a specific example using async_creation_runner, new\",\n \"augmentation can be applied. .. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if\",\n \"6) Another attribute ``set()`` is added to provide extra caching possibilities relative to\",\n \"specified as a callable, taking no arguments, that returns a value to be\",\n \"backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \\\"\\\"\\\"Configure a :class:`.CacheRegion`. The\",\n \"key if self.key_mangler: key = self.key_mangler(key) def get_value(): value = self.backend.get(key) if (value\",\n \"a cache key. Given a function ``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\\\"foo\\\") def\",\n \"the new value, as well as returning that value:: newvalue = generate_something.refresh(5, 6)\",\n \"on each function argument in order to convert to a string. Defaults to\",\n \"function_multi_key_generator is None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace, fn,\",\n \"the *dogpile lock* can be acquired or not. If it can't, it means\",\n \"was_hard_invalidated(self): return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated() and self.is_invalidated(timestamp) def\",\n \"Lock( self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass try:\",\n \"will store a given value directly without calling the decorated function. The value\",\n \"cache and conditionally call the function. See that method for additional behavioral details.\",\n \"callable function which will receive the value returned by the \\\"creator\\\", and will\",\n \"the effect of deleting the given sequence of keys using the same mechanism\",\n \"but its creation time is older than the current invalidation time, the ``NO_VALUE``\",\n \"a mapping of keys and values to set in the cache:: generate_something.set({\\\"k1\\\": \\\"value1\\\",\",\n \"cache. This operation is idempotent (can be called multiple times, or on a\",\n \"coerce_string_conf(config_dict) return self.configure( config_dict[\\\"%sbackend\\\" % prefix], expiration_time=config_dict.get( \\\"%sexpiration_time\\\" % prefix, None), _config_argument_dict=config_dict, _config_prefix=\\\"%sarguments.\\\"\",\n \"key. If the value is not present, the method returns the token ``NO_VALUE``.\",\n \"class declaration mechanics otherwise prevent the decorator from having awareness of the ``MyClass``\",\n \"also interprets the cached value in terms of the current \\\"invalidation\\\" time as\",\n \"current invalidation time, the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses\",\n \"supports both \\\"hard\\\" and \\\"soft\\\" invalidation options. With \\\"hard\\\" invalidation, :meth:`.CacheRegion.get_or_create` will force\",\n \"self._value(value)) def set_multi(self, mapping): \\\"\\\"\\\"Place new values in the cache under the given\",\n \"returns either the value cached for the given key, or the token ``NO_VALUE``\",\n \"cache keys using a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the name\",\n \"from . import exception from ..util import PluginLoader, memoized_property, coerce_string_conf from .util import\",\n \"\\\"two\\\", \\\"three\\\"] values = region.get_multi(keys) dictionary = dict(zip(keys, values)) Keys which aren't present\",\n \"self.delete(key) def set_(value, *arg, **kw): key = key_generator(*arg, **kw) self.set(key, value) def get(*arg,\",\n \"two levels: given the data creation function, return a new function that generates\",\n \"however if the return value is None, it won't be cached. .. versionadded::\",\n \"= key_generator(*arg, **kw) self.delete(key) def set_(value, *arg, **kw): key = key_generator(*arg, **kw) self.set(key,\",\n \"older than the last call to :meth:`.invalidate`. :param key: Key to be retrieved.\",\n \"return lambda value: value else: if expiration_time is None: expiration_time = self.expiration_time current_time\",\n \"matching the keys given. E.g.:: values = region.get_multi([\\\"one\\\", \\\"two\\\", \\\"three\\\"]) To convert values\",\n \"the value of create_value() if the cache is invalid, however if the return\",\n \"\\\"Specify replace_existing_backend=True to replace.\\\" % self.backend) backend_cls = _backend_loader.load(backend) if _config_argument_dict: self.backend =\",\n \"can be accessed via the ``.name`` parameter, helpful for configuring a region from\",\n \"added to provide extra caching possibilities relative to the function. This is a\",\n \"to ``function_key_generator`` parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list\",\n \"NO_VALUE) else: result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result def invalidate(*arg):\",\n \"\\\"cache.local.backend\\\":\\\"dogpile.cache.dbm\\\", \\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\", \\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\", \\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1, 10.0.0.1\\\", } local_region.configure_from_config(myconfig, \\\"cache.local.\\\") memcached_region.configure_from_config(myconfig, \\\"cache.memcached.\\\") \\\"\\\"\\\" config_dict =\",\n \"of the value. Pass to ``invalidate()`` the same arguments you'd pass to the\",\n \"Remember that the first request for a key with no associated value will\",\n \"to decorated function. Similar to ``set()`` is ``refresh()``. This attribute will invoke the\",\n \"wrap: Optional. A list of :class:`.ProxyBackend` classes and/or instances, each of which will\",\n \"and is also local to this instance of :class:`.CacheRegion`. Once set, the invalidation\",\n \"value is returned from the cache if present, regardless of configured expiration times\",\n \"0.5.0 \\\"\\\"\\\" if not keys: return [] if self.key_mangler: keys = list(map(lambda key:\",\n \"the method will block if no previous value is available, until the lock\",\n \"no expiration, use the value -1. :param should_cache_fn: optional callable function which will\",\n \"expiration_time=300, arguments={ \\\"filename\\\":\\\"file.dbm\\\" } ) The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's\",\n \"new values in the cache under the given keys. .. versionadded:: 0.5.0 \\\"\\\"\\\"\",\n \"compatible key_generator = function_key_generator(namespace, fn) else: key_generator = function_key_generator( namespace, fn, to_str=to_str) @wraps(fn)\",\n \"[ value.payload if value is not NO_VALUE else value for value in (\",\n \"- .0001 return value.payload, ct def gen_value(): raise NotImplementedError() def async_creator(key, mutex): mutexes[key]\",\n \"keys = key_generator(*arg) return self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values = fn(*arg)\",\n \"not NO_VALUE) else: result = self.get_or_create_multi( keys, creator, timeout, should_cache_fn) return result def\",\n \"integer placed in the :class:`.CachedValue` so that new versions of dogpile.cache can detect\",\n \"in sorted_unique_keys] else: mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys,\",\n \"within the same module, as can occur when decorating instance or class methods\",\n \"unicode cache keys which may require key mangling before reaching the cache. ..\",\n \"to ``str()``. If the function accepts non-ascii unicode arguments on Python 2.x, the\",\n \"\\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) value = self.backend.get(key) value = self._unexpired_value_fn( expiration_time,\",\n \"in mutexes.values(): mutex.release() def _value(self, value): \\\"\\\"\\\"Return a :class:`.CachedValue` given a value.\\\"\\\"\\\" return\",\n \"= fn.__name__ def generate_key(*arg): return namespace + \\\"_\\\" + fname + \\\"_\\\".join(str(s) for\",\n \"called normally, where data will be pulled from the cache region unless a\",\n \"the function is used depends on if the *dogpile lock* can be acquired\",\n \"If it returns False, the value is still returned, but isn't cached. ..\",\n \"it returns True will that value be placed in the cache. :param asdict:\",\n \"register_backend = _backend_loader.register from . import backends # noqa value_version = 1 \\\"\\\"\\\"An\",\n \"that will produce a list of keys. This function will supersede the one\",\n \"datetime from numbers import Number from functools import wraps import threading _backend_loader =\",\n \"bsddb or dbm under Python 2.x in conjunction with Unicode keys. :param async_creation_runner:\",\n \"based on the given keys. Returns values as a list matching the keys\",\n \"which creates a new value. :param expiration_time: optional expiration time which will overide\",\n \"asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \\\"\\\"\\\"A function decorator that will cache multiple return values from\",\n \"try: value = creator() cache.set(somekey, value) finally: mutex.release() thread = threading.Thread(target=runner) thread.start() region\",\n \"to and called by dogpile.lock when there is a stale value present in\",\n \"name of the function, the module name for the function, the arguments passed,\",\n \"With \\\"soft\\\" invalidation, subsequent getters will return the \\\"old\\\" value until the new\",\n \"if present, regardless of configured expiration times or whether or not :meth:`.invalidate` was\",\n \"key in keys ] The decorated function can be called normally. The decorator\",\n \"by the \\\"creator\\\", and will then return True or False, indicating if the\",\n \"not be invoked. However, subsequent requests for cached-but-expired values will still return promptly.\",\n \"or class methods as below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \\\"\\\"\",\n \"reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return self def wrap(self, proxy): '''\",\n \"self.region_invalidator.is_invalidated( value.metadata[\\\"ct\\\"]): return NO_VALUE else: return value return value_fn def get_multi(self, keys, expiration_time=None,\",\n \"caching possibilities relative to the function. This is a convenience method for :meth:`.CacheRegion.set`\",\n \"to the :class:`.CacheRegion` itself should construct the invalidator given the region as an\",\n \"type(proxy) == type: proxy = proxy() if not issubclass(type(proxy), ProxyBackend): raise TypeError(\\\"Type %s\",\n \"ProxyBackend from ..util import compat import time import datetime from numbers import Number\",\n \"in arg) return generate_key region = make_region( function_key_generator = my_key_generator ).configure( \\\"dogpile.cache.dbm\\\", expiration_time=300,\",\n \"classes and/or instances, each of which will be applied in a chain to\",\n \"in terms of the current \\\"invalidation\\\" time as set by the :meth:`.invalidate` method.\",\n \"key = self.key_mangler(key) def get_value(): value = self.backend.get(key) if (value is NO_VALUE or\",\n \"The value to be cached is passed as the first argument, and the\",\n \"\\\"\\\"\\\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`. See that\",\n \"new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`. See that class for\",\n \"def is_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was invalidated. :return: Boolean.\",\n \"True if ``timestamp`` is older than the last region invalidation time. \\\"\\\"\\\" raise\",\n \"mode. \\\"\\\"\\\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated = None self._invalidated =\",\n \"< self._invalidated) def was_hard_invalidated(self): return self._is_hard_invalidated is True def is_hard_invalidated(self, timestamp): return self.was_hard_invalidated()\",\n \"by loading the class from the ``dogpile.cache`` entrypoint. :param expiration_time: Optional. The expiration\",\n \"get_value, expiration_time, async_creator) as value: return value def get_or_create_multi( self, keys, creator, expiration_time=None,\",\n \"if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata['v'])): # dogpile.core\",\n \"will receive each value returned by the \\\"creator\\\", and will then return True\",\n \"value in the cache under the given key.\\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key)\",\n \"self.function_key_generator def decorator(fn): if to_str is compat.string_type: # backwards compatible key_generator = function_key_generator(namespace,\",\n \".0001 return value.payload, ct def gen_value(): created_value = creator() value = self._value(created_value) if\",\n \"was hard invalidated. :return: Boolean. True if ``timestamp`` is older than the last\",\n \"if region_invalidator: self.region_invalidator = region_invalidator return self def wrap(self, proxy): ''' Takes a\",\n \"to :meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace:\",\n \"@wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k] for k in keys_to_create]) timeout = expiration_time() if\",\n \"system works by setting a current timestamp (using ``time.time()``) to consider all older\",\n \"Above, the function returns the value of create_value() if the cache is invalid,\",\n \"``refresh()``. This attribute will invoke the decorated function and populate a new value\",\n \"or a task manager system like Celery. For a specific example using async_creation_runner,\",\n \"persist the newly generated value in the cache. Whether or not the function\",\n \"or on a non-existent key, safely) .. versionadded:: 0.5.0 \\\"\\\"\\\" if self.key_mangler: keys\",\n \":meth:`.CacheRegion.cache_multi_on_arguments` have the same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional\",\n \"from ..util import NameRegistry from . import exception from ..util import PluginLoader, memoized_property,\",\n \"finished. This can be used to defer the computation of expensive creator functions\",\n \"or isinstance(expiration_time, Number): self.expiration_time = expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time))\",\n \"than an instance then # initialize it. if type(proxy) == type: proxy =\",\n \"the ``NO_VALUE`` token. ``NO_VALUE`` evaluates to False, but is separate from ``None`` to\",\n \"mangled_keys = sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key,\",\n \"mapping = dict(( self.key_mangler(k), self._value(v)) for k, v in mapping.items()) else: mapping =\",\n \"sequence of keys using the same mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\\\"k1\\\", \\\"k2\\\",\",\n \"if function_multi_key_generator is None: function_multi_key_generator = self.function_multi_key_generator def decorator(fn): key_generator = function_multi_key_generator( namespace,\",\n \"< self._hard_invalidated) def was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp\",\n \"calling the decorated function will also be a list. When ``asdict==True`` if the\",\n \"backend(self): raise exception.RegionNotConfigured( \\\"No backend is configured on this region.\\\") @property def is_configured(self):\",\n \"creator() value = self._value(created_value) if not should_cache_fn or \\\\ should_cache_fn(created_value): self.backend.set(key, value) return\",\n \"cache with the new value, as well as returning that value:: newvalue =\",\n \"v in mapping.items()) else: mapping = dict((k, self._value(v)) for k, v in mapping.items())\",\n \"0.3.0 :param hard: if True, cache values will all require immediate regeneration; dogpile\",\n \"\\\"\\\"\\\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict, prefix): \\\"\\\"\\\"Configure from a configuration dictionary and a\",\n \"- .0001 return value.payload, ct def gen_value(): created_value = creator() value = self._value(created_value)\",\n \"expiration_time == -1: expiration_time = None if self.async_creation_runner: def async_creator(mutex): return self.async_creation_runner( self,\",\n \"False, the creation time of existing values will be pushed back before the\",\n \"key\\\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key)\",\n \"The cache key above for ``MyClass().one(3, 4)`` will again produce the same cache\",\n \"given the region as an argument:: class MyInvalidator(RegionInvalidationStrategy): def __init__(self, region): self.region =\",\n \"which will be established as part of each cache key. :param expiration_time: if\",\n \"def get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a sequence of cached values\",\n \"the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True`` bypasses the expiration time\",\n \"to be stale. It does not affect the data in the cache in\",\n \"an immediate regeneration of the value which all getters will wait for. With\",\n \"``one(3, 4)`` will produce a cache key as follows:: myapp.tools:one|foo|3 4 The key\",\n \"decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \\\"\\\"\\\" orig_key = key if self.key_mangler: key\",\n \"orig_key = key if self.key_mangler: key = self.key_mangler(key) def get_value(): value = self.backend.get(key)\",\n \":meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports both \\\"hard\\\" and \\\"soft\\\" invalidation options.\",\n \"cannot be acquired, the method will block if no previous value is available,\",\n \"is older than the last call to :meth:`.invalidate`. :param key: Key to be\",\n \"key = self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping): \\\"\\\"\\\"Place new values in the\",\n \"of each key. It will then consult the cache using the same mechanism\",\n \"the decorator from having awareness of the ``MyClass`` and ``MyOtherClass`` names, as the\",\n \"expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is None: function_key_generator = self.function_key_generator def decorator(fn): if\",\n \"a new :class:`.CacheRegion`.\\\"\\\"\\\" self.name = name self.function_key_generator = function_key_generator self.function_multi_key_generator = function_multi_key_generator self.key_mangler\",\n \"from being returned. The method will attempt to acquire the dogpile lock to\",\n \"self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn(\",\n \"by setting a current timestamp (using ``time.time()``) representing the \\\"minimum creation time\\\" for\",\n \"any form. For example, it can be passed as a tuple, used to\",\n \"value.metadata[\\\"ct\\\"] if expiration_time is None: expiration_time = self.expiration_time if (expiration_time is None and\",\n \"= time.time() - expiration_time - .0001 return value.payload, ct def gen_value(): raise NotImplementedError()\",\n \"uses the same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and set values\",\n \":param creator: function which accepts a sequence of keys and returns a sequence\",\n \"can then be called normally, where data will be pulled from the cache\",\n \"for the given key, or the token ``NO_VALUE`` if no such key exists::\",\n \"set in the cache:: generate_something.set({\\\"k1\\\": \\\"value1\\\", \\\"k2\\\": \\\"value2\\\", \\\"k3\\\": \\\"value3\\\"}) ...an ``invalidate()`` method,\",\n \"in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return self def wrap(self, proxy):\",\n \"cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \\\"\\\"\\\"A function decorator that will\",\n \"before reaching the cache. .. versionadded:: 0.5.0 :param function_multi_key_generator: a function that will\",\n \"value.payload if value is not NO_VALUE else value for value in ( _unexpired_value_fn(value)\",\n \"Number from functools import wraps import threading _backend_loader = PluginLoader(\\\"dogpile.cache\\\") register_backend = _backend_loader.register\",\n \"prevent deadlocks. # though haven't been able to simulate one anyway. keys_to_get =\",\n \"single function signature, one which takes a simple list of keys as arguments.\",\n \":func:`.kwarg_function_key_generator` - optional gen that also uses keyword arguments :param function_multi_key_generator: Optional. Similar\",\n \"bypasses the expiration time check. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not keys: return\",\n \"\\\"soft\\\" invalidation options. With \\\"hard\\\" invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate regeneration of\",\n \"def is_invalidated(self, timestamp): return (self._invalidated is not None and timestamp < self._invalidated) def\",\n \"this function invokes ``.set_multi()`` for newly generated values using the same values it\",\n \"set_multi(self, mapping): \\\"\\\"\\\"Place new values in the cache under the given keys. ..\",\n \"of configured expiration times or whether or not :meth:`.invalidate` was called. .. versionadded::\",\n \".. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" def get_value(key): value = values.get(key, NO_VALUE) if (value\",\n \"expiration_time=None, should_cache_fn=None): \\\"\\\"\\\"Return a sequence of cached values based on a sequence of\",\n \"def decorator(fn): if to_str is compat.string_type: # backwards compatible key_generator = function_key_generator(namespace, fn)\",\n \"= proxy() if not issubclass(type(proxy), ProxyBackend): raise TypeError(\\\"Type %s is not a valid\",\n \"an attribute ``invalidate()``, which provides for invalidation of the value. Pass to ``invalidate()``\",\n \"the given sequence of keys using the same mechanism as that of :meth:`.CacheRegion.delete_multi`::\",\n \"invalidation strategy interface Implement this interface and pass implementation instance to :meth:`.CacheRegion.configure` to\",\n \"also uses keyword arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but it's\",\n \"self.expiration_time current_time = time.time() def value_fn(value): if value is NO_VALUE: return value elif\",\n \"key\\\", create_value, should_cache_fn=dont_cache_none) Above, the function returns the value of create_value() if the\",\n \"``set()`` is added to provide extra caching possibilities relative to the function. This\",\n \"``.name`` parameter, helpful for configuring a region from a config file. :param function_key_generator:\",\n \"generation can be entirely replaced on a per-region basis using the ``function_key_generator`` argument\",\n \"mutex in mutexes.values(): mutex.release() def _value(self, value): \\\"\\\"\\\"Return a :class:`.CachedValue` given a value.\\\"\\\"\\\"\",\n \"determine a *dynamic* expiration time for the cached function result. Example use cases\",\n \"method is given a non-None expiration time. .. versionadded:: 0.3.0 :param hard: if\",\n \"cached. :param to_str: callable, will be called on each function argument in order\",\n \"of, for example, a background thread, a long-running queue, or a task manager\",\n \"of new values. :param expiration_time: optional expiration time which will overide the expiration\",\n \"if getattr(wrap, '__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator =\",\n \"\\\"creator\\\", and will then return True or False, indicating if the value should\",\n \"points in the future by way of, for example, a background thread, a\",\n \"_backend_loader.register from . import backends # noqa value_version = 1 \\\"\\\"\\\"An integer placed\",\n \"if True, cache values will all require immediate regeneration; dogpile logic won't be\",\n \"is considered to be expired based on its creation time, the given creation\",\n \"Added ``get()`` method to decorated function. The default key generation will use the\",\n \"works by setting a current timestamp (using ``time.time()``) representing the \\\"minimum creation time\\\"\",\n \"get and set values from the backend. If you are using a :class:`.CacheBackend`\",\n \"against the creation time of the retrieved value versus the current time (as\",\n \"+ b The cache key above for ``MyClass().one(3, 4)`` will again produce the\",\n \"\\\"\\\"\\\"Indicate the region was invalidated in soft mode. :return: Boolean. True if region\",\n \"be needed to disambiguate functions of the same name within the same source\",\n \"key_mangler=None, async_creation_runner=None, ): \\\"\\\"\\\"Construct a new :class:`.CacheRegion`.\\\"\\\"\\\" self.name = name self.function_key_generator = function_key_generator\",\n \"time is honored by the :meth:`.CacheRegion.get_or_create`, :meth:`.CacheRegion.get_or_create_multi` and :meth:`.CacheRegion.get` methods. The method supports\",\n \"elif not should_cache_fn: return True else: return should_cache_fn(value) result = self.get_or_create_multi( keys, dict_create,\",\n \"to the function. This is a convenience method for :meth:`.CacheRegion.set` which will store\",\n \"def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated and timestamp\",\n \"keys, creator, timeout, should_cache_fn) return result def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def\",\n \"def is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp < self._soft_invalidated) The custom implementation is\",\n \"the expiration time supplied by the ``expiration_time`` argument, is tested against the creation\",\n \"running a creation function for this key against the cache. When the dogpile\",\n \"the value's creation time against the expiration time, rather than returning the value\",\n \"or may not be used to recreate the value and persist the newly\",\n \"a sequence of new values. :param expiration_time: optional expiration time which will overide\",\n \"assembled into a new argument list, and the decorated function is then called\",\n \"required \\\" \\\"for soft invalidation\\\") if expiration_time == -1: expiration_time = None if\",\n \"the value -1. :param should_cache_fn: optional callable function which will receive each value\",\n \"is compat.string_type: # backwards compatible key_generator = function_key_generator(namespace, fn) else: key_generator = function_key_generator(\",\n \"is available. Usage of \\\"soft\\\" invalidation requires that the region or the method\",\n \"can be applied. .. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True,\",\n \"self.region_invalidator.was_soft_invalidated()): raise exception.DogpileCacheException( \\\"Non-None expiration time required \\\" \\\"for soft invalidation\\\") if expiration_time\",\n \"ct = time.time() - expiration_time - .0001 return value.payload, ct def gen_value(): raise\",\n \"= fn return decorate return decorator def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False,\",\n \"dict(zip(keys, cache_keys)) @wraps(fn) def creator(*keys_to_create): return fn(*[key_lookup[k] for k in keys_to_create]) timeout =\",\n \"Takes a ProxyBackend instance or class and wraps the attached backend. ''' #\",\n \"time against the expiration time, rather than returning the value unconditionally. The method\",\n \"( _unexpired_value_fn(value) for value in backend_values ) ] def get_or_create( self, key, creator,\",\n \"new function that generates the key based on the given arguments. Such as::\",\n \"function may be asked to generate any subset of the given keys. The\",\n \"key. Given a function ``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\\\"foo\\\") def one(a, b):\",\n \"return value is not None value = region.get_or_create(\\\"some key\\\", create_value, should_cache_fn=dont_cache_none) Above, the\",\n \"mechanism as that of :meth:`.CacheRegion.delete_multi`:: generate_something.invalidate(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...a ``refresh()`` method, which will\",\n \"modifies values, take note this function invokes ``.set_multi()`` for newly generated values using\",\n \"by the key_mangler function, if present. :param creator: function which creates a new\",\n \"def invalidate(self, hard=None): if hard: self._soft_invalidated = None self._hard_invalidated = time.time() else: self._soft_invalidated\",\n \"from the cache if present, regardless of configured expiration times or whether or\",\n \"default invalidation system works by setting a current timestamp (using ``time.time()``) representing the\",\n \"value): \\\"\\\"\\\"Place a new value in the cache under the given key.\\\"\\\"\\\" if\",\n \"self.set_multi( dict(zip(keys, values)) ) return values decorate.set = set_ decorate.invalidate = invalidate decorate.refresh\",\n \"return [ d_values.get(key_lookup[k], NO_VALUE) for k in keys] def wrap_cache_fn(value): if value is\",\n \"\\\"cache key\\\" given a data creation function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments`\",\n \"which will call the creation function, cache the new values, and return them::\",\n \"is not available\\\", e.g. # _has_value() will return False. return value.payload, 0 else:\",\n \"The method also interprets the cached value in terms of the current \\\"invalidation\\\"\",\n \"\\\"cache the result until the end of the day, week or time period\\\"\",\n \"certain date or time passes\\\". .. versionchanged:: 0.5.0 ``expiration_time`` may be passed as\",\n \"passed to ``creator()``, and ``creator()`` should return the generated values as a sequence\",\n \"and wraps the attached backend. ''' # if we were passed a type\",\n \"be specified as a callable, taking no arguments, that returns a value to\",\n \"for gen_key, key in zip(gen_keys, keys)) ) def get(*arg): keys = key_generator(*arg) return\",\n \"established as part of the cache key. This may be needed to disambiguate\",\n \"can be entirely replaced on a per-region basis using the ``function_key_generator`` argument present\",\n \"list of keys. This function will supersede the one configured on the :class:`.CacheRegion`\",\n \"list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in zip(gen_keys, keys))\",\n \"To set no expiration, use the value -1. :param should_cache_fn: optional callable function\",\n \"string form of each key. It will then consult the cache using the\",\n \"generation. :param arguments: Optional. The structure here is passed directly to the constructor\",\n \"that new versions of dogpile.cache can detect cached values from a previous, backwards-incompatible\",\n \"is considered to be stale. It does not affect the data in the\",\n \"effectively invalidated. \\\"\\\"\\\" raise NotImplementedError() def is_hard_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if\",\n \"given keys. .. versionadded:: 0.5.0 \\\"\\\"\\\" if not mapping: return if self.key_mangler: mapping\",\n \"either the value cached for the given key, or the token ``NO_VALUE`` if\",\n \"or \\\\ should_cache_fn(created_value): self.backend.set(key, value) return value.payload, value.metadata[\\\"ct\\\"] if expiration_time is None: expiration_time\",\n \"no such key exists:: value = generate_something.get(5, 6) .. versionadded:: 0.5.3 Added ``get()``\",\n \"generate_key region = make_region( function_key_generator = my_key_generator ).configure( \\\"dogpile.cache.dbm\\\", expiration_time=300, arguments={ \\\"filename\\\":\\\"file.dbm\\\" }\",\n \"<gh_stars>1000+ from __future__ import with_statement from .. import Lock, NeedRegenerationException from ..util import\",\n \"\\\"\\\"\\\" def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ): \\\"\\\"\\\"Construct a new\",\n \"expiration times or whether or not :meth:`.invalidate` was called. .. versionadded:: 0.3.0 \\\"\\\"\\\"\",\n \"below:: class MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \\\"\\\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def\",\n \"as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and set values from the backend. If\",\n \"case the key mangling function recommended by the cache backend will be used.\",\n \"is older than the last region invalidation time. \\\"\\\"\\\" raise NotImplementedError() def was_soft_invalidated(self):\",\n \"the function using a sequence of keys derived from the function itself and\",\n \"those keys will not be cached. :param to_str: callable, will be called on\",\n \"to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key = key_generator(*arg, **kw) @wraps(fn) def creator(): return\",\n \"one configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi`\",\n \"generate_key(*arg, **kw): return \\\":\\\".join( [kw[k] for k in namespace] + [str(x) for x\",\n \"with no associated value will always block; async_creator will not be invoked. However,\",\n \"value cached for the given key, or the token ``NO_VALUE`` if no such\",\n \"arguments={ \\\"filename\\\":\\\"file.dbm\\\" } ) The ``namespace`` is that passed to :meth:`.CacheRegion.cache_on_arguments`. It's not\",\n \"if expiration_time == -1: expiration_time = None mutexes = {} sorted_unique_keys = sorted(set(keys))\",\n \"value.\\\"\\\"\\\" return CachedValue( value, { \\\"ct\\\": time.time(), \\\"v\\\": value_version }) def set(self, key,\",\n \"for k, v in zip(cache_keys, result) if v is not NO_VALUE) else: result\",\n \"function is missing keys, those keys will not be cached. :param to_str: callable,\",\n \"for a in arg])) ) return values else: self.set_multi( dict(zip(keys, values)) ) return\",\n \"the first argument, and the arguments which would normally be passed to the\",\n \"the newly generated value in the cache. Whether or not the function is\",\n \"def async_creation_runner(cache, somekey, creator, mutex): ''' Used by dogpile.core:Lock when appropriate ''' def\",\n \":meth:`.CacheRegion.invalidate` method. :param key: Key to be retrieved. While it's typical for a\",\n \"function and populate a new value into the cache with the new value,\",\n \"at :func:`.sha1_mangle_key` which coerces keys into a SHA1 hash, so that the string\",\n \"seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_key_generator is None: function_key_generator =\",\n \"in hard mode. \\\"\\\"\\\" raise NotImplementedError() class DefaultInvalidationStrategy(RegionInvalidationStrategy): def __init__(self): self._is_hard_invalidated = None\",\n \"not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for\",\n \"a dictionary. :param wrap: Optional. A list of :class:`.ProxyBackend` classes and/or instances, each\",\n \"cache key. Given a function ``one`` inside the module ``myapp.tools``:: @region.cache_on_arguments(namespace=\\\"foo\\\") def one(a,\",\n \"a previous value is available, that value is returned immediately without blocking. If\",\n \"proxy() if not issubclass(type(proxy), ProxyBackend): raise TypeError(\\\"Type %s is not a valid ProxyBackend\\\"\",\n \"For example:: def my_multi_key_generator(namespace, fn, **kw): namespace = fn.__name__ + (namespace or '')\",\n \"levels: given the data creation function, return a new function that generates the\",\n \"options. With \\\"hard\\\" invalidation, :meth:`.CacheRegion.get_or_create` will force an immediate regeneration of the value\",\n \"key mangling, set to ``False``. Another typical mangler is the built-in Python function\",\n \"return if self.key_mangler: mapping = dict(( self.key_mangler(k), self._value(v)) for k, v in mapping.items())\",\n \"cache multiple return values from the function using a sequence of keys derived\",\n \"sequence of new values. :param expiration_time: optional expiration time which will overide the\",\n \":param key_mangler: Function which will be used on all incoming keys before passing\",\n \"the async_creation_runner feature. \\\"\\\"\\\" def __init__( self, name=None, function_key_generator=function_key_generator, function_multi_key_generator=function_multi_key_generator, key_mangler=None, async_creation_runner=None, ):\",\n \"a SHA1 hash, so that the string length is fixed. To disable all\",\n \"default key generation will use the name of the function, the module name\",\n \"entrypoint. :param expiration_time: Optional. The expiration time passed to the dogpile system. May\",\n \"to any function using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \\\"\\\"\\\" orig_key\",\n \"key, or the token ``NO_VALUE`` if no such key exists:: value = generate_something.get(5,\",\n \"``zip()``:: keys = [\\\"one\\\", \\\"two\\\", \\\"three\\\"] values = region.get_multi(keys) dictionary = dict(zip(keys, values))\",\n \"``timestamp`` is older than the last region invalidation time and region is invalidated\",\n \"a data creation function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method. The structure\",\n \"versionadded:: 0.4.1 Added ``set()`` method to decorated function. Similar to ``set()`` is ``refresh()``.\",\n \"Above, the ``namespace`` parameter disambiguates between ``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python class\",\n \"expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \\\"\\\"\\\"A function decorator that will cache multiple return\",\n \"dict(( self.key_mangler(k), self._value(v)) for k, v in mapping.items()) else: mapping = dict((k, self._value(v))\",\n \"= expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time\",\n \"optional callable function which will receive the value returned by the \\\"creator\\\", and\",\n \"in the :class:`.CachedValue` so that new versions of dogpile.cache can detect cached values\",\n \"multiple times, or on a non-existent key, safely) \\\"\\\"\\\" if self.key_mangler: key =\",\n \"cache key as follows:: myapp.tools:one|foo|3 4 The key generator will ignore an initial\",\n \":param name: Optional, a string name for the region. This isn't used internally\",\n \"time for the cached function result. Example use cases include \\\"cache the result\",\n \"of deleting the given sequence of keys using the same mechanism as that\",\n \"missing keys, those keys will not be cached. :param to_str: callable, will be\",\n \"accepts non-ascii unicode arguments on Python 2.x, the ``unicode()`` builtin can be substituted,\",\n \"the \\\"multiple key\\\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return\",\n \"the cache. :param asdict: if ``True``, the decorated function should return its result\",\n \"function that will produce a \\\"cache key\\\" given a data creation function and\",\n \"convert non-string or Unicode keys to bytestrings, which is needed when using a\",\n \"cache values will all require immediate regeneration; dogpile logic won't be used. If\",\n \"value based on the given key. If the value does not exist or\",\n \"it won't be cached. .. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies :meth:`.get_or_create`\",\n \"the decorated function will also be a dictionary. If left at its default\",\n \"cache under the given key.\\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.set(key, self._value(value)) def\",\n \"configured on the :class:`.CacheRegion` itself. .. versionadded:: 0.5.5 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \\\"\\\"\\\"\",\n \"return somedatabase.query(x, y) The decorated function can then be called normally, where data\",\n \"versionadded:: 0.5.1 \\\"\\\"\\\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict, prefix): \\\"\\\"\\\"Configure from a configuration dictionary\",\n \"method, which here accepts a mapping of keys and values to set in\",\n \"exception.ValidationError( 'expiration_time is not a number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler =\",\n \"a return+regen will be invoked. .. versionadded:: 0.5.1 \\\"\\\"\\\" self.region_invalidator.invalidate(hard) def configure_from_config(self, config_dict,\",\n \"self.lock.acquire(wait) def release(self): self.lock.release() def _create_mutex(self, key): mutex = self.backend.get_mutex(key) if mutex is\",\n \"@someregion.cache_on_arguments() def generate_something(x, y): return somedatabase.query(x, y) The decorated function can then be\",\n \"function argument in order to convert to a string. Defaults to ``str()``. If\",\n \"function can be called normally. The decorator will produce a list of cache\",\n \"to retrieve all current values; the originally passed keys corresponding to those values\",\n \"versus the current time (as reported by ``time.time()``). If stale, the cached value\",\n \"function may or may not be used to recreate the value and persist\",\n \"+ str(a) for a in args] return generate_keys :param key_mangler: Function which will\",\n \"if self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None,\",\n \"follow:: generate_something.set(3, 5, 6) The above example is equivalent to calling ``generate_something(5, 6)``,\",\n \"is returned. Passing the flag ``ignore_expiration=True`` bypasses the expiration time check. .. versionadded::\",\n \"fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable \\\\ else expiration_time return self.get_or_create(key, creator,\",\n \"will produce a list of cache keys using a mechanism similar to that\",\n \"\\\"\\\"\\\" orig_key = key if self.key_mangler: key = self.key_mangler(key) def get_value(): value =\",\n \"internally makes use of the :meth:`.CacheRegion.get_or_create` method to access the cache and conditionally\",\n \"details. Unlike the :meth:`.CacheRegion.cache_on_arguments` method, :meth:`.CacheRegion.cache_multi_on_arguments` works only with a single function signature,\",\n \"config_dict, prefix): \\\"\\\"\\\"Configure from a configuration dictionary and a prefix. Example:: local_region =\",\n \"config_dict = coerce_string_conf(config_dict) return self.configure( config_dict[\\\"%sbackend\\\" % prefix], expiration_time=config_dict.get( \\\"%sexpiration_time\\\" % prefix, None),\",\n \"with the new value, as well as returning that value:: newvalue = generate_something.refresh(5,\",\n \":param function_multi_key_generator: a function that will produce a list of keys. This function\",\n \"- expiration_time - .0001 return value.payload, ct def gen_value(): raise NotImplementedError() def async_creator(key,\",\n \"= expiration_time() if expiration_time_is_callable \\\\ else expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn) def\",\n \"will invoke the decorated function and populate a new value into the cache\",\n \"the creation function, cache the new values, and return them:: values = generate_something.refresh(\\\"k1\\\",\",\n \"timestamp < self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return (self._hard_invalidated and\",\n \"return 'backend' in self.__dict__ def get(self, key, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return a value from\",\n \"passed since the last generation. :param arguments: Optional. The structure here is passed\",\n \"The method uses the same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi` to get and\",\n \"list(map(lambda key: self.key_mangler(key), keys)) backend_values = self.backend.get_multi(keys) _unexpired_value_fn = self._unexpired_value_fn( expiration_time, ignore_expiration) return\",\n \"gen_key, key in zip(gen_keys, keys)) ) def get(*arg): keys = key_generator(*arg) return self.get_multi(keys)\",\n \"of keys and values to set in the cache:: generate_something.set({\\\"k1\\\": \\\"value1\\\", \\\"k2\\\": \\\"value2\\\",\",\n \"it becomes an instance method. The function key generation can be entirely replaced\",\n \"value is unconditionally regenerated if the creation time is older than the last\",\n \"def generate_keys(*args): return [namespace + ':' + str(a) for a in args] return\",\n \"the list are returned as the ``NO_VALUE`` token. ``NO_VALUE`` evaluates to False, but\",\n \"associated value will always block; async_creator will not be invoked. However, subsequent requests\",\n \"NameRegistry(self._create_mutex) if getattr(wrap, '__iter__', False): for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator\",\n \"key: Key to be retrieved. While it's typical for a key to be\",\n \"time, the given creation function may or may not be used to recreate\",\n \"callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`. This function is given a value as\",\n \".. versionadded:: 0.4.1 Added ``set()`` method to decorated function. Similar to ``set()`` is\",\n \"def generate_key(*arg): return namespace + \\\"_\\\" + fname + \\\"_\\\".join(str(s) for s in\",\n \"incoming keys before passing to the backend. Defaults to ``None``, in which case\",\n \"self.key_mangler: keys = list(map(lambda key: self.key_mangler(key), keys)) self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None,\",\n \"dict((k, self._value(v)) for k, v in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \\\"\\\"\\\"Remove a\",\n \"and/or instances, each of which will be applied in a chain to ultimately\",\n \"distinguish between a cached value of ``None``. By default, the configured expiration time\",\n \"function, the module name for the function, the arguments passed, as well as\",\n \"region was invalidated in soft mode. :return: Boolean. True if region was invalidated\",\n \"soft invalidation\\\") if expiration_time == -1: expiration_time = None mutexes = {} sorted_unique_keys\",\n \"and ``creator()`` should return the generated values as a sequence corresponding to the\",\n \"that value be placed in the cache. :param asdict: if ``True``, the decorated\",\n \"using a decorator. :meth:`.CacheRegion.get_or_create_multi` - multiple key/value version \\\"\\\"\\\" orig_key = key if\",\n \"it can't, it means a different thread or process is already running a\",\n \"invalidation time check. .. versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param key:\",\n \"after this time period has passed since the last generation. :param arguments: Optional.\",\n \"decorators, but not yet for actual caching # later, when config is available\",\n \"from .util import function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue from .proxy import\",\n \"%s is not a valid ProxyBackend\\\" % type(proxy)) self.backend = proxy.wrap(self.backend) def _mutex(self,\",\n \"to a dictionary, use ``zip()``:: keys = [\\\"one\\\", \\\"two\\\", \\\"three\\\"] values = region.get_multi(keys)\",\n \"of arguments. The returned result is a list:: result = generate_something(\\\"key1\\\", \\\"key2\\\", \\\"key3\\\")\",\n \"the ``namespace`` parameter disambiguates between ``somemethod`` on ``MyClass`` and ``MyOtherClass``. Python class declaration\",\n \"asked to generate any subset of the given keys. The list of keys\",\n \"using the same mechanism as that of :meth:`.CacheRegion.get_multi` to retrieve all current values;\",\n \"return value.payload, value.metadata[\\\"ct\\\"] if expiration_time is None: expiration_time = self.expiration_time if (expiration_time is\",\n \"suitable (with caveats) for use with instance or class methods. Given the example::\",\n \"@wraps(fn) def decorate(*arg, **kw): cache_keys = arg keys = key_generator(*arg, **kw) key_lookup =\",\n \"arguments={ 'url': '127.0.0.1:11211', 'distributed_lock': True, } ) Remember that the first request for\",\n \"normally, where data will be pulled from the cache region unless a new\",\n \"wrapper for threading.Lock\\\"\\\"\\\" def __init__(self): self.lock = threading.Lock() def acquire(self, wait=True): return self.lock.acquire(wait)\",\n \"\\\"\\\"\\\" raise NotImplementedError() def was_soft_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in soft mode.\",\n \"in soft mode. :return: Boolean. True if region was invalidated in soft mode.\",\n \"PluginLoader, memoized_property, coerce_string_conf from .util import function_key_generator, function_multi_key_generator from .api import NO_VALUE, CachedValue\",\n \"Sequence of keys to be retrieved. :param creator: function which accepts a sequence\",\n \"time period\\\" and \\\"cache until a certain date or time passes\\\". .. versionchanged::\",\n \":class:`.ProxyBackend` that modifies values, take note this function invokes ``.set_multi()`` for newly generated\",\n \"function should be two levels: given the data creation function, return a new\",\n \"multiple times, or on a non-existent key, safely) .. versionadded:: 0.5.0 \\\"\\\"\\\" if\",\n \"in caching or retrieving. Thus, this can be used to determine a *dynamic*\",\n \"name within the same source file, such as those associated with classes -\",\n \"decorator(fn): if to_str is compat.string_type: # backwards compatible key_generator = function_key_generator(namespace, fn) else:\",\n \"be passed as an integer or a callable. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create_multi`.\",\n \"return a new function that generates the key based on the given arguments.\",\n \"by whatever asynchronous means the provided async_creation_runner callable implements. By default the async_creation_runner\",\n \"be passed as a tuple, used to specify arguments to pluck from \\\\**kw::\",\n \"parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated function should return list of keys.\",\n \"function decorator that will cache the return value of the function using a\",\n \"expiration time, rather than returning the value unconditionally. The method also interprets the\",\n \"is older than the invalidation timestamp, the value is unconditionally prevented from being\",\n \"returns True will that value be placed in the cache. :param asdict: if\",\n \"same name within the same module, as can occur when decorating instance or\",\n \"function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method. The structure of this function\",\n \"in the cache. It will be passed the mutex and is responsible releasing\",\n \"def __init__(self): self._is_hard_invalidated = None self._invalidated = None def invalidate(self, hard=True): self._is_hard_invalidated =\",\n \"instance then # initialize it. if type(proxy) == type: proxy = proxy() if\",\n \"**kw): \\\"\\\"\\\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to :class:`.CacheRegion`. See\",\n \"the cache. Whether or not the function is used depends on if the\",\n \"retrieved value whose creation time is prior to this timestamp is considered to\",\n \"self._value(v)) for k, v in mapping.items()) self.backend.set_multi(mapping) def delete(self, key): \\\"\\\"\\\"Remove a value\",\n \"be retrieved. While it's typical for a key to be a string, it\",\n \"The key generator will ignore an initial argument of ``self`` or ``cls``, making\",\n \":param backend: Required. This is the name of the :class:`.CacheBackend` to use, and\",\n \"key = key_generator(*arg, **kw) value = fn(*arg, **kw) self.set(key, value) return value decorate.set\",\n \"based on the given arguments:: values = generate_something.get(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") .. versionadded:: 0.5.3\",\n \"``time.time()``) representing the \\\"minimum creation time\\\" for a value. Any retrieved value whose\",\n \"fn(*[key_lookup[k] for k in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\\\ else expiration_time\",\n \"whose creation time is prior to this timestamp is considered to be stale.\",\n \"as well as returning that value:: newvalue = generate_something.refresh(5, 6) .. versionadded:: 0.5.0\",\n \"integer number of seconds, or as a ``datetime.timedelta`` value. .. versionadded 0.5.0 ``expiration_time``\",\n \"decorated function. The default key generation will use the name of the function,\",\n \"be a list. When ``asdict==True`` if the dictionary returned by the decorated function\",\n \"new values, and return them:: values = generate_something.refresh(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\") ...and a ``get()``\",\n \"makes use of the :meth:`.CacheRegion.get_or_create_multi` method to access the cache and conditionally call\",\n \"it returns False, the value is still returned, but isn't cached. E.g.:: def\",\n \"_config_argument_dict, _config_prefix ) else: self.backend = backend_cls(arguments or {}) if not expiration_time or\",\n \"- multiple key/value version \\\"\\\"\\\" orig_key = key if self.key_mangler: key = self.key_mangler(key)\",\n \"set(self, key, value): \\\"\\\"\\\"Place a new value in the cache under the given\",\n \"dictionary. :param wrap: Optional. A list of :class:`.ProxyBackend` classes and/or instances, each of\",\n \"be pushed back before the expiration time so that a return+regen will be\",\n \"provide extra caching possibilities relative to the function. This is a convenience method\",\n \"was_hard_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated in hard mode. :return: Boolean. True if\",\n \"\\\"\\\"\\\" raise NotImplementedError() def is_soft_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was\",\n \"self.async_creation_runner = async_creation_runner self.region_invalidator = DefaultInvalidationStrategy() def configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None,\",\n \"invalidation, subsequent getters will return the \\\"old\\\" value until the new one is\",\n \"the given key.\\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping):\",\n \"unicode arguments on Python 2.x, the ``unicode()`` builtin can be substituted, but note\",\n \"\\\"_\\\".join(str(s) for s in arg) return generate_key region = make_region( function_key_generator = my_key_generator\",\n \"in a chain to ultimately wrap the original backend, so that custom functionality\",\n \"versionadded:: 0.5.3 Added ``get()`` method to decorated function. The default key generation will\",\n \"using the same values it returns to the calling function. A correct implementation\",\n \"= dict( (orig_to_mangled[k], self._value(v)) for k, v in zip(keys_to_get, new_values) ) if not\",\n \"the :class:`.CacheBackend` in use, though is typically a dictionary. :param wrap: Optional. A\",\n \"def generate_key(*arg, **kw): return \\\":\\\".join( [kw[k] for k in namespace] + [str(x) for\",\n \"Passing the flag ``ignore_expiration=True`` bypasses the invalidation time check. .. versionadded:: 0.3.0 Support\",\n \"b): return a + b The cache key above for ``MyClass().one(3, 4)`` will\",\n \"expiration_time_is_callable \\\\ else expiration_time return self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key\",\n \"it. This method is the \\\"multiple key\\\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method. Example::\",\n \"return self._is_hard_invalidated is False def is_soft_invalidated(self, timestamp): return self.was_soft_invalidated() and self.is_invalidated(timestamp) class CacheRegion(object):\",\n \"and :class:`.CacheRegion`. If defaults to :func:`.function_key_generator`. :param namespace: optional string argument which will\",\n \"value is present, but its creation time is older than the current invalidation\",\n \"If it returns False, the value is still returned, but isn't cached. E.g.::\",\n \"unconditionally prevented from being returned. The method will attempt to acquire the dogpile\",\n \"decorated function should return its result as a list of values, and the\",\n \"``creator()``, and ``creator()`` should return the generated values as a sequence corresponding to\",\n \"used. A typical mangler is the SHA1 mangler found at :func:`.sha1_mangle_key` which coerces\",\n \"return \\\":\\\".join( [kw[k] for k in namespace] + [str(x) for x in arg]\",\n \"the new value. .. versionchanged:: 0.3.0 The value is unconditionally regenerated if the\",\n \"configuring a region from a config file. :param function_key_generator: Optional. A function that\",\n \"will be replaced. Without this flag, an exception is raised if a backend\",\n \"import backends # noqa value_version = 1 \\\"\\\"\\\"An integer placed in the :class:`.CachedValue`\",\n \"wait for. With \\\"soft\\\" invalidation, subsequent getters will return the \\\"old\\\" value until\",\n \"``3`` as the value to be cached. .. versionadded:: 0.4.1 Added ``set()`` method\",\n \"**not** the :meth:`.CacheRegion.get` method) will call upon the value creation function after this\",\n \"arguments. Such as:: def my_key_generator(namespace, fn, **kw): fname = fn.__name__ def generate_key(*arg): return\",\n \"against the expiration time, rather than returning the value unconditionally. The method also\",\n \"new_values) ) if not should_cache_fn: self.backend.set_multi(values_w_created) else: self.backend.set_multi(dict( (k, v) for k, v\",\n \"versionadded:: 0.5.3 Added ``get()`` method to decorated function. Parameters passed to :meth:`.CacheRegion.cache_multi_on_arguments` have\",\n \"return result def invalidate(*arg): keys = key_generator(*arg) self.delete_multi(keys) def set_(mapping): keys = list(mapping)\",\n \"@property def is_configured(self): \\\"\\\"\\\"Return True if the backend has been configured via the\",\n \"MyClass(object): @region.cache_on_arguments(namespace='MC') def somemethod(self, x, y): \\\"\\\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x,\",\n \"+ \\\"_\\\".join(str(s) for s in arg) return generate_key region = make_region( function_key_generator =\",\n \"from having awareness of the ``MyClass`` and ``MyOtherClass`` names, as the function is\",\n \"asdict: if ``True``, the decorated function should return its result as a dictionary\",\n \"self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError( 'expiration_time is not a number or\",\n \"): pass try: if mutexes: # sort the keys, the idea is to\",\n \"flag ``ignore_expiration=True`` bypasses the invalidation time check. .. versionadded:: 0.3.0 Support for the\",\n \"= generate_something.refresh(5, 6) .. versionadded:: 0.5.0 Added ``refresh()`` method to decorated function. Lastly,\",\n \"decorated function. Lastly, the ``get()`` method returns either the value cached for the\",\n \":class:`.ProxyBackend` classes and/or instances, each of which will be applied in a chain\",\n \"names, as the function is received by the decorator before it becomes an\",\n \"of the :class:`.CacheBackend` in use, though is typically a dictionary. :param wrap: Optional.\",\n \"or dbm under Python 2.x in conjunction with Unicode keys. :param async_creation_runner: A\",\n \"non-None expiration time. .. versionadded:: 0.3.0 :param hard: if True, cache values will\",\n \"given key. If the value does not exist or is considered to be\",\n \"should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3 :param to_str: callable, will be called\",\n \"generated value in the cache. Whether or not the function is used depends\",\n \"should return its result as a dictionary of keys->values, and the final result\",\n \":meth:`.CacheRegion.cache_on_arguments`, the decorated function is also provided with a ``set()`` method, which here\",\n \"custom implementation is injected into a :class:`.CacheRegion` at configure time using the :paramref:`.CacheRegion.configure.region_invalidator`\",\n \"passing to the backend. Defaults to ``None``, in which case the key mangling\",\n \"The function is also given an attribute ``invalidate()``, which provides for invalidation of\",\n \"mutex) else: async_creator = None with Lock( self._mutex(key), gen_value, get_value, expiration_time, async_creator) as\",\n \"a list of cache keys using a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`,\",\n \"\\\"\\\"\\\" if self.key_mangler: key = self.key_mangler(key) self.backend.delete(key) def delete_multi(self, keys): \\\"\\\"\\\"Remove multiple values\",\n \":class:`.CacheRegion` if not None. To set no expiration, use the value -1. :param\",\n \"uses keyword arguments :param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but it's used\",\n \".. versionchanged:: 0.3.0 :meth:`.CacheRegion.get` now checks the value's creation time against the expiration\",\n \"still returned, but isn't cached. .. versionadded:: 0.5.0 .. seealso:: :meth:`.CacheRegion.cache_multi_on_arguments` :meth:`.CacheRegion.get_or_create` \\\"\\\"\\\"\",\n \"= sorted_unique_keys orig_to_mangled = dict(zip(sorted_unique_keys, mangled_keys)) values = dict(zip(mangled_keys, self.backend.get_multi(mangled_keys))) for orig_key, mangled_key\",\n \"generation will use the name of the function, the module name for the\",\n \"key_generator = function_key_generator( namespace, fn, to_str=to_str) @wraps(fn) def decorate(*arg, **kw): key = key_generator(*arg,\",\n \"values from the function using a sequence of keys derived from the function\",\n \"timeout = expiration_time() if expiration_time_is_callable \\\\ else expiration_time if asdict: def dict_create(*keys): d_values\",\n \"fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for a in arg])) ) return values\",\n \"a new function that generates the key based on the given arguments. Such\",\n \"cache key. This may be needed to disambiguate functions of the same name\",\n \"this function, so in fact can be of any form. For example, it\",\n \"def make_region(*arg, **kw): \\\"\\\"\\\"Instantiate a new :class:`.CacheRegion`. Currently, :func:`.make_region` is a passthrough to\",\n \"+ (namespace or '') def generate_keys(*args): return [namespace + ':' + str(a) for\",\n \"seealso:: :meth:`.CacheRegion.cache_on_arguments` :meth:`.CacheRegion.get_or_create_multi` \\\"\\\"\\\" expiration_time_is_callable = compat.callable(expiration_time) if function_multi_key_generator is None: function_multi_key_generator =\",\n \"time period has passed since the last generation. :param arguments: Optional. The structure\",\n \"region invalidation time. \\\"\\\"\\\" raise NotImplementedError() def was_soft_invalidated(self): \\\"\\\"\\\"Indicate the region was invalidated\",\n \"was_soft_invalidated(self): return bool(self._soft_invalidated) def is_soft_invalidated(self, timestamp): return (self._soft_invalidated and timestamp < self._soft_invalidated) The\",\n \"should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \\\"\\\"\\\"A function decorator that will cache multiple return values\",\n \"= self.key_mangler(key) self.backend.set(key, self._value(value)) def set_multi(self, mapping): \\\"\\\"\\\"Place new values in the cache\",\n \"returned by the \\\"creator\\\", and will then return True or False, indicating if\",\n \"to return the new value. .. versionchanged:: 0.3.0 The value is unconditionally regenerated\",\n \"\\\"key2\\\", \\\"key3\\\") The decorator internally makes use of the :meth:`.CacheRegion.get_or_create_multi` method to access\",\n \"of \\\"soft\\\" invalidation requires that the region or the method is given a\",\n \"0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param key: Key to be retrieved. While\",\n \"the value is still returned, but isn't cached. E.g.:: def dont_cache_none(value): return value\",\n \"mutex when finished. This can be used to defer the computation of expensive\",\n \"function, so can be of any type recognized by the backend or by\",\n \"They will be refreshed by whatever asynchronous means the provided async_creation_runner callable implements.\",\n \"the \\\"old\\\" value until the new one is available. Usage of \\\"soft\\\" invalidation\",\n \"available. If a previous value is available, that value is returned immediately without\",\n \"function. Similar to ``set()`` is ``refresh()``. This attribute will invoke the decorated function\",\n \"or class and wraps the attached backend. ''' # if we were passed\",\n \"expiration time so that a return+regen will be invoked. .. versionadded:: 0.5.1 \\\"\\\"\\\"\",\n \"def is_configured(self): \\\"\\\"\\\"Return True if the backend has been configured via the :meth:`.CacheRegion.configure`\",\n \"= self._unexpired_value_fn( expiration_time, ignore_expiration)(value) return value.payload def _unexpired_value_fn(self, expiration_time, ignore_expiration): if ignore_expiration: return\",\n \"cache key. :param expiration_time: if not None, will override the normal expiration time.\",\n \"False): for wrapper in reversed(wrap): self.wrap(wrapper) if region_invalidator: self.region_invalidator = region_invalidator return self\",\n \"\\\"cache.local.arguments.filename\\\":\\\"/path/to/dbmfile.dbm\\\", \\\"cache.memcached.backend\\\":\\\"dogpile.cache.pylibmc\\\", \\\"cache.memcached.arguments.url\\\":\\\"127.0.0.1, 10.0.0.1\\\", } local_region.configure_from_config(myconfig, \\\"cache.local.\\\") memcached_region.configure_from_config(myconfig, \\\"cache.memcached.\\\") \\\"\\\"\\\" config_dict = coerce_string_conf(config_dict)\",\n \"= my_key_generator ).configure( \\\"dogpile.cache.dbm\\\", expiration_time=300, arguments={ \\\"filename\\\":\\\"file.dbm\\\" } ) The ``namespace`` is that\",\n \"''' def runner(): try: value = creator() cache.set(somekey, value) finally: mutex.release() thread =\",\n \"k, v in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload for k in\",\n \"might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y')) def my_function(a, b, **kw): return my_data() ..\",\n \"example:: class MyClass(object): @region.cache_on_arguments(namespace=\\\"foo\\\") def one(self, a, b): return a + b The\",\n \"\\\"\\\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y): \\\"\\\" Above, the ``namespace`` parameter\",\n \"self.get_multi(keys) def refresh(*arg): keys = key_generator(*arg) values = fn(*arg) if asdict: self.set_multi( dict(zip(keys,\",\n \"reported by ``time.time()``). If stale, the cached value is ignored and the ``NO_VALUE``\",\n \"= self.backend.get(key) if (value is NO_VALUE or value.metadata['v'] != value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\\\"ct\\\"])):\",\n \":meth:`.CacheRegion.get_or_create` \\\"\\\"\\\" def get_value(key): value = values.get(key, NO_VALUE) if (value is NO_VALUE or\",\n \"of the keys. The method uses the same approach as :meth:`.Region.get_multi` and :meth:`.Region.set_multi`\",\n \"self._hard_invalidated)) def was_hard_invalidated(self): return bool(self._hard_invalidated) def is_hard_invalidated(self, timestamp): return (self._hard_invalidated and timestamp <\",\n \"creation time is older than the current invalidation time, the ``NO_VALUE`` token is\",\n \"self._mutex(mangled_key), gen_value, lambda: get_value(mangled_key), expiration_time, async_creator=lambda mutex: async_creator(orig_key, mutex) ): pass try: if\",\n \"been able to simulate one anyway. keys_to_get = sorted(mutexes) new_values = creator(*keys_to_get) values_w_created\",\n \"possibilities relative to the function. This is a convenience method for :meth:`.CacheRegion.set` which\",\n \"the ``unicode()`` builtin can be substituted, but note this will produce unicode cache\",\n \"retrieve all current values; the originally passed keys corresponding to those values which\",\n \"value: value else: if expiration_time is None: expiration_time = self.expiration_time current_time = time.time()\",\n \"cache. Whether or not the function is used depends on if the *dogpile\",\n \"0.3.0 :meth:`.CacheRegion.get` now checks the value's creation time against the expiration time, rather\",\n \"= [\\\"one\\\", \\\"two\\\", \\\"three\\\"] values = region.get_multi(keys) dictionary = dict(zip(keys, values)) Keys which\",\n \"correct implementation of ``.set_multi()`` will not modify values in-place on the submitted ``mapping``\",\n \"import threading def async_creation_runner(cache, somekey, creator, mutex): ''' Used by dogpile.core:Lock when appropriate\",\n \"This is the name of the :class:`.CacheBackend` to use, and is resolved by\",\n \"to consider all older timestamps effectively invalidated. \\\"\\\"\\\" raise NotImplementedError() def is_hard_invalidated(self, timestamp):\",\n \"to defer the computation of expensive creator functions to later points in the\",\n \"arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \\\"\\\"\\\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself\",\n \"the :class:`.CacheBackend` to use, and is resolved by loading the class from the\",\n \"The value is unconditionally regenerated if the creation time is older than the\",\n \"dont_cache_none(value): return value is not None value = region.get_or_create(\\\"some key\\\", create_value, should_cache_fn=dont_cache_none) Above,\",\n \"``refresh()`` method, which will call the creation function, cache the new values, and\",\n \"creation function and arguments, when using the :meth:`.CacheRegion.cache_on_arguments` method. The structure of this\",\n \"the current \\\"invalidation\\\" time as set by the :meth:`.invalidate` method. If a value\",\n \"value which all getters will wait for. With \\\"soft\\\" invalidation, subsequent getters will\",\n \"of the :meth:`.CacheRegion.get_or_create` method to access the cache and conditionally call the function.\",\n \"the expiration time so that a return+regen will be invoked. .. versionadded:: 0.5.1\",\n \"becomes an instance method. The function key generation can be entirely replaced on\",\n \"have the same meaning as those passed to :meth:`.CacheRegion.cache_on_arguments`. :param namespace: optional string\",\n \"else: ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct = time.time() - expiration_time - .0001\",\n \"the data in the cache in any way, and is also local to\",\n \"also local to this instance of :class:`.CacheRegion`. Once set, the invalidation time is\",\n \"we were passed a type rather than an instance then # initialize it.\",\n \"seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \\\"\\\"\\\" def invalidate(self, hard=True): \\\"\\\"\\\"Region invalidation. :class:`.CacheRegion` propagated call. The default\",\n \"... # ... region = CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 ..\",\n \"value is needed:: result = generate_something(5, 6) The function is also given an\",\n \"= fn(*arg) if asdict: self.set_multi( dict(zip(keys, [values[a] for a in arg])) ) return\",\n \"The :class:`.CacheRegion` itself is returned. :param backend: Required. This is the name of\",\n \"This can be used to defer the computation of expensive creator functions to\",\n \"will attempt to acquire the dogpile lock to generate a new value, or\",\n \":param namespace: optional string argument which will be established as part of each\",\n \"values = region.get_multi([\\\"one\\\", \\\"two\\\", \\\"three\\\"]) To convert values to a dictionary, use ``zip()``::\",\n \"cache in any way, and is also local to this instance of :class:`.CacheRegion`.\",\n \"expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \\\"\\\"\\\"A function decorator that will cache the return value\",\n \"def cache_multi_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, asdict=False, to_str=compat.string_type, function_multi_key_generator=None): \\\"\\\"\\\"A function decorator that\",\n \"all current values; the originally passed keys corresponding to those values which aren't\",\n \"parent class on a function as the class is being declared. :param expiration_time:\",\n \".. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True, the existing cache\",\n \"``MyClass().one(3, 4)`` will again produce the same cache key of ``myapp.tools:one|foo|3 4`` -\",\n \"class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y): \\\"\\\" Above, the ``namespace`` parameter disambiguates\",\n \"form. For example, it can be passed as a tuple, used to specify\",\n \"= invalidate decorate.refresh = refresh decorate.get = get decorate.original = fn return decorate\",\n \"be called normally, where data will be pulled from the cache region unless\",\n \"though haven't been able to simulate one anyway. keys_to_get = sorted(mutexes) new_values =\",\n \"or time passes\\\". .. versionchanged:: 0.5.0 ``expiration_time`` may be passed as a callable\",\n \"somekey, creator, mutex): ''' Used by dogpile.core:Lock when appropriate ''' def runner(): try:\",\n \"_mutex(self, key): return self._lock_registry.get(key) class _LockWrapper(object): \\\"\\\"\\\"weakref-capable wrapper for threading.Lock\\\"\\\"\\\" def __init__(self): self.lock\",\n \"\\\"\\\"\\\"Return True if the backend has been configured via the :meth:`.CacheRegion.configure` method already.\",\n \"the region or the method is given a non-None expiration time. .. versionadded::\",\n \"0 here as # \\\"the value is not available\\\", e.g. # _has_value() will\",\n \"self.backend.delete_multi(keys) def cache_on_arguments( self, namespace=None, expiration_time=None, should_cache_fn=None, to_str=compat.string_type, function_key_generator=None): \\\"\\\"\\\"A function decorator that\",\n \"def get_value(): value = self.backend.get(key) if (value is NO_VALUE or value.metadata['v'] != value_version\",\n \"myapp.tools:one|foo|3 4 The key generator will ignore an initial argument of ``self`` or\",\n \"as that of :meth:`.CacheRegion.get_multi` to retrieve all current values; the originally passed keys\",\n \"final result of calling the decorated function will also be a dictionary. If\",\n \"request for a key with no associated value will always block; async_creator will\",\n \"will return values based on the given arguments:: values = generate_something.get(\\\"k1\\\", \\\"k2\\\", \\\"k3\\\")\",\n \"[values[a] for a in arg])) ) return values else: self.set_multi( dict(zip(keys, values)) )\",\n \"expiration_time: Optional. The expiration time passed to the dogpile system. May be passed\",\n \"``.set_multi()`` will not modify values in-place on the submitted ``mapping`` dict. :param keys:\",\n \"call to :meth:`.invalidate`. :param key: Key to be retrieved. While it's typical for\",\n \"be applied. .. versionadded:: 0.5.0 .. seealso:: :ref:`changing_backend_behavior` :param replace_existing_backend: if True, the\",\n \"the current invalidation time, the ``NO_VALUE`` token is returned. Passing the flag ``ignore_expiration=True``\",\n \"as a callable to :meth:`.CacheRegion.cache_on_arguments`. :param should_cache_fn: passed to :meth:`.CacheRegion.get_or_create`. .. versionadded:: 0.4.3\",\n \"True, cache values will all require immediate regeneration; dogpile logic won't be used.\",\n \"values)) Keys which aren't present in the list are returned as the ``NO_VALUE``\",\n \"return self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key)\",\n \"0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \\\"\\\"\\\" def invalidate(self, hard=True): \\\"\\\"\\\"Region invalidation. :class:`.CacheRegion` propagated call.\",\n \"import NameRegistry from . import exception from ..util import PluginLoader, memoized_property, coerce_string_conf from\",\n \"determine if it was invalidated. :return: Boolean. True if ``timestamp`` is older than\",\n \"a \\\"cache key\\\" given a data creation function and arguments, when using the\",\n \"any way, and is also local to this instance of :class:`.CacheRegion`. Once set,\",\n \"new values. :param expiration_time: optional expiration time which will overide the expiration time\",\n \"found at :func:`.sha1_mangle_key` which coerces keys into a SHA1 hash, so that the\",\n \"self.expiration_time = expiration_time elif isinstance(expiration_time, datetime.timedelta): self.expiration_time = int( compat.timedelta_total_seconds(expiration_time)) else: raise exception.ValidationError(\",\n \"the value cached for the given key, or the token ``NO_VALUE`` if no\",\n \"keys corresponding to those values which aren't generated or need regeneration will be\",\n \"an instance then # initialize it. if type(proxy) == type: proxy = proxy()\",\n \"has the effect of deleting the given sequence of keys using the same\",\n \"None, it won't be cached. .. versionadded:: 0.4.3 .. seealso:: :meth:`.CacheRegion.cache_on_arguments` - applies\",\n \"to_str: callable, will be called on each function argument in order to convert\",\n \"in keys_to_create]) timeout = expiration_time() if expiration_time_is_callable \\\\ else expiration_time if asdict: def\",\n \"not replace_existing_backend: raise exception.RegionAlreadyConfigured( \\\"This region is already \\\" \\\"configured with backend: %s.\",\n \"configure( self, backend, expiration_time=None, arguments=None, _config_argument_dict=None, _config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \\\"\\\"\\\"Configure a\",\n \"raised if a backend is already configured. .. versionadded:: 0.5.7 :param region_invalidator: Optional.\",\n \"self._soft_invalidated = time.time() self._hard_invalidated = None def is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp\",\n \"block; async_creator will not be invoked. However, subsequent requests for cached-but-expired values will\",\n \"used to convert non-string or Unicode keys to bytestrings, which is needed when\",\n \"self.get_or_create(key, creator, timeout, should_cache_fn) def invalidate(*arg, **kw): key = key_generator(*arg, **kw) self.delete(key) def\",\n \"timestamps effectively invalidated. \\\"\\\"\\\" raise NotImplementedError() def is_hard_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine\",\n \"(k, v) for k, v in values_w_created.items() if should_cache_fn(v[0]) )) values.update(values_w_created) return [values[orig_to_mangled[k]].payload\",\n \"will also be a list. When ``asdict==True`` if the dictionary returned by the\",\n \"has been configured via the :meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1 \\\"\\\"\\\" return\",\n \"= CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region)) .. versionadded:: 0.6.2 .. seealso:: :paramref:`.CacheRegion.configure.region_invalidator` \\\"\\\"\\\" def\",\n \"internally makes use of the :meth:`.CacheRegion.get_or_create_multi` method to access the cache and conditionally\",\n \"x, y): \\\"\\\" class MyOtherClass(object): @region.cache_on_arguments(namespace='MOC') def somemethod(self, x, y): \\\"\\\" Above, the\",\n \"False elif not should_cache_fn: return True else: return should_cache_fn(value) result = self.get_or_create_multi( keys,\",\n \"until the lock is released and a new value available. If a previous\",\n \"versionadded:: 0.5.0 \\\"\\\"\\\" if not mapping: return if self.key_mangler: mapping = dict(( self.key_mangler(k),\",\n \"and a new value available. If a previous value is available, that value\",\n \"def is_soft_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was soft invalidated. :return:\",\n \"access the cache and conditionally call the function. See that method for additional\",\n \"Without this flag, an exception is raised if a backend is already configured.\",\n \"will then consult the cache using the same mechanism as that of :meth:`.CacheRegion.get_multi`\",\n \"wrap=config_dict.get( \\\"%swrap\\\" % prefix, None), ) @memoized_property def backend(self): raise exception.RegionNotConfigured( \\\"No backend\",\n \":meth:`.CacheRegion.get_or_create` method as well as the :meth:`.CacheRegion.cache_on_arguments` decorator (though note: **not** the :meth:`.CacheRegion.get`\",\n \"replace_existing_backend=False, region_invalidator=None ): \\\"\\\"\\\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned. :param backend:\",\n \"if function_key_generator is None: function_key_generator = self.function_key_generator def decorator(fn): if to_str is compat.string_type:\",\n \"to it. This method is the \\\"multiple key\\\" analogue to the :meth:`.CacheRegion.cache_on_arguments` method.\",\n \"be accessed via the ``.name`` parameter, helpful for configuring a region from a\",\n \"instance of :class:`.CacheRegion`. Once set, the invalidation time is honored by the :meth:`.CacheRegion.get_or_create`,\",\n \"getters will wait for. With \\\"soft\\\" invalidation, subsequent getters will return the \\\"old\\\"\",\n \"produce the value ``3`` as the value to be cached. .. versionadded:: 0.4.1\",\n \"@wraps(fn) def creator(): return fn(*arg, **kw) timeout = expiration_time() if expiration_time_is_callable \\\\ else\",\n \"can be used to convert non-string or Unicode keys to bytestrings, which is\",\n \"def gen_value(): created_value = creator() value = self._value(created_value) if not should_cache_fn or \\\\\",\n \"...and a ``get()`` method, which will return values based on the given arguments::\",\n \"mutex) ): pass try: if mutexes: # sort the keys, the idea is\",\n \"be used on all incoming keys before passing to the backend. Defaults to\",\n \"_config_prefix=None, wrap=None, replace_existing_backend=False, region_invalidator=None ): \\\"\\\"\\\"Configure a :class:`.CacheRegion`. The :class:`.CacheRegion` itself is returned.\",\n \"When the dogpile lock cannot be acquired, the method will block if no\",\n \"will be assembled into a new argument list, and the decorated function is\",\n \"NO_VALUE, CachedValue from .proxy import ProxyBackend from ..util import compat import time import\",\n \"generator will ignore an initial argument of ``self`` or ``cls``, making the decorator\",\n \"the built-in Python function ``str``, which can be used to convert non-string or\",\n \":param expiration_time: if not None, will override the normal expiration time. May be\",\n \"of the retrieved value versus the current time (as reported by ``time.time()``). If\",\n \"= list(mapping) gen_keys = key_generator(*keys) self.set_multi(dict( (gen_key, mapping[key]) for gen_key, key in zip(gen_keys,\",\n \"arg] ) return generate_key Where the decorator might be used as:: @my_region.cache_on_arguments(namespace=('x', 'y'))\",\n \"into a new argument list, and the decorated function is then called with\",\n \"setting a current timestamp (using ``time.time()``) to consider all older timestamps effectively invalidated.\",\n \"default invalidation strategy with custom implementation of :class:`.RegionInvalidationStrategy`. .. versionadded:: 0.6.2 \\\"\\\"\\\" if\",\n \"self._invalidated = None def invalidate(self, hard=True): self._is_hard_invalidated = bool(hard) self._invalidated = time.time() def\",\n \"is also given an attribute ``invalidate()``, which provides for invalidation of the value.\",\n \"0.5.0 :param function_key_generator: a function that will produce a \\\"cache key\\\". This function\",\n \"A typical mangler is the SHA1 mangler found at :func:`.sha1_mangle_key` which coerces keys\",\n \"so can be of any type recognized by the backend or by the\",\n \"with classes - note that the decorator itself can't see the parent class\",\n \"stale. It does not affect the data in the cache in any way,\",\n \"# regions are ready to use for function # decorators, but not yet\",\n \"raise NotImplementedError() def is_invalidated(self, timestamp): \\\"\\\"\\\"Check timestamp to determine if it was invalidated.\",\n \"self.region = region # ... # ... region = CacheRegion() region = region.configure(region_invalidator=MyInvalidator(region))\",\n \"raise NotImplementedError() def async_creator(key, mutex): mutexes[key] = mutex if expiration_time is None: expiration_time\",\n \"else: self.set_multi( dict(zip(keys, values)) ) return values decorate.set = set_ decorate.invalidate = invalidate\",\n \"creation function may or may not be used to recreate the value and\",\n \"def set_multi(self, mapping): \\\"\\\"\\\"Place new values in the cache under the given keys.\",\n \"if expiration_time_is_callable \\\\ else expiration_time if asdict: def dict_create(*keys): d_values = creator(*keys) return\",\n \"via the :meth:`.CacheRegion.configure` method already. .. versionadded:: 0.5.1 \\\"\\\"\\\" return 'backend' in self.__dict__\",\n \"def get(self, key, expiration_time=None, ignore_expiration=False): \\\"\\\"\\\"Return a value from the cache, based on\",\n \"aren't generated or need regeneration will be assembled into a new argument list,\",\n \"between a cached value of ``None``. By default, the configured expiration time of\",\n \"convert values to a dictionary, use ``zip()``:: keys = [\\\"one\\\", \\\"two\\\", \\\"three\\\"] values\",\n \"method. Example:: @someregion.cache_multi_on_arguments() def generate_something(*keys): return [ somedatabase.query(key) for key in keys ]\",\n \"time check. .. versionadded:: 0.3.0 Support for the :meth:`.CacheRegion.invalidate` method. :param key: Key\",\n \"a 0 here as # \\\"the value is not available\\\", e.g. # _has_value()\",\n \"is_invalidated(self, timestamp): return ((self._soft_invalidated and timestamp < self._soft_invalidated) or (self._hard_invalidated and timestamp <\",\n \"time of the :class:`.CacheRegion`, or alternatively the expiration time supplied by the ``expiration_time``\",\n \"that of :meth:`.CacheRegion.cache_on_arguments`, combining the name of the function with the optional namespace\",\n \"based on keys corresponds to that of :meth:`.Region.get_or_create`, with the exception that the\",\n \":param function_multi_key_generator: Optional. Similar to ``function_key_generator`` parameter, but it's used in :meth:`.CacheRegion.cache_multi_on_arguments`. Generated\",\n \"*dogpile lock* can be acquired or not. If it can't, it means a\",\n \"Another typical mangler is the built-in Python function ``str``, which can be used\",\n \"def my_key_generator(namespace, fn, **kw): fname = fn.__name__ def generate_key(*arg): return namespace + \\\"_\\\"\",\n \"namespace] + [str(x) for x in arg] ) return generate_key Where the decorator\",\n \"= region.get_multi([\\\"one\\\", \\\"two\\\", \\\"three\\\"]) To convert values to a dictionary, use ``zip()``:: keys\",\n \":ref:`changing_backend_behavior` :param replace_existing_backend: if True, the existing cache backend will be replaced. Without\",\n \"and called by dogpile.lock when there is a stale value present in the\",\n \"region or the method is given a non-None expiration time. .. versionadded:: 0.3.0\",\n \"number or timedelta.') if not self._user_defined_key_mangler: self.key_mangler = self.backend.key_mangler self._lock_registry = NameRegistry(self._create_mutex) if\",\n \"this region.\\\") @property def is_configured(self): \\\"\\\"\\\"Return True if the backend has been configured\",\n \":class:`.CacheRegion` itself is returned. :param backend: Required. This is the name of the\",\n \"does not exist or is considered to be expired based on its creation\",\n \"still returned, but isn't cached. E.g.:: def dont_cache_none(value): return value is not None\",\n \"!= value_version or self.region_invalidator.is_hard_invalidated( value.metadata[\\\"ct\\\"])): raise NeedRegenerationException() ct = value.metadata[\\\"ct\\\"] if self.region_invalidator.is_soft_invalidated(ct): ct\",\n \"of cache keys using a mechanism similar to that of :meth:`.CacheRegion.cache_on_arguments`, combining the\",\n \"itself is returned. :param backend: Required. This is the name of the :class:`.CacheBackend`\",\n \"in use, though is typically a dictionary. :param wrap: Optional. A list of\",\n \"result) if v is not NO_VALUE) else: result = self.get_or_create_multi( keys, creator, timeout,\"\n]","isConversational":false}}},{"rowIdx":494,"cells":{"ngram":{"kind":"list like","value":["Deze functie voert alle versies uit zodat deze vergeleken kunnen worden qua timing.","= import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if __name__ == \"__main__\":","-*- \"\"\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \"\"\" import projectparallelprogrammeren def","de simulatie importeren en achtereenvolgens uitvoeren. version = f\"montecarlo_v{i}\" montecarlo = import_module(version) montecarlo.simulatie(100,50)","module simuleert alles. \"\"\" import projectparallelprogrammeren def simulatie(): \"\"\" Deze functie voert alle","f\"montecarlo_v{i}\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if __name__","en achtereenvolgens uitvoeren. version = f\"montecarlo_v{i}\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen","from importlib import import_module for i in range(4): #alle versies van de simulatie","vergeleken kunnen worden qua timing. \"\"\" from importlib import import_module for i in","\"\"\" import projectparallelprogrammeren def simulatie(): \"\"\" Deze functie voert alle versies uit zodat","# -*- coding: utf-8 -*- \"\"\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles.","\"\"\" Deze functie voert alle versies uit zodat deze vergeleken kunnen worden qua","in range(4): #alle versies van de simulatie importeren en achtereenvolgens uitvoeren. version =","for i in range(4): #alle versies van de simulatie importeren en achtereenvolgens uitvoeren.","import import_module for i in range(4): #alle versies van de simulatie importeren en","i in range(4): #alle versies van de simulatie importeren en achtereenvolgens uitvoeren. version","utf-8 -*- \"\"\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \"\"\" import projectparallelprogrammeren","import projectparallelprogrammeren def simulatie(): \"\"\" Deze functie voert alle versies uit zodat deze","coding: utf-8 -*- \"\"\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \"\"\" import","projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \"\"\" import projectparallelprogrammeren def simulatie(): \"\"\" Deze","uitvoeren. version = f\"montecarlo_v{i}\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als","def simulatie(): \"\"\" Deze functie voert alle versies uit zodat deze vergeleken kunnen","versies van de simulatie importeren en achtereenvolgens uitvoeren. version = f\"montecarlo_v{i}\" montecarlo =","importeren en achtereenvolgens uitvoeren. version = f\"montecarlo_v{i}\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden","range(4): #alle versies van de simulatie importeren en achtereenvolgens uitvoeren. version = f\"montecarlo_v{i}\"","projectparallelprogrammeren def simulatie(): \"\"\" Deze functie voert alle versies uit zodat deze vergeleken","alle versies uit zodat deze vergeleken kunnen worden qua timing. \"\"\" from importlib","<gh_stars>0 # -*- coding: utf-8 -*- \"\"\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert","montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if __name__ ==","#alle versies van de simulatie importeren en achtereenvolgens uitvoeren. version = f\"montecarlo_v{i}\" montecarlo","import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if __name__ == \"__main__\": simulatie()","zodat deze vergeleken kunnen worden qua timing. \"\"\" from importlib import import_module for","deze vergeleken kunnen worden qua timing. \"\"\" from importlib import import_module for i","importlib import import_module for i in range(4): #alle versies van de simulatie importeren","= f\"montecarlo_v{i}\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if","simulatie importeren en achtereenvolgens uitvoeren. version = f\"montecarlo_v{i}\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze","simulatie(): \"\"\" Deze functie voert alle versies uit zodat deze vergeleken kunnen worden","functie voert alle versies uit zodat deze vergeleken kunnen worden qua timing. \"\"\"","alles. \"\"\" import projectparallelprogrammeren def simulatie(): \"\"\" Deze functie voert alle versies uit","qua timing. \"\"\" from importlib import import_module for i in range(4): #alle versies","-*- coding: utf-8 -*- \"\"\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \"\"\"","worden qua timing. \"\"\" from importlib import import_module for i in range(4): #alle","timing. \"\"\" from importlib import import_module for i in range(4): #alle versies van","Deze module simuleert alles. \"\"\" import projectparallelprogrammeren def simulatie(): \"\"\" Deze functie voert","simuleert alles. \"\"\" import projectparallelprogrammeren def simulatie(): \"\"\" Deze functie voert alle versies","\"\"\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \"\"\" import projectparallelprogrammeren def simulatie():","van de simulatie importeren en achtereenvolgens uitvoeren. version = f\"montecarlo_v{i}\" montecarlo = import_module(version)","voert alle versies uit zodat deze vergeleken kunnen worden qua timing. \"\"\" from","uit zodat deze vergeleken kunnen worden qua timing. \"\"\" from importlib import import_module","import_module for i in range(4): #alle versies van de simulatie importeren en achtereenvolgens","kunnen worden qua timing. \"\"\" from importlib import import_module for i in range(4):","version = f\"montecarlo_v{i}\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test","================================================================= Deze module simuleert alles. \"\"\" import projectparallelprogrammeren def simulatie(): \"\"\" Deze functie","achtereenvolgens uitvoeren. version = f\"montecarlo_v{i}\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel","versies uit zodat deze vergeleken kunnen worden qua timing. \"\"\" from importlib import","Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \"\"\" import projectparallelprogrammeren def simulatie(): \"\"\"","montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if __name__ == \"__main__\": simulatie() #eof","\"\"\" from importlib import import_module for i in range(4): #alle versies van de"],"string":"[\n \"Deze functie voert alle versies uit zodat deze vergeleken kunnen worden qua timing.\",\n \"= import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if __name__ == \\\"__main__\\\":\",\n \"-*- \\\"\\\"\\\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \\\"\\\"\\\" import projectparallelprogrammeren def\",\n \"de simulatie importeren en achtereenvolgens uitvoeren. version = f\\\"montecarlo_v{i}\\\" montecarlo = import_module(version) montecarlo.simulatie(100,50)\",\n \"module simuleert alles. \\\"\\\"\\\" import projectparallelprogrammeren def simulatie(): \\\"\\\"\\\" Deze functie voert alle\",\n \"f\\\"montecarlo_v{i}\\\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if __name__\",\n \"en achtereenvolgens uitvoeren. version = f\\\"montecarlo_v{i}\\\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen\",\n \"from importlib import import_module for i in range(4): #alle versies van de simulatie\",\n \"vergeleken kunnen worden qua timing. \\\"\\\"\\\" from importlib import import_module for i in\",\n \"\\\"\\\"\\\" import projectparallelprogrammeren def simulatie(): \\\"\\\"\\\" Deze functie voert alle versies uit zodat\",\n \"# -*- coding: utf-8 -*- \\\"\\\"\\\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles.\",\n \"\\\"\\\"\\\" Deze functie voert alle versies uit zodat deze vergeleken kunnen worden qua\",\n \"in range(4): #alle versies van de simulatie importeren en achtereenvolgens uitvoeren. version =\",\n \"for i in range(4): #alle versies van de simulatie importeren en achtereenvolgens uitvoeren.\",\n \"import import_module for i in range(4): #alle versies van de simulatie importeren en\",\n \"i in range(4): #alle versies van de simulatie importeren en achtereenvolgens uitvoeren. version\",\n \"utf-8 -*- \\\"\\\"\\\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \\\"\\\"\\\" import projectparallelprogrammeren\",\n \"import projectparallelprogrammeren def simulatie(): \\\"\\\"\\\" Deze functie voert alle versies uit zodat deze\",\n \"coding: utf-8 -*- \\\"\\\"\\\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \\\"\\\"\\\" import\",\n \"projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \\\"\\\"\\\" import projectparallelprogrammeren def simulatie(): \\\"\\\"\\\" Deze\",\n \"uitvoeren. version = f\\\"montecarlo_v{i}\\\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als\",\n \"def simulatie(): \\\"\\\"\\\" Deze functie voert alle versies uit zodat deze vergeleken kunnen\",\n \"versies van de simulatie importeren en achtereenvolgens uitvoeren. version = f\\\"montecarlo_v{i}\\\" montecarlo =\",\n \"importeren en achtereenvolgens uitvoeren. version = f\\\"montecarlo_v{i}\\\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden\",\n \"range(4): #alle versies van de simulatie importeren en achtereenvolgens uitvoeren. version = f\\\"montecarlo_v{i}\\\"\",\n \"projectparallelprogrammeren def simulatie(): \\\"\\\"\\\" Deze functie voert alle versies uit zodat deze vergeleken\",\n \"alle versies uit zodat deze vergeleken kunnen worden qua timing. \\\"\\\"\\\" from importlib\",\n \"<gh_stars>0 # -*- coding: utf-8 -*- \\\"\\\"\\\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert\",\n \"montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if __name__ ==\",\n \"#alle versies van de simulatie importeren en achtereenvolgens uitvoeren. version = f\\\"montecarlo_v{i}\\\" montecarlo\",\n \"import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if __name__ == \\\"__main__\\\": simulatie()\",\n \"zodat deze vergeleken kunnen worden qua timing. \\\"\\\"\\\" from importlib import import_module for\",\n \"deze vergeleken kunnen worden qua timing. \\\"\\\"\\\" from importlib import import_module for i\",\n \"importlib import import_module for i in range(4): #alle versies van de simulatie importeren\",\n \"= f\\\"montecarlo_v{i}\\\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if\",\n \"simulatie importeren en achtereenvolgens uitvoeren. version = f\\\"montecarlo_v{i}\\\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze\",\n \"simulatie(): \\\"\\\"\\\" Deze functie voert alle versies uit zodat deze vergeleken kunnen worden\",\n \"functie voert alle versies uit zodat deze vergeleken kunnen worden qua timing. \\\"\\\"\\\"\",\n \"alles. \\\"\\\"\\\" import projectparallelprogrammeren def simulatie(): \\\"\\\"\\\" Deze functie voert alle versies uit\",\n \"qua timing. \\\"\\\"\\\" from importlib import import_module for i in range(4): #alle versies\",\n \"-*- coding: utf-8 -*- \\\"\\\"\\\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \\\"\\\"\\\"\",\n \"worden qua timing. \\\"\\\"\\\" from importlib import import_module for i in range(4): #alle\",\n \"timing. \\\"\\\"\\\" from importlib import import_module for i in range(4): #alle versies van\",\n \"Deze module simuleert alles. \\\"\\\"\\\" import projectparallelprogrammeren def simulatie(): \\\"\\\"\\\" Deze functie voert\",\n \"simuleert alles. \\\"\\\"\\\" import projectparallelprogrammeren def simulatie(): \\\"\\\"\\\" Deze functie voert alle versies\",\n \"\\\"\\\"\\\" Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \\\"\\\"\\\" import projectparallelprogrammeren def simulatie():\",\n \"van de simulatie importeren en achtereenvolgens uitvoeren. version = f\\\"montecarlo_v{i}\\\" montecarlo = import_module(version)\",\n \"voert alle versies uit zodat deze vergeleken kunnen worden qua timing. \\\"\\\"\\\" from\",\n \"uit zodat deze vergeleken kunnen worden qua timing. \\\"\\\"\\\" from importlib import import_module\",\n \"import_module for i in range(4): #alle versies van de simulatie importeren en achtereenvolgens\",\n \"kunnen worden qua timing. \\\"\\\"\\\" from importlib import import_module for i in range(4):\",\n \"version = f\\\"montecarlo_v{i}\\\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test\",\n \"================================================================= Deze module simuleert alles. \\\"\\\"\\\" import projectparallelprogrammeren def simulatie(): \\\"\\\"\\\" Deze functie\",\n \"achtereenvolgens uitvoeren. version = f\\\"montecarlo_v{i}\\\" montecarlo = import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel\",\n \"versies uit zodat deze vergeleken kunnen worden qua timing. \\\"\\\"\\\" from importlib import\",\n \"Module projectparallelprogrammeren.codesimulatie ================================================================= Deze module simuleert alles. \\\"\\\"\\\" import projectparallelprogrammeren def simulatie(): \\\"\\\"\\\"\",\n \"montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if __name__ == \\\"__main__\\\": simulatie() #eof\",\n \"\\\"\\\"\\\" from importlib import import_module for i in range(4): #alle versies van de\"\n]","isConversational":false}}},{"rowIdx":495,"cells":{"ngram":{"kind":"list like","value":["# the encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self):","encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae'","(aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) +","intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32))","= aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data =","key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\"","python from __future__ import unicode_literals # Allow direct execution import os import sys","base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password","aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data can","message goes here' def test_encrypt(self): msg = b'message' key = list(range(16)) encrypted =","+ 14 * [0] self.secret_msg = b'Secret message goes here' def test_encrypt(self): msg","14 * [0] self.secret_msg = b'Secret message goes here' def test_encrypt(self): msg =","def test_cbc_decrypt(self): data = bytes_to_intlist( b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\x08'),","class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20, 0x15] + 14 *","self.iv = [0x20, 0x15] + 14 * [0] self.secret_msg = b'Secret message goes","aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 #","intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted =","sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import","Allow direct execution import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes","key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data,","def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\")","= intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\" ) decrypted","password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83'","self.iv)) self.assertEqual( encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8])","encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted,","= [0x20, 0x15] + 14 * [0] self.secret_msg = b'Secret message goes here'","[0x20, 0x15] + 14 * [0] self.secret_msg = b'Secret message goes here' def","encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data","b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted,",") decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg)","msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv))","= intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password,","TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20, 0x15] + 14 * [0]","b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae' ).decode('utf-8')","os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist,","= bytes_to_intlist( b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\x08'), self.secret_msg) def test_cbc_encrypt(self):","* [0] self.secret_msg = b'Secret message goes here' def test_encrypt(self): msg = b'message'","sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text","= b'Secret message goes here' def test_encrypt(self): msg = b'message' key = list(range(16))","intlist_to_bytes import base64 # the encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class","b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg) if __name__ == '__main__':","from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes","data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv","import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt,","base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg) if","data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def test_decrypt_text(self):","aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the","bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data can be generate with 'devscripts/generate_aes_testdata.py'","the encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key","+ b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8')","def test_encrypt(self): msg = b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted","self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83' ).decode('utf-8') decrypted =","haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import","be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20,","goes here' def test_encrypt(self): msg = b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg),",").decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg) if __name__ == '__main__': unittest.main()",").decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted =","self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83' ).decode('utf-8') decrypted","aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist(","= bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def test_decrypt_text(self): password","self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key,","data = bytes_to_intlist( b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\x08'), self.secret_msg) def","import unicode_literals # Allow direct execution import os import sys import unittest sys.path.insert(0,","16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83' ).decode('utf-8')","<gh_stars>10-100 #!/usr/bin/env python from __future__ import unicode_literals # Allow direct execution import os","direct execution import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import","= (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8])","= self.iv = [0x20, 0x15] + 14 * [0] self.secret_msg = b'Secret message","aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data","encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted,","b'Secret message goes here' def test_encrypt(self): msg = b'message' key = list(range(16)) encrypted","base64 # the encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def","decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted","self.iv)) self.assertEqual(decrypted.rstrip(b'\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv))","setUp(self): self.key = self.iv = [0x20, 0x15] + 14 * [0] self.secret_msg =","intlist_to_bytes(self.iv[:8]) + b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg) if __name__","import base64 # the encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase):","unicode_literals # Allow direct execution import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))","from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data can be","= b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key))","self.assertEqual(decrypted.rstrip(b'\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual(","test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def","# Allow direct execution import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from","import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from","from __future__ import unicode_literals # Allow direct execution import os import sys import","decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\" )","def setUp(self): self.key = self.iv = [0x20, 0x15] + 14 * [0] self.secret_msg","intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data,","import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64","list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self):","self.secret_msg = b'Secret message goes here' def test_encrypt(self): msg = b'message' key =","#!/usr/bin/env python from __future__ import unicode_literals # Allow direct execution import os import","test_encrypt(self): msg = b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted =","aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted","import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data can be generate with","decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode(","password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted,","with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20, 0x15] +","test_cbc_decrypt(self): data = bytes_to_intlist( b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\x08'), self.secret_msg)","= base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg)","here' def test_encrypt(self): msg = b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key)","[0] self.secret_msg = b'Secret message goes here' def test_encrypt(self): msg = b'message' key","b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\x08'), self.secret_msg) def test_cbc_encrypt(self): data =","self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted,","import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt,","bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def test_decrypt_text(self): password =","b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted","haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data can be generate","password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted,","intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16))","+ b'\\x0b\\xe6\\xa4\\xd9z\\x0e\\xb8\\xb9\\xd0\\xd4i_\\x85\\x1d\\x99\\x98_\\xe5\\x80\\xe7.\\xbf\\xa5\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg) if __name__ ==","execution import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt,","= base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg)","encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8')","bytes_to_intlist( b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\x08'), self.secret_msg) def test_cbc_encrypt(self): data","def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae' ).decode('utf-8') decrypted","encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key =","= intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted =","key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg)","intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\" ) decrypted =","self.key, self.iv)) self.assertEqual( encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode(","self.key = self.iv = [0x20, 0x15] + 14 * [0] self.secret_msg = b'Secret","can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv =","= list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def","0x15] + 14 * [0] self.secret_msg = b'Secret message goes here' def test_encrypt(self):","__future__ import unicode_literals # Allow direct execution import os import sys import unittest","'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20, 0x15] + 14","self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key,","os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt,","test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae' ).decode('utf-8') decrypted =","unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils","= intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted","self.assertEqual( encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) +","generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20, 0x15]","intlist_to_bytes(self.iv[:8]) + b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password =","msg = b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted,","= intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\x17\\x15\\x93\\xab\\x8d\\x80V\\xcdV\\xe0\\t\\xcdo\\xc2\\xa5\\xd8ksM\\r\\xe27N\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password,"],"string":"[\n \"# the encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self):\",\n \"encrypted, b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae'\",\n \"(aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) +\",\n \"intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32))\",\n \"= aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data =\",\n \"key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\"\",\n \"python from __future__ import unicode_literals # Allow direct execution import os import sys\",\n \"base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password\",\n \"aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data can\",\n \"message goes here' def test_encrypt(self): msg = b'message' key = list(range(16)) encrypted =\",\n \"+ 14 * [0] self.secret_msg = b'Secret message goes here' def test_encrypt(self): msg\",\n \"14 * [0] self.secret_msg = b'Secret message goes here' def test_encrypt(self): msg =\",\n \"def test_cbc_decrypt(self): data = bytes_to_intlist( b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\\\x08'),\",\n \"class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20, 0x15] + 14 *\",\n \"self.iv = [0x20, 0x15] + 14 * [0] self.secret_msg = b'Secret message goes\",\n \"aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 #\",\n \"intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted =\",\n \"sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import\",\n \"Allow direct execution import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes\",\n \"key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data,\",\n \"def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\")\",\n \"= intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\" ) decrypted\",\n \"password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83'\",\n \"self.iv)) self.assertEqual( encrypted, b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8])\",\n \"encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted,\",\n \"= [0x20, 0x15] + 14 * [0] self.secret_msg = b'Secret message goes here'\",\n \"[0x20, 0x15] + 14 * [0] self.secret_msg = b'Secret message goes here' def\",\n \"encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data\",\n \"b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted,\",\n \") decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg)\",\n \"msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv))\",\n \"= intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password,\",\n \"TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20, 0x15] + 14 * [0]\",\n \"b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae' ).decode('utf-8')\",\n \"os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist,\",\n \"= bytes_to_intlist( b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\\\x08'), self.secret_msg) def test_cbc_encrypt(self):\",\n \"* [0] self.secret_msg = b'Secret message goes here' def test_encrypt(self): msg = b'message'\",\n \"sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text\",\n \"= b'Secret message goes here' def test_encrypt(self): msg = b'message' key = list(range(16))\",\n \"intlist_to_bytes import base64 # the encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class\",\n \"b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg) if __name__ == '__main__':\",\n \"from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes\",\n \"data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv\",\n \"import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt,\",\n \"base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg) if\",\n \"data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\") def test_decrypt_text(self):\",\n \"aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the\",\n \"bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data can be generate with 'devscripts/generate_aes_testdata.py'\",\n \"the encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key\",\n \"+ b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8')\",\n \"def test_encrypt(self): msg = b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted\",\n \"self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83' ).decode('utf-8') decrypted =\",\n \"haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import\",\n \"be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20,\",\n \"goes here' def test_encrypt(self): msg = b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg),\",\n \").decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg) if __name__ == '__main__': unittest.main()\",\n \").decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted =\",\n \"self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83' ).decode('utf-8') decrypted\",\n \"aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist(\",\n \"= bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\") def test_decrypt_text(self): password\",\n \"self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key,\",\n \"data = bytes_to_intlist( b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\\\x08'), self.secret_msg) def\",\n \"import unicode_literals # Allow direct execution import os import sys import unittest sys.path.insert(0,\",\n \"16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83' ).decode('utf-8')\",\n \"<gh_stars>10-100 #!/usr/bin/env python from __future__ import unicode_literals # Allow direct execution import os\",\n \"direct execution import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import\",\n \"= (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8])\",\n \"= self.iv = [0x20, 0x15] + 14 * [0] self.secret_msg = b'Secret message\",\n \"aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data\",\n \"encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted,\",\n \"b'Secret message goes here' def test_encrypt(self): msg = b'message' key = list(range(16)) encrypted\",\n \"base64 # the encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def\",\n \"decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted\",\n \"self.iv)) self.assertEqual(decrypted.rstrip(b'\\\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv))\",\n \"setUp(self): self.key = self.iv = [0x20, 0x15] + 14 * [0] self.secret_msg =\",\n \"intlist_to_bytes(self.iv[:8]) + b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg) if __name__\",\n \"import base64 # the encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase):\",\n \"unicode_literals # Allow direct execution import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))\",\n \"from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data can be\",\n \"= b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key))\",\n \"self.assertEqual(decrypted.rstrip(b'\\\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual(\",\n \"test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\") def\",\n \"# Allow direct execution import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from\",\n \"import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from\",\n \"from __future__ import unicode_literals # Allow direct execution import os import sys import\",\n \"decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\" )\",\n \"def setUp(self): self.key = self.iv = [0x20, 0x15] + 14 * [0] self.secret_msg\",\n \"intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data,\",\n \"import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64\",\n \"list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self):\",\n \"self.secret_msg = b'Secret message goes here' def test_encrypt(self): msg = b'message' key =\",\n \"#!/usr/bin/env python from __future__ import unicode_literals # Allow direct execution import os import\",\n \"test_encrypt(self): msg = b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted =\",\n \"aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted\",\n \"import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data can be generate with\",\n \"decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode(\",\n \"password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted,\",\n \"with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20, 0x15] +\",\n \"test_cbc_decrypt(self): data = bytes_to_intlist( b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\\\x08'), self.secret_msg)\",\n \"= base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg)\",\n \"here' def test_encrypt(self): msg = b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key)\",\n \"[0] self.secret_msg = b'Secret message goes here' def test_encrypt(self): msg = b'message' key\",\n \"b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\\\x08'), self.secret_msg) def test_cbc_encrypt(self): data =\",\n \"self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted,\",\n \"import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt,\",\n \"bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\") def test_decrypt_text(self): password =\",\n \"b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted\",\n \"haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data can be generate\",\n \"password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted,\",\n \"intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16))\",\n \"+ b'\\\\x0b\\\\xe6\\\\xa4\\\\xd9z\\\\x0e\\\\xb8\\\\xb9\\\\xd0\\\\xd4i_\\\\x85\\\\x1d\\\\x99\\\\x98_\\\\xe5\\\\x80\\\\xe7.\\\\xbf\\\\xa5\\\\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg) if __name__ ==\",\n \"execution import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt,\",\n \"= base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg)\",\n \"encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8')\",\n \"bytes_to_intlist( b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\\\x08'), self.secret_msg) def test_cbc_encrypt(self): data\",\n \"def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae' ).decode('utf-8') decrypted\",\n \"encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key =\",\n \"= intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted =\",\n \"key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg)\",\n \"intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\" ) decrypted =\",\n \"self.key, self.iv)) self.assertEqual( encrypted, b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode(\",\n \"self.key = self.iv = [0x20, 0x15] + 14 * [0] self.secret_msg = b'Secret\",\n \"can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv =\",\n \"= list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def\",\n \"0x15] + 14 * [0] self.secret_msg = b'Secret message goes here' def test_encrypt(self):\",\n \"__future__ import unicode_literals # Allow direct execution import os import sys import unittest\",\n \"'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20, 0x15] + 14\",\n \"self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\\\\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key,\",\n \"os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt,\",\n \"test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae' ).decode('utf-8') decrypted =\",\n \"unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils\",\n \"= intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted\",\n \"self.assertEqual( encrypted, b\\\"\\\\x97\\\\x92+\\\\xe5\\\\x0b\\\\xc3\\\\x18\\\\x91ky9m&\\\\xb3\\\\xb5@\\\\xe6'\\\\xc2\\\\x96.\\\\xc8u\\\\x88\\\\xab9-[\\\\x9e|\\\\xf1\\\\xcd\\\") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) +\",\n \"generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20, 0x15]\",\n \"intlist_to_bytes(self.iv[:8]) + b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password =\",\n \"msg = b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted,\",\n \"= intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\\\\x17\\\\x15\\\\x93\\\\xab\\\\x8d\\\\x80V\\\\xcdV\\\\xe0\\\\t\\\\xcdo\\\\xc2\\\\xa5\\\\xd8ksM\\\\r\\\\xe27N\\\\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password,\"\n]","isConversational":false}}},{"rowIdx":496,"cells":{"ngram":{"kind":"list like","value":["https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import scrapbook as sb from utils_cv.common.data","kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"keypoints\"].data) == len( nb_output.scraps[\"bboxes\"].data ) @pytest.mark.gpu @pytest.mark.notebooks","0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\"01\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(","> 0 training_aps = nb_output.scraps[\"training_average_precision\"].data assert len(training_aps) > 0 for d in training_aps:","len( nb_output.scraps[\"bboxes\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path =","parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert","runs on the activated conda environment KERNEL_NAME = \"python3\" OUTPUT_NOTEBOOK = \"output.ipynb\" @pytest.mark.notebooks","len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path","@pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\"03\"] data_path2 =","nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"detection_bounding_box\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path","assert len(nb_output.scraps[\"detection_bounding_box\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\"01\"] pm.execute_notebook(","# the name of the current jupyter kernel # that runs on the","@pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\"02\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__,","for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path =","def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\"02\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1,","len(nb_output.scraps[\"keypoints\"].data) == len( nb_output.scraps[\"bboxes\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ):","name of the current jupyter kernel # that runs on the activated conda","activated conda environment KERNEL_NAME = \"python3\" OUTPUT_NOTEBOOK = \"output.ipynb\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path","= unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100,","PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert","PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"valid_accs\"].data)","OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK)","pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"detection_bounding_box\"].data) > 0",") nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"detection_bounding_box\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path):","the current jupyter kernel # that runs on the activated conda environment KERNEL_NAME","kernel # that runs on the activated conda environment KERNEL_NAME = \"python3\" OUTPUT_NOTEBOOK","DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data) > 0","@pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\"03\"] data_path2 = unzip_url(","test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\"03\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session,","notebook_path = detection_notebooks[\"00\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert","@pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\"01\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__,","from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls # Unless manually modified, python3","notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK)","DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data) > 0","# Licensed under the MIT License. # This test is based on the","nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"valid_accs\"].data) == 1 assert 5 <= len(nb_output.scraps[\"hard_im_scores\"].data) <= 10","notebook_path = detection_notebooks[\"12\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ),","d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ):","= sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data) > 0 training_aps = nb_output.scraps[\"training_average_precision\"].data assert len(training_aps) > 0","= detection_notebooks[\"12\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME,","All rights reserved. # Licensed under the MIT License. # This test is","the test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm","test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\"00\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK)","detection_notebooks[\"00\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"detection_bounding_box\"].data) >","KERNEL_NAME = \"python3\" OUTPUT_NOTEBOOK = \"output.ipynb\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\"00\"] pm.execute_notebook(","scrapbook as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls # Unless","MIT License. # This test is based on the test suite implemented for","parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data)","for d in training_aps: assert isinstance(d, dict) assert len(set([len(d) for d in training_aps]))","nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data) > 0 training_aps = nb_output.scraps[\"training_average_precision\"].data assert len(training_aps) >","training_aps = nb_output.scraps[\"training_average_precision\"].data assert len(training_aps) > 0 for d in training_aps: assert isinstance(d,","1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\"03\"] data_path2","as pm import pytest import scrapbook as sb from utils_cv.common.data import unzip_url from","pm import pytest import scrapbook as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data","utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls # Unless manually modified, python3 should","import pytest import scrapbook as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import","on the activated conda environment KERNEL_NAME = \"python3\" OUTPUT_NOTEBOOK = \"output.ipynb\" @pytest.mark.notebooks def","# This test is based on the test suite implemented for Recommenders project","sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls # Unless manually modified,","\"output.ipynb\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\"00\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, )","== len( nb_output.scraps[\"bboxes\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path","detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\"12\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path,","test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\"02\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100,","Licensed under the MIT License. # This test is based on the test","nb_output.scraps[\"training_average_precision\"].data assert len(training_aps) > 0 for d in training_aps: assert isinstance(d, dict) assert","environment KERNEL_NAME = \"python3\" OUTPUT_NOTEBOOK = \"output.ipynb\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\"00\"]","pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, )","in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path","suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest","should be # the name of the current jupyter kernel # that runs","detection_notebooks[\"01\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output","OUTPUT_NOTEBOOK = \"output.ipynb\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\"00\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__),","EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data) > 0 training_aps","kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data) > 0 training_aps = nb_output.scraps[\"training_average_precision\"].data assert","detection_notebooks[\"03\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(","@pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\"01\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path,","import unzip_url from utils_cv.detection.data import Urls # Unless manually modified, python3 should be","PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data) >","in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\"02\"] pm.execute_notebook(","fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2,","the MIT License. # This test is based on the test suite implemented","the activated conda environment KERNEL_NAME = \"python3\" OUTPUT_NOTEBOOK = \"output.ipynb\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks):","assert len(nb_output.scraps[\"training_losses\"].data) > 0 training_aps = nb_output.scraps[\"training_average_precision\"].data assert len(training_aps) > 0 for d","), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"keypoints\"].data) == len( nb_output.scraps[\"bboxes\"].data ) @pytest.mark.gpu","def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\"12\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(","EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"valid_accs\"].data) == 1 assert","sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"detection_bounding_box\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\"01\"]","test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import","pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output","unzip_url from utils_cv.detection.data import Urls # Unless manually modified, python3 should be #","parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"detection_bounding_box\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def","= sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"keypoints\"].data) == len( nb_output.scraps[\"bboxes\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks,","implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import","\"python3\" OUTPUT_NOTEBOOK = \"output.ipynb\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\"00\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK,","pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output =","def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\"00\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output =","unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1,","for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session","training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\"02\"] pm.execute_notebook( notebook_path,","import Urls # Unless manually modified, python3 should be # the name of","assert len(nb_output.scraps[\"keypoints\"].data) == len( nb_output.scraps[\"bboxes\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path","for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import scrapbook","def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\"03\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path,","dict) assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks,","nb_output.scraps[\"bboxes\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\"12\"]",") nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"keypoints\"].data) == len( nb_output.scraps[\"bboxes\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def","OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert","kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"valid_accs\"].data) == 1 assert 5 <= len(nb_output.scraps[\"hard_im_scores\"].data)","manually modified, python3 should be # the name of the current jupyter kernel","IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data) > 0 training_aps =","based on the test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill","OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert","test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\"01\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100,","THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"keypoints\"].data) == len( nb_output.scraps[\"bboxes\"].data )","Unless manually modified, python3 should be # the name of the current jupyter","tiny_od_data_path): notebook_path = detection_notebooks[\"01\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ),","d in training_aps: assert isinstance(d, dict) assert len(set([len(d) for d in training_aps])) ==","training_aps: assert isinstance(d, dict) assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu","assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path):","= nb_output.scraps[\"training_average_precision\"].data assert len(training_aps) > 0 for d in training_aps: assert isinstance(d, dict)","len(training_aps) > 0 for d in training_aps: assert isinstance(d, dict) assert len(set([len(d) for","import papermill as pm import pytest import scrapbook as sb from utils_cv.common.data import","Urls # Unless manually modified, python3 should be # the name of the","License. # This test is based on the test suite implemented for Recommenders","that runs on the activated conda environment KERNEL_NAME = \"python3\" OUTPUT_NOTEBOOK = \"output.ipynb\"","= detection_notebooks[\"00\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"detection_bounding_box\"].data)","notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"detection_bounding_box\"].data) > 0 @pytest.mark.gpu","# that runs on the activated conda environment KERNEL_NAME = \"python3\" OUTPUT_NOTEBOOK =","@pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\"12\"] pm.execute_notebook( notebook_path,","from utils_cv.detection.data import Urls # Unless manually modified, python3 should be # the","0 for d in training_aps: assert isinstance(d, dict) assert len(set([len(d) for d in","d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\"02\"]","pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output =",") nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"valid_accs\"].data) == 1 assert 5 <= len(nb_output.scraps[\"hard_im_scores\"].data) <=","exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ),","test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\"12\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__,","), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data) > 0 training_aps = nb_output.scraps[\"training_average_precision\"].data","parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data)","on the test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as","= sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"detection_bounding_box\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path =","# Unless manually modified, python3 should be # the name of the current","@pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\"00\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output","DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"keypoints\"].data) == len(","NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"valid_accs\"].data) == 1","in training_aps: assert isinstance(d, dict) assert len(set([len(d) for d in training_aps])) == 1","detection_notebooks[\"02\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output","dict) assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run(","kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"detection_bounding_box\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks,","be # the name of the current jupyter kernel # that runs on","of the current jupyter kernel # that runs on the activated conda environment","1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\"02\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(","== 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\"02\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK,","== 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\"03\"]","detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\"03\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session,","reserved. # Licensed under the MIT License. # This test is based on","notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output =","python3 should be # the name of the current jupyter kernel # that","IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"keypoints\"].data)","import scrapbook as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls #","len(nb_output.scraps[\"training_losses\"].data) > 0 training_aps = nb_output.scraps[\"training_average_precision\"].data assert len(training_aps) > 0 for d in","), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"valid_accs\"].data) == 1 assert 5 <=","# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT","tiny_ic_negatives_path ): notebook_path = detection_notebooks[\"12\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1,","): notebook_path = detection_notebooks[\"03\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook(","the name of the current jupyter kernel # that runs on the activated","Microsoft Corporation. All rights reserved. # Licensed under the MIT License. # This","len(nb_output.scraps[\"detection_bounding_box\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\"01\"] pm.execute_notebook( notebook_path,","PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data) >","parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK)","training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path =","tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\"12\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path,","assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks,","notebook_path = detection_notebooks[\"01\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME,","under the MIT License. # This test is based on the test suite","IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"valid_accs\"].data) == 1 assert 5","nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"keypoints\"].data) == len( nb_output.scraps[\"bboxes\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run(","is based on the test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import","# https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import scrapbook as sb from","OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"detection_bounding_box\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks","Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path,","= detection_notebooks[\"02\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, )","(c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. #","Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import scrapbook as","Corporation. All rights reserved. # Licensed under the MIT License. # This test","sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"keypoints\"].data) == len( nb_output.scraps[\"bboxes\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path,","conda environment KERNEL_NAME = \"python3\" OUTPUT_NOTEBOOK = \"output.ipynb\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path =","assert len(training_aps) > 0 for d in training_aps: assert isinstance(d, dict) assert len(set([len(d)","len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path,","isinstance(d, dict) assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def","detection_notebooks[\"12\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, )","pytest import scrapbook as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls","papermill as pm import pytest import scrapbook as sb from utils_cv.common.data import unzip_url","rights reserved. # Licensed under the MIT License. # This test is based","= \"python3\" OUTPUT_NOTEBOOK = \"output.ipynb\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\"00\"] pm.execute_notebook( notebook_path,",") nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data) > 0 training_aps = nb_output.scraps[\"training_average_precision\"].data assert len(training_aps)","utils_cv.detection.data import Urls # Unless manually modified, python3 should be # the name","tmp_session ): notebook_path = detection_notebooks[\"03\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, )","notebook_path = detection_notebooks[\"03\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path,","notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK)","> 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\"01\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK,","dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01,","EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"keypoints\"].data) ==","= detection_notebooks[\"03\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK,",") pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME,","> 0 for d in training_aps: assert isinstance(d, dict) assert len(set([len(d) for d","notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output","jupyter kernel # that runs on the activated conda environment KERNEL_NAME = \"python3\"",") @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\"12\"] pm.execute_notebook(","test is based on the test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests","modified, python3 should be # the name of the current jupyter kernel #","assert isinstance(d, dict) assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks","tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\"03\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True,","Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License.","data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__,","DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"valid_accs\"].data) ==","project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import scrapbook as sb","def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\"01\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1,","This test is based on the test suite implemented for Recommenders project #","@pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\"02\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path,","as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls # Unless manually","sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"training_losses\"].data) > 0 training_aps = nb_output.scraps[\"training_average_precision\"].data assert len(training_aps) > 0 for","current jupyter kernel # that runs on the activated conda environment KERNEL_NAME =","0 training_aps = nb_output.scraps[\"training_average_precision\"].data assert len(training_aps) > 0 for d in training_aps: assert","tiny_od_mask_data_path): notebook_path = detection_notebooks[\"02\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ),","notebook_path = detection_notebooks[\"02\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME,","= \"output.ipynb\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\"00\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME,","OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output =","DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"keypoints\"].data) == len( nb_output.scraps[\"bboxes\"].data","): notebook_path = detection_notebooks[\"12\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100,","@pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\"12\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK,","= detection_notebooks[\"01\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, )"],"string":"[\n \"https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import scrapbook as sb from utils_cv.common.data\",\n \"kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"keypoints\\\"].data) == len( nb_output.scraps[\\\"bboxes\\\"].data ) @pytest.mark.gpu @pytest.mark.notebooks\",\n \"0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\\\"01\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(\",\n \"> 0 training_aps = nb_output.scraps[\\\"training_average_precision\\\"].data assert len(training_aps) > 0 for d in training_aps:\",\n \"len( nb_output.scraps[\\\"bboxes\\\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path =\",\n \"parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert\",\n \"runs on the activated conda environment KERNEL_NAME = \\\"python3\\\" OUTPUT_NOTEBOOK = \\\"output.ipynb\\\" @pytest.mark.notebooks\",\n \"len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path\",\n \"@pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\\\"03\\\"] data_path2 =\",\n \"nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"detection_bounding_box\\\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path\",\n \"assert len(nb_output.scraps[\\\"detection_bounding_box\\\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\\\"01\\\"] pm.execute_notebook(\",\n \"# the name of the current jupyter kernel # that runs on the\",\n \"@pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\\\"02\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__,\",\n \"for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path =\",\n \"def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\\\"02\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1,\",\n \"len(nb_output.scraps[\\\"keypoints\\\"].data) == len( nb_output.scraps[\\\"bboxes\\\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ):\",\n \"name of the current jupyter kernel # that runs on the activated conda\",\n \"activated conda environment KERNEL_NAME = \\\"python3\\\" OUTPUT_NOTEBOOK = \\\"output.ipynb\\\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path\",\n \"= unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100,\",\n \"PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert\",\n \"PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"valid_accs\\\"].data)\",\n \"OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK)\",\n \"pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"detection_bounding_box\\\"].data) > 0\",\n \") nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"detection_bounding_box\\\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path):\",\n \"the current jupyter kernel # that runs on the activated conda environment KERNEL_NAME\",\n \"kernel # that runs on the activated conda environment KERNEL_NAME = \\\"python3\\\" OUTPUT_NOTEBOOK\",\n \"DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data) > 0\",\n \"@pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\\\"03\\\"] data_path2 = unzip_url(\",\n \"test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\\\"03\\\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session,\",\n \"notebook_path = detection_notebooks[\\\"00\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert\",\n \"@pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\\\"01\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__,\",\n \"from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls # Unless manually modified, python3\",\n \"notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK)\",\n \"DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data) > 0\",\n \"# Licensed under the MIT License. # This test is based on the\",\n \"nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"valid_accs\\\"].data) == 1 assert 5 <= len(nb_output.scraps[\\\"hard_im_scores\\\"].data) <= 10\",\n \"notebook_path = detection_notebooks[\\\"12\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ),\",\n \"d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ):\",\n \"= sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data) > 0 training_aps = nb_output.scraps[\\\"training_average_precision\\\"].data assert len(training_aps) > 0\",\n \"= detection_notebooks[\\\"12\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME,\",\n \"All rights reserved. # Licensed under the MIT License. # This test is\",\n \"the test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm\",\n \"test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\\\"00\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK)\",\n \"detection_notebooks[\\\"00\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"detection_bounding_box\\\"].data) >\",\n \"KERNEL_NAME = \\\"python3\\\" OUTPUT_NOTEBOOK = \\\"output.ipynb\\\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\\\"00\\\"] pm.execute_notebook(\",\n \"scrapbook as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls # Unless\",\n \"MIT License. # This test is based on the test suite implemented for\",\n \"parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data)\",\n \"for d in training_aps: assert isinstance(d, dict) assert len(set([len(d) for d in training_aps]))\",\n \"nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data) > 0 training_aps = nb_output.scraps[\\\"training_average_precision\\\"].data assert len(training_aps) >\",\n \"training_aps = nb_output.scraps[\\\"training_average_precision\\\"].data assert len(training_aps) > 0 for d in training_aps: assert isinstance(d,\",\n \"1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\\\"03\\\"] data_path2\",\n \"as pm import pytest import scrapbook as sb from utils_cv.common.data import unzip_url from\",\n \"pm import pytest import scrapbook as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data\",\n \"utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls # Unless manually modified, python3 should\",\n \"import pytest import scrapbook as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import\",\n \"on the activated conda environment KERNEL_NAME = \\\"python3\\\" OUTPUT_NOTEBOOK = \\\"output.ipynb\\\" @pytest.mark.notebooks def\",\n \"# This test is based on the test suite implemented for Recommenders project\",\n \"sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls # Unless manually modified,\",\n \"\\\"output.ipynb\\\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\\\"00\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, )\",\n \"== len( nb_output.scraps[\\\"bboxes\\\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path\",\n \"detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\\\"12\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path,\",\n \"test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\\\"02\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100,\",\n \"Licensed under the MIT License. # This test is based on the test\",\n \"nb_output.scraps[\\\"training_average_precision\\\"].data assert len(training_aps) > 0 for d in training_aps: assert isinstance(d, dict) assert\",\n \"environment KERNEL_NAME = \\\"python3\\\" OUTPUT_NOTEBOOK = \\\"output.ipynb\\\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\\\"00\\\"]\",\n \"pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, )\",\n \"in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path\",\n \"suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest\",\n \"should be # the name of the current jupyter kernel # that runs\",\n \"detection_notebooks[\\\"01\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output\",\n \"OUTPUT_NOTEBOOK = \\\"output.ipynb\\\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\\\"00\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__),\",\n \"EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data) > 0 training_aps\",\n \"kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data) > 0 training_aps = nb_output.scraps[\\\"training_average_precision\\\"].data assert\",\n \"detection_notebooks[\\\"03\\\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(\",\n \"@pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\\\"01\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path,\",\n \"import unzip_url from utils_cv.detection.data import Urls # Unless manually modified, python3 should be\",\n \"PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data) >\",\n \"in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\\\"02\\\"] pm.execute_notebook(\",\n \"fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2,\",\n \"the MIT License. # This test is based on the test suite implemented\",\n \"the activated conda environment KERNEL_NAME = \\\"python3\\\" OUTPUT_NOTEBOOK = \\\"output.ipynb\\\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks):\",\n \"assert len(nb_output.scraps[\\\"training_losses\\\"].data) > 0 training_aps = nb_output.scraps[\\\"training_average_precision\\\"].data assert len(training_aps) > 0 for d\",\n \"), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"keypoints\\\"].data) == len( nb_output.scraps[\\\"bboxes\\\"].data ) @pytest.mark.gpu\",\n \"def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\\\"12\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(\",\n \"EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"valid_accs\\\"].data) == 1 assert\",\n \"sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"detection_bounding_box\\\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\\\"01\\\"]\",\n \"test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import\",\n \"pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output\",\n \"unzip_url from utils_cv.detection.data import Urls # Unless manually modified, python3 should be #\",\n \"parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"detection_bounding_box\\\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def\",\n \"= sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"keypoints\\\"].data) == len( nb_output.scraps[\\\"bboxes\\\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks,\",\n \"implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import\",\n \"\\\"python3\\\" OUTPUT_NOTEBOOK = \\\"output.ipynb\\\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\\\"00\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK,\",\n \"pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output =\",\n \"def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\\\"00\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output =\",\n \"unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1,\",\n \"for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session\",\n \"training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\\\"02\\\"] pm.execute_notebook( notebook_path,\",\n \"import Urls # Unless manually modified, python3 should be # the name of\",\n \"assert len(nb_output.scraps[\\\"keypoints\\\"].data) == len( nb_output.scraps[\\\"bboxes\\\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path\",\n \"for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import scrapbook\",\n \"def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\\\"03\\\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path,\",\n \"dict) assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks,\",\n \"nb_output.scraps[\\\"bboxes\\\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\\\"12\\\"]\",\n \") nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"keypoints\\\"].data) == len( nb_output.scraps[\\\"bboxes\\\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def\",\n \"OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert\",\n \"kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"valid_accs\\\"].data) == 1 assert 5 <= len(nb_output.scraps[\\\"hard_im_scores\\\"].data)\",\n \"manually modified, python3 should be # the name of the current jupyter kernel\",\n \"IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data) > 0 training_aps =\",\n \"based on the test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill\",\n \"OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert\",\n \"test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\\\"01\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100,\",\n \"THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"keypoints\\\"].data) == len( nb_output.scraps[\\\"bboxes\\\"].data )\",\n \"Unless manually modified, python3 should be # the name of the current jupyter\",\n \"tiny_od_data_path): notebook_path = detection_notebooks[\\\"01\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ),\",\n \"d in training_aps: assert isinstance(d, dict) assert len(set([len(d) for d in training_aps])) ==\",\n \"training_aps: assert isinstance(d, dict) assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu\",\n \"assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path):\",\n \"= nb_output.scraps[\\\"training_average_precision\\\"].data assert len(training_aps) > 0 for d in training_aps: assert isinstance(d, dict)\",\n \"len(training_aps) > 0 for d in training_aps: assert isinstance(d, dict) assert len(set([len(d) for\",\n \"import papermill as pm import pytest import scrapbook as sb from utils_cv.common.data import\",\n \"Urls # Unless manually modified, python3 should be # the name of the\",\n \"License. # This test is based on the test suite implemented for Recommenders\",\n \"that runs on the activated conda environment KERNEL_NAME = \\\"python3\\\" OUTPUT_NOTEBOOK = \\\"output.ipynb\\\"\",\n \"= detection_notebooks[\\\"00\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"detection_bounding_box\\\"].data)\",\n \"notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"detection_bounding_box\\\"].data) > 0 @pytest.mark.gpu\",\n \"# that runs on the activated conda environment KERNEL_NAME = \\\"python3\\\" OUTPUT_NOTEBOOK =\",\n \"@pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\\\"12\\\"] pm.execute_notebook( notebook_path,\",\n \"from utils_cv.detection.data import Urls # Unless manually modified, python3 should be # the\",\n \"0 for d in training_aps: assert isinstance(d, dict) assert len(set([len(d) for d in\",\n \"d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\\\"02\\\"]\",\n \"pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output =\",\n \") nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"valid_accs\\\"].data) == 1 assert 5 <= len(nb_output.scraps[\\\"hard_im_scores\\\"].data) <=\",\n \"exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ),\",\n \"test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\\\"12\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__,\",\n \"), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data) > 0 training_aps = nb_output.scraps[\\\"training_average_precision\\\"].data\",\n \"parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data)\",\n \"on the test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as\",\n \"= sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"detection_bounding_box\\\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path =\",\n \"# Unless manually modified, python3 should be # the name of the current\",\n \"@pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\\\"00\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output\",\n \"DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"keypoints\\\"].data) == len(\",\n \"NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"valid_accs\\\"].data) == 1\",\n \"in training_aps: assert isinstance(d, dict) assert len(set([len(d) for d in training_aps])) == 1\",\n \"detection_notebooks[\\\"02\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output\",\n \"dict) assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run(\",\n \"kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"detection_bounding_box\\\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks,\",\n \"be # the name of the current jupyter kernel # that runs on\",\n \"of the current jupyter kernel # that runs on the activated conda environment\",\n \"1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\\\"02\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(\",\n \"== 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\\\"02\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK,\",\n \"== 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\\\"03\\\"]\",\n \"detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\\\"03\\\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session,\",\n \"reserved. # Licensed under the MIT License. # This test is based on\",\n \"notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output =\",\n \"python3 should be # the name of the current jupyter kernel # that\",\n \"IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"keypoints\\\"].data)\",\n \"import scrapbook as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls #\",\n \"len(nb_output.scraps[\\\"training_losses\\\"].data) > 0 training_aps = nb_output.scraps[\\\"training_average_precision\\\"].data assert len(training_aps) > 0 for d in\",\n \"), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"valid_accs\\\"].data) == 1 assert 5 <=\",\n \"# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT\",\n \"tiny_ic_negatives_path ): notebook_path = detection_notebooks[\\\"12\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1,\",\n \"): notebook_path = detection_notebooks[\\\"03\\\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook(\",\n \"the name of the current jupyter kernel # that runs on the activated\",\n \"Microsoft Corporation. All rights reserved. # Licensed under the MIT License. # This\",\n \"len(nb_output.scraps[\\\"detection_bounding_box\\\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\\\"01\\\"] pm.execute_notebook( notebook_path,\",\n \"PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data) >\",\n \"parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK)\",\n \"training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path =\",\n \"tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\\\"12\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path,\",\n \"assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks,\",\n \"notebook_path = detection_notebooks[\\\"01\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME,\",\n \"under the MIT License. # This test is based on the test suite\",\n \"IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"valid_accs\\\"].data) == 1 assert 5\",\n \"nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"keypoints\\\"].data) == len( nb_output.scraps[\\\"bboxes\\\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run(\",\n \"is based on the test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import\",\n \"# https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import scrapbook as sb from\",\n \"OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"detection_bounding_box\\\"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks\",\n \"Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path,\",\n \"= detection_notebooks[\\\"02\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, )\",\n \"(c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. #\",\n \"Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import scrapbook as\",\n \"Corporation. All rights reserved. # Licensed under the MIT License. # This test\",\n \"sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"keypoints\\\"].data) == len( nb_output.scraps[\\\"bboxes\\\"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path,\",\n \"conda environment KERNEL_NAME = \\\"python3\\\" OUTPUT_NOTEBOOK = \\\"output.ipynb\\\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path =\",\n \"assert len(training_aps) > 0 for d in training_aps: assert isinstance(d, dict) assert len(set([len(d)\",\n \"len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path,\",\n \"isinstance(d, dict) assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def\",\n \"detection_notebooks[\\\"12\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, )\",\n \"pytest import scrapbook as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls\",\n \"papermill as pm import pytest import scrapbook as sb from utils_cv.common.data import unzip_url\",\n \"rights reserved. # Licensed under the MIT License. # This test is based\",\n \"= \\\"python3\\\" OUTPUT_NOTEBOOK = \\\"output.ipynb\\\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\\\"00\\\"] pm.execute_notebook( notebook_path,\",\n \") nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data) > 0 training_aps = nb_output.scraps[\\\"training_average_precision\\\"].data assert len(training_aps)\",\n \"utils_cv.detection.data import Urls # Unless manually modified, python3 should be # the name\",\n \"tmp_session ): notebook_path = detection_notebooks[\\\"03\\\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, )\",\n \"notebook_path = detection_notebooks[\\\"03\\\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path,\",\n \"notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK)\",\n \"> 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\\\"01\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK,\",\n \"dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01,\",\n \"EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"keypoints\\\"].data) ==\",\n \"= detection_notebooks[\\\"03\\\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK,\",\n \") pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME,\",\n \"> 0 for d in training_aps: assert isinstance(d, dict) assert len(set([len(d) for d\",\n \"notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output\",\n \"jupyter kernel # that runs on the activated conda environment KERNEL_NAME = \\\"python3\\\"\",\n \") @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\\\"12\\\"] pm.execute_notebook(\",\n \"test is based on the test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests\",\n \"modified, python3 should be # the name of the current jupyter kernel #\",\n \"assert isinstance(d, dict) assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks\",\n \"tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks[\\\"03\\\"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True,\",\n \"Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License.\",\n \"data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__,\",\n \"DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"valid_accs\\\"].data) ==\",\n \"project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import scrapbook as sb\",\n \"def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks[\\\"01\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1,\",\n \"This test is based on the test suite implemented for Recommenders project #\",\n \"@pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks[\\\"02\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path,\",\n \"as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls # Unless manually\",\n \"sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"training_losses\\\"].data) > 0 training_aps = nb_output.scraps[\\\"training_average_precision\\\"].data assert len(training_aps) > 0 for\",\n \"current jupyter kernel # that runs on the activated conda environment KERNEL_NAME =\",\n \"0 training_aps = nb_output.scraps[\\\"training_average_precision\\\"].data assert len(training_aps) > 0 for d in training_aps: assert\",\n \"tiny_od_mask_data_path): notebook_path = detection_notebooks[\\\"02\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ),\",\n \"notebook_path = detection_notebooks[\\\"02\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME,\",\n \"= \\\"output.ipynb\\\" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks[\\\"00\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME,\",\n \"OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output =\",\n \"DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\\\"keypoints\\\"].data) == len( nb_output.scraps[\\\"bboxes\\\"].data\",\n \"): notebook_path = detection_notebooks[\\\"12\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100,\",\n \"@pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks[\\\"12\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK,\",\n \"= detection_notebooks[\\\"01\\\"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, )\"\n]","isConversational":false}}},{"rowIdx":497,"cells":{"ngram":{"kind":"list like","value":["dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10])","for a batch size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config","[ '../retinanet_r50_fpn_1x_coco.py', '../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set for a batch","dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500,","<gh_stars>0 _base_ = [ '../retinanet_r50_fpn_1x_coco.py', '../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set","'../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set for a batch size of","# lr is set for a batch size of 8 optimizer = dict(type='SGD',","of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35,","dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy","policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10]) runner = dict( type='EpochBasedRunner',","a batch size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config =","is set for a batch size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9,","batch size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None)","# dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001,","set for a batch size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001)","optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) #","lr is set for a batch size of 8 optimizer = dict(type='SGD', lr=0.0005,","lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10]) runner = dict( type='EpochBasedRunner', max_epochs=20)","optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict( policy='step',","lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config","weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict(","norm_type=2)) # learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10]) runner","= dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict( policy='step', warmup='linear',","# learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10]) runner =","optimizer # lr is set for a batch size of 8 optimizer =","'../retinanet_r50_fpn_1x_coco.py', '../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set for a batch size","_base_ = [ '../retinanet_r50_fpn_1x_coco.py', '../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set for","size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) #","= dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning","# optimizer # lr is set for a batch size of 8 optimizer","= [ '../retinanet_r50_fpn_1x_coco.py', '../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set for a","momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config =","] # optimizer # lr is set for a batch size of 8","8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2))","learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10]) runner = dict("],"string":"[\n \"dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10])\",\n \"for a batch size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config\",\n \"[ '../retinanet_r50_fpn_1x_coco.py', '../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set for a batch\",\n \"dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500,\",\n \"<gh_stars>0 _base_ = [ '../retinanet_r50_fpn_1x_coco.py', '../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set\",\n \"'../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set for a batch size of\",\n \"# lr is set for a batch size of 8 optimizer = dict(type='SGD',\",\n \"of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35,\",\n \"dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy\",\n \"policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10]) runner = dict( type='EpochBasedRunner',\",\n \"a batch size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config =\",\n \"is set for a batch size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9,\",\n \"batch size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None)\",\n \"# dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001,\",\n \"set for a batch size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001)\",\n \"optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) #\",\n \"lr is set for a batch size of 8 optimizer = dict(type='SGD', lr=0.0005,\",\n \"lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10]) runner = dict( type='EpochBasedRunner', max_epochs=20)\",\n \"optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict( policy='step',\",\n \"lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config\",\n \"weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict(\",\n \"norm_type=2)) # learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10]) runner\",\n \"= dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict( policy='step', warmup='linear',\",\n \"# learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10]) runner =\",\n \"optimizer # lr is set for a batch size of 8 optimizer =\",\n \"'../retinanet_r50_fpn_1x_coco.py', '../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set for a batch size\",\n \"_base_ = [ '../retinanet_r50_fpn_1x_coco.py', '../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set for\",\n \"size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) #\",\n \"= dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning\",\n \"# optimizer # lr is set for a batch size of 8 optimizer\",\n \"= [ '../retinanet_r50_fpn_1x_coco.py', '../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set for a\",\n \"momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config =\",\n \"] # optimizer # lr is set for a batch size of 8\",\n \"8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2))\",\n \"learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10]) runner = dict(\"\n]","isConversational":false}}},{"rowIdx":498,"cells":{"ngram":{"kind":"list like","value":[],"string":"[]","isConversational":false}}},{"rowIdx":499,"cells":{"ngram":{"kind":"list like","value":["import os import pytest import pandas as pd import numpy as np from","as pd import numpy as np from os import path from sklearn import","from cognito.check import Check from cognito.table import Table import os import pytest import","from cognito.table import Table import os import pytest import pandas as pd import","<reponame>vandana-11/cognito from cognito.check import Check from cognito.table import Table import os import pytest","Table import os import pytest import pandas as pd import numpy as np","pytest import pandas as pd import numpy as np from os import path","import pandas as pd import numpy as np from os import path from","pandas as pd import numpy as np from os import path from sklearn","cognito.table import Table import os import pytest import pandas as pd import numpy","cognito.check import Check from cognito.table import Table import os import pytest import pandas","import Table import os import pytest import pandas as pd import numpy as","import pytest import pandas as pd import numpy as np from os import","pd import numpy as np from os import path from sklearn import preprocessing","os import pytest import pandas as pd import numpy as np from os","import Check from cognito.table import Table import os import pytest import pandas as","Check from cognito.table import Table import os import pytest import pandas as pd"],"string":"[\n \"import os import pytest import pandas as pd import numpy as np from\",\n \"as pd import numpy as np from os import path from sklearn import\",\n \"from cognito.check import Check from cognito.table import Table import os import pytest import\",\n \"from cognito.table import Table import os import pytest import pandas as pd import\",\n \"<reponame>vandana-11/cognito from cognito.check import Check from cognito.table import Table import os import pytest\",\n \"Table import os import pytest import pandas as pd import numpy as np\",\n \"pytest import pandas as pd import numpy as np from os import path\",\n \"import pandas as pd import numpy as np from os import path from\",\n \"pandas as pd import numpy as np from os import path from sklearn\",\n \"cognito.table import Table import os import pytest import pandas as pd import numpy\",\n \"cognito.check import Check from cognito.table import Table import os import pytest import pandas\",\n \"import Table import os import pytest import pandas as pd import numpy as\",\n \"import pytest import pandas as pd import numpy as np from os import\",\n \"pd import numpy as np from os import path from sklearn import preprocessing\",\n \"os import pytest import pandas as pd import numpy as np from os\",\n \"import Check from cognito.table import Table import os import pytest import pandas as\",\n \"Check from cognito.table import Table import os import pytest import pandas as pd\"\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":4,"numItemsPerPage":100,"numTotalItems":12866649,"offset":400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDM3MjU2OCwic3ViIjoiL2RhdGFzZXRzL3RlcnJ5eXovc3RhcmNvZGVyZGF0YV9uZ3JhbV8xMyIsImV4cCI6MTc3NDM3NjE2OCwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.NXicimrcI2J0lERpb6M7XCP6mfqNtNffah-l2jwkgaMwQnDUNdBTXod6cDm4JoC5AwgYxr12j6J4K7T8JrD_Bw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":12866649,"numBytesParquet":149232926747}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
ngram listlengths 0 67.8k |
|---|
[
"if path.endswith('/') and len(path) == 2: for v in self.list_dir(d + path[:-1]): yield",
"= \"@%08x\" % (khash >> 32) _dir = self.get_dir(khash32) ret = [] if",
"bucket)) def get_buckets_keys_count(store): \"\"\" return dict: buckets -> count \"\"\" st = {}",
"get_buckets_keys_count(store): \"\"\" return dic... |
[
"l1p1y l1p1y = l1p2y l1p2y = tmp l2p1x = line2[0][0] l2p1y = line2[0][1]",
"False if l1p1y > l2p2y or l1p2y < l2p1y: return False return True",
"= l2p1y l2p1y = l2p2y l2p2y = tmp # line2 rectangle is inside",
"return True if l1p1x > l2p2x or l1p2x < l2p1x: return False if",
"l2p2y = tmp # line2 rectangle is... |
[
"= self.get_from() if from_clause is not None: rv = rv.select_from(from_clause) return rv.execution_options(loader=self) def",
"= rv.outerjoin(from_clause, getattr(subloader, 'on_clause', None)) return rv def load(self, *column_names, **extras): if column_names:",
"item) class ModelLoader(Loader): def __init__(... |
[
"is None, returning data\") return \"data\" logging.debug(\"profile.get('curr_view', 'dummy') is %s\" % profile.get(\"curr_view\", \"data\"))",
"to pass in the day, and # remove this interface. Extra credit: should",
"newView): user = User.fromUUID(uuid) user.setClientSpecificProfileFields({'curr_view': newView... |
[
"AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,",
"out.append( u\" * %s\" % (self.colorize(m.level, m.summary[\"en\"] % m.vars)) ) smsgs = [msg",
"status on stderr with CLI? class BaseTextFormatter(Formatter): \"\"\" Base class for text formatters.\"\"\"",
"if level == \"uri... |
[
"scale_value(self, value): ''' (out_max - out_min)(value - in_min) f(x) = ----------------------------------- + out_min",
"self._in_min ) / ( self._in_max - self._in_min )) + self._out_min # return ((",
"= self.get_value() if update_led: self.set_rgb(_value) return self.scale_value(_value) # as float # # ......... |
[
"class Response: '' def close(): pass content = None def json(): pass text",
"1.12.0 \"\"\" # MCU: (sysname='esp32', nodename='esp32', release='1.12.0', version='v1.12 on 2019-12-20', machine='ESP32 module (spiram)",
"text = None def delete(): pass def get(): pass def head(): pass def",
"def get(): pass def h... |
[
"urlparse import urlparse def parse1(): p = re.compile(r\"/(?P<uid>\\d+)/(?P<mid>\\w+)\") o = urlparse(\"http://weibo.com/2827699110/yz62AlEjF\") m =",
"p = re.compile(r\"/(?P<uid>\\d+)/(?P<mid>\\w+)\") o = urlparse(\"http://weibo.com/2827699110/yz62AlEjF\") m = p.search(o.path) print m.group('uid') print m.group... |
[
"import Popup from kivy.properties import NumericProperty, ReferenceListProperty from kivy.uix.checkbox import CheckBox from kivy.core.window",
"import matplotlib import datetime from TransactionBook.model.Filter import Filter from datetime import datetime from",
"AnchorLayout() if option_init is None: option_i... |
[
"bridge this turn. \"\"\" finished_cars = list() for c in self.cars: c.distance_on_bridge +=",
"Bridge: \"\"\"Bridge class simulating the behaviour of bridge in simulation. On can set",
"len(self.cars) > self.capacity def move_cars(self) -> List[Car]: \"\"\" Moves cars across the bridge",
"= field(default_fac... |
[
"self.config['main']['reporting_firmware_ver'], self.config['main']['uuid'], base_url)) elif contentPath == '/lineup_status.json': if self.hdhr_station_scan: returnJSON = templates['jsonLineupStatus'] else:",
"enumerate(self.rmg_station_scans): if scan_status == 'Scan': self.rmg_station_scans[index] = \"Idle\" de... |
[
"context = {} # All resource paths end in .html. # Pick out",
"from django.http import HttpResponse from django.template import loader @login_required(login_url=\"/login/\") def index(request): context =",
"= loader.get_template(load_template) return HttpResponse(html_template.render(context, request)) except t... |
[
"> 1 def convert_float_samples_to_int16(y): \"\"\"Convert floating-point numpy array of audio samples to int16.\"\"\"",
"Is the given ndarray a multichannel spectrogram? :param samples: numpy ndarray :return: \"\"\"",
"a multichannel spectrogram? :param samples: numpy ndarray :return: \"\"\" return len(spectrog... |
[
"elif i == \"]\": if len(stack) < 1: print(False) exit() if stack[-1] ==",
"stack.pop() else: print(False) exit() elif i == \"}\": if len(stack) < 1: print(False)",
"1: print(False) exit() if stack[-1] == \"{\": stack.pop() else: print(False) exit() if len(stack)",
"i == \"{\": stack.append(\"{\") elif i == \... |
[
"data.get('slides'): for el in data.get('slides'): template = el.get('template') self.render(template=template, data=el, render_type='slide') @staticmethod def",
"self.set_base_dirs() self.set_source_dirs() self.content = get_content(content_path) self.render_init_templates() if table_contents: self.render_table_... |
[
"= \"encrypt\" subprocess.check_call(cmd_line) # Now we need to pass the encrypted-hsm startup option",
"= node_factory.get_nodes(3) l1.fundwallet(10**6) # We should now have a transaction that gave us",
"COUNT(*) as c FROM outputs WHERE status=2')[0]['c'] == 4 # Simple test for",
"decode['vin']: assert l1.da... |
[
"is_unit_fraction=is_unit_fraction) df[cn.TRANSFER] = transfer dfs.append(df) if self._is_plot: plt.show() return pd.concat(dfs) def plotLine(self, transfer,",
":return pd.DataFrame: row=mutation, col=line, value is fraction \"\"\" if is_plot is None: is_plot",
"plots nrows = 2 if (len(pairs) == 4) else 3 fig =... |
[
"label in 3-dim(h,w,c) and in BGR fromat read from cv2 ''' h, w,",
"KIND, either express or implied. # See the License for the specific language",
"= open(train_file, \"r\") lines = [line[:-1] for line in train_text_file] for line in",
"Unless required by applicable law or agreed to in writing, software # dis... |
[
"= trainer.get_lr() train_meter = StopwatchMeter() train_meter.start() while lr > args.min_lr and epoch <=",
"args.test_subset.split(','): scorer = score_test(args, trainer.get_model(), dataset, subset, beam, cuda_device=(0 if num_gpus > 0",
"if num_gpus > 0 else None)) print('| Test on {} with beam={}: {}'.for... |
[
"# Message sent. elif (command.startswith(\"sent,\")): m_id = command.split(\",\")[1] messages[m_id].sent(time) # Message processed. elif",
"file>\") exit() messages = logTiming(sys.argv[1]) groups = groupByMsgType(messages) print() print(\"All messages:\") for key",
"return groupByX(lambda x : x.getSource(), m... |
[
"'\\n[' + error('ERROR') + '] schema of ' + str(e['url']) + ' is",
"schemas = settings.SIMPLE_JSONSCHEMA for url, schema in schemas.items(): try: Draft4Validator.check_schema(schema) except SchemaError as",
"except SchemaError as e: errors.append({ 'url': url, 'error': e, 'schema': json.dumps(schema, indent=4, ... |
[
"right on right comb[:left.shape[0],:left.shape[1]] = left comb[:right.shape[0],left.shape[1]:] = right return comb def plotXY(data,size",
"for our purposes. \"\"\" def resize(*args, **kwargs): return cv2.resize(*args, **kwargs) def moveWindow(*args,**kwargs): return",
"= 0 P = [] for x,y in data: x = np.array(... |
[
"that tag. tag_to_positions = defaultdict(set) for i, (token, tag) in enumerate(tagged_tokens): tag_to_positions[tag].add(i) #",
"+= score tottrainscores = sum(trainscores) # det_tplsort() is for deterministic sorting; # the",
"def extract_property(tokens, index): \"\"\"@return: The given token's text.\"\"\" re... |
[
"+ xlnet_tokens_sub4 + xlnet_tokens_sub5 + [\"[SEP]\"] ) if len(tokens) > max_len: max_len =",
"span_tokens[:length]: st = len(\" \".join(tokens[:idx])) + 1 if idx != 0 else 0",
"= [] # span2 span2s = [] # span1 idx span1_idxs = []",
"span_text, span_index): tokens = text.replace(\"\\n\", \" \").lower().split... |
[
"= [] for i in range(len(self.tokens)): word = self.tokens[i] score = self.dictionary.get(word, 0)",
"as data_file: self.dictionary = json.load(data_file) no_punctunation = re.sub(r\"[^a-zA-Z ]+\", \" \", self.text) self.tokens",
"[\"no\", \"not\"]: word = \"not_\" + word score = -score if score <",
"= [\"Sim... |
[
"visit: # https://robodk.com/doc/en/PythonAPI/robolink.html from robolink import * # RoboDK API # JSON tools",
"#OptimAxes_TEST[\"RefWeight_\" + str(i+1)] = (count+i) #OptimAxes_TEST[\"RefOn_\" + str(i+1)] = count % 2 #",
"active: ToUpdate = {} ToUpdate[\"Active\"] = 1 json_str = json.dumps(json.dumps(ToUpdate)... |
[
"\"\"\"E -> E ^ + T E -> T T -> T *",
"self.assertSetEqual({'E', 'T', 'F'}, self.G.nonterminals) self.assertSetEqual({'+', '*', '(', ')', 'id', 'E', 'T', 'F'}, self.G.symbols)",
"E ^ + T E -> T T -> T * F |",
"-> T * F | F F -> ( E ) F ->",
"E -> T T -> T * F | F F -> (",
"id\"\"\", \"\"\"E -> E ^ + T E -... |
[
"models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('elo_mean', models.IntegerField(default=0)), ('elo_diff', models.IntegerField(default=0)), ('result', models.CharField(max_length=40)), ('timecontrol', models.CharField(max_length=40)), ('timestamp',",
"= True dependenci... |
[
"1, key=world.Get_rank()) if world.Get_rank() < num_workers: if comm.Get_rank() == 0: x = torch.tensor([[0,",
"@abort_on_exception def test_1(): worker_shape = [2, 2] world = MPI.COMM_WORLD num_workers = np.array(worker_shape).prod()",
"comm=comm, worker_shape=worker_shape) e = torch.tensor([[0, 1], [2, 3]]) as... |
[
"min_x = min(positions) max_x = max(positions) costs = {x: 0 for x in",
"= abs(pos - crab) costs[pos] += ((distance * distance) + distance) // 2",
"positions = [int(x) for x in infile.readline().strip().split(',')] min_x = min(positions) max_x = max(positions)",
"def process(filename): with open(filename) as ... |
[
"n def getFeatGene(x, firstOnly = False): # get gene if pd.isnull(x): return ''",
"if firstOnly: return [n[1] for n in r][0] else: return [n[1] for n",
"r][0] else: return [n[1] for n in r] def pd_filter(df, idx): # filters",
"idx = [n for n in idx if n in df.index] return df.loc[idx,",
"= [n for n in idx i... |
[
"14, gameMain.DefaultCnt.Get_RegKey(\"/strings/settings/random_title\") + str(gameMain.DefaultCnt.Get_RegKey(\"/OPTIONS/random_title\")), (240, 240, 240), ElementsX + 95, ElementsY + 77,",
"KIND, either express or implied. # See the License for the specific language",
"Unless required by applicable law or agree... |
[
"def getRawButton(self, num): return self._pressed[num] def press(self, num): self._pressed[num] = True def release(self,",
"Toggle(joystick, 1, 0.1) assert toggleButton.off joystick.press(1) assert toggleButton.on joystick.release(1) joystick.press(1) joystick.release(1) assert toggleButton.on",
"self._pressed... |
[
"test cases for tflearn ''' import tensorflow.compat.v1 as tf import tflearn import unittest",
"self.assertAlmostEqual( sess.run(tflearn.activation(x, 'tanh')), -0.2449, places=TestActivations.PLACES) # Case 5: lrelu_02 (callable) self.assertAlmostEqual( sess.run(tflearn.activation(x, lrelu_02)),",
"sess.run(tf... |
[
"an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND,",
"distributed on an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY",
"fab install-libs', shell=True, check=True) except: success = False reply = dict() reply['request_id'] =",
"express or implied. See the License for the # spe... |
[
"# # Licensed under the Apache License, Version 2.0 (the \"License\"); # you",
"writing, software # distributed under the License is distributed on an \"AS IS\"",
"edict({ 'task': 'NER', 'num_labels': 41, 'data_file': '', 'schema_file': None, 'finetune_ckpt': '', 'use_crf': False,",
"'clue_benchmark': False, ... |
[
"mdb_view: try: avb = ArticleViewedBy.objects.get(article=mdb_view['article'], user=mdb_view['user']) avb.viewed_at = mdb_view['viewed_at'] avb.save() except ArticleViewedBy.DoesNotExist: try:",
"mdb_view = core_articleviewedby_mdb.posts.find_one_and_delete({}) while mdb_view: try: avb = ArticleViewedBy.objects.g... |
[
"__init__(self, in_channels, out_channels, D=3): ResNetBase.__init__(self, in_channels, out_channels, D) def network_initialization(self, in_channels, out_channels, D):",
"x): out = self.conv0p1s1(x) out = self.bn0(out) out_p1 = self.relu(out) out = self.conv1p1s2(out_p1)",
"loss.item()) # Gradient loss.backwar... |
[
"setuptools import setup setup( name='nginx-access-tailer', version='0.1', author='swfrench', url='https://github.com/swfrench/nginx-tailer', packages=['nginx_access_tailer',], license='BSD three-clause license', entry_points={",
"version='0.1', author='swfrench', url='https://github.com/swfrench/nginx-tailer', p... |
[
"# # Licensed under the Apache License, Version 2.0 (the \"License\"); # you",
"writing, software # distributed under the License is distributed on an \"AS IS\"",
"permissions and # limitations under the License. from .. import helpers from .",
"}, \"exclusive\": false, \"name\": \"shared\" } } } \"\"\" def t... |
[
"setuptools import find_packages, setup # allow setup.py to be run from any path",
"#!/usr/bin/env python # -*- coding: utf-8 -* import os from setuptools import find_packages,",
"utf-8 -* import os from setuptools import find_packages, setup # allow setup.py to",
":: Python :: 3', 'Programming Language :: Py... |
[
"size=_max_receive_size): if self.on_read is not None: self.on_read() return self.receive_buffer.popleft() class ClientTests(unittest.TestCase): def setUp(self):",
"is not None: self.on_read() return self.receive_buffer.popleft() class ClientTests(unittest.TestCase): def setUp(self): self.client = driver.Client(_... |
[
"categorical_var = bank.select_dtypes(include = 'object') print(categorical_var) numerical_var = bank.select_dtypes(include = 'number') print(numerical_var) #",
"# Import packages import numpy as np import pandas as pd from scipy.stats",
"i in range(len(loan_terms)) if loan_term.value_counts().index[i] >= 25] #... |
[
"build_design_matrices, PatsyError, Origin) def test_issue_11(): # Give a sensible error message for level",
"try: build_design_matrices([info.design_info], new_data) except PatsyError as e: assert e.origin == Origin(formula, 0, 4)",
"# This file is part of Patsy # Copyright (C) 2013 <NAME> <<EMAIL>>",
"dmatr... |
[
"'A' in image.mode: frame = image.convert('RGBA') elif image.mode == 'CMYK': frame = image.convert('RGB')",
"image.seek(i) except EOFError: break frame = image if img_num is not None and",
"an array with R, G, B columns palette = np.asarray(pil_image.getpalette()).reshape((256, 3)) # Not",
"= 'I;16' mode_base... |
[
"utf-8 -*- \"\"\" Linear chain of reactions. \"\"\" from __future__ import print_function, division",
"/ (1 + S1 + S2); J2: S2 -> S3; (10 * S2",
"0; S2 = 0; S3 = 0; S4 = 0; X0 = 10;",
"X1 = 0; // Variable initialization: VM1 = 10; Keq1 = 10; h",
"(10 * S3 - 2 * S4) / (1 + S3 + S4);",
"(KS4 + S4); // Speci... |
[
"UserUpdate from .transactions import Transaction, TransactionCreate, TransactionUpdate from .accounts import Account, AccountList, AccountSingle,",
"from .transactions import Transaction, TransactionCreate, TransactionUpdate from .accounts import Account, AccountList, AccountSingle, AccountCreate,",
"import Tr... |
[
"def __init__(self): super.test(Bar, self).__init__() class InvalidSuperCall(Foo): def __init__(self): super(InvalidSuperCall.__class__, self).__init__() def method_accepting_cls(cls, self):",
"cell found # (Exact exception would be 'RuntimeError: super(): __class__ cell not found')",
"to *not* see a warning ab... |
[
"labelencoder_X_6 = LabelEncoder() X[:, 6] = labelencoder_X_6.fit_transform(X[:, 6]) labelencoder_X_7 = LabelEncoder() X[:, 7]",
"LabelEncoder() X[:, 7] = labelencoder_X_7.fit_transform(X[:, 7]) labelencoder_X_9 = LabelEncoder() X[:, 9] = labelencoder_X_9.fit_transform(X[:,",
"LabelEncoder() X[:, 1] = labelenco... |
[
"data output_test = gcn(C_test[:-1], X_test[:-1], e_test) guess_test = t.argmax(output_test, dim=1) if eval_type ==",
"MAP_train, MRR_train, loss_train)) print(\"alpha/Tr/Ep %.2f/%d/%d. Val MAP/MRR %.16f/%.16f. Val loss %.16f.\" % (alpha,",
"[6,6,2], nonlin2=\"selu\") elif no_layers == 1: gcn = ehf.EmbeddingKWG... |
[
"_test_y = data[2][0], np.array(data[2][1]).reshape(len(data[2][1]), 1) return _train_x, _train_y, _val_x, _val_y, _test_x, _test_y if",
"_test_x, _test_y = data[2][0], np.array(data[2][1]).reshape(len(data[2][1]), 1) return _train_x, _train_y, _val_x, _val_y, _test_x, _test_y",
"import ELMClassifier from sklea... |
[
"97), 200) print('bob:', bob.uid) # socket communication kdc_host, kdc_port = 'localhost', 9999 bob_host,",
"msg: print(msg); sys.exit(1) # sock_with_kdc.shutdown(socket.SHUT_WR) # talk to bob try: sock_self = socket.socket(socket.AF_INET,",
"bob.uid) # socket communication kdc_host, kdc_port = 'localhost', 999... |
[
"taking_best: print(\"using best instead of latest\") model_path = os.path.join(config.out_dir, \"best_net.pytorch\") net.load_state_dict( torch.load(model_path, map_location=lambda",
"as archs from proj.utils.cluster.general import config_to_str, get_opt, update_lr from proj.utils.cluster.baselines.triplets impo... |
[
"nullable=False), sa.Column(\"created_at\", sa.DateTime(), nullable=True), sa.Column(\"updated_at\", sa.DateTime(), nullable=True), sa.ForeignKeyConstraint( [\"job_id\"], [\"jobs.id\"], ), sa.PrimaryKeyConstraint(\"id\"), )",
"sa.DateTime(), nullable=True), sa.Column(\"updated_at\", sa.DateTime(), nullable=True),... |
[
"def test_otpauth_url(self): url = urlparse(self.user_settings.otpauth_url) assert_equal(url.scheme, 'otpauth') assert_equal(url.netloc, 'totp') assert_equal(url.path, '/RDM:{}'.format(self.user.username)) assert_equal( parse_qs(url.query),",
"can test it was changed back. self.user_settings.totp_drift = 1 self.u... |
[
"class TransformWhileSampling(object): def __init__(self, transform): self.transform = transform def __call__(self, sample): x1 =",
"as np from torchvision import transforms np.random.seed(1) class TransformWhileSampling(object): def __init__(self, transform): self.transform",
"def __init__(self, transform): se... |
[
"for pth in os.listdir(model_dir)] # if len(pths) <= 2: # return # os.system('rm",
"import colored from .logger import get_logger def save_model(net, optim, scheduler, recorder, is_best=False): model_dir",
"else epoch torch.save({ 'net': net.state_dict(), 'optim': optim.state_dict(), 'scheduler': scheduler.stat... |
[
"import AppConfig #pragma: no cover class HexafuelOilAppConfig(AppConfig): #pragma: no cover name = 'hexafuel_oil_app'",
"django.apps import AppConfig #pragma: no cover class HexafuelOilAppConfig(AppConfig): #pragma: no cover name =",
"from django.apps import AppConfig #pragma: no cover class HexafuelOilAppConf... |
[
"+= 1 elif value > minSuitability*0.1: vs_candidates += 1 total += value check.append(column+1)",
"postings] postCompetencies = [lists[7:10] for lists in postings] postSecurity = [lists[10] for lists",
"as f: #gives first column ie candidate a a=totalMatrix[:,[0]] #b = totalMatrix[:,[0]] #print(a)",
"% tenpc_... |
[
"re from setuptools import setup, find_packages ################################################################### NAME = \"pysyrenn\" PACKAGES = [",
"OS Independent\", \"Programming Language :: Python\", \"Programming Language :: Python :: 2\", \"Programming",
"script for PySyReNN. Adapted from: https://hynek... |
[] |
[
"import importlib def load(name, path): \"\"\"Load and initialize a module implemented as a",
"path): \"\"\"Load and initialize a module implemented as a Python source file and",
"imp import importlib def load(name, path): \"\"\"Load and initialize a module implemented as",
"load(name, path): \"\"\"Load and i... |
[
"width, there is nothing to # do if any(i[0] == [] for i",
"dtype[key] if isinstance(key, slice): key = key.start if key is None or key",
"if isinstance(key, slice): key = key.start if key is None or key ==",
"dtype = s.in_ports[0].dtype out_type = s.out_ports[0].dtype slices = list( map( partial(index_to_sv_... |
[
"= {} hold_thresh = 5 score_thresh = 0.001 x_axises, y_axises, mark_points, money =",
".add_xaxis(xaxis_data=x_axises) .add_yaxis( series_name=\"cur_money\", y_axis=money, is_smooth=True, linestyle_opts=opts.LineStyleOpts(opacity=0.5), label_opts=opts.LabelOpts(is_show=False), markline_opts=opts.MarkLineOpts( dat... |
[] |
[
"loss) if loss < best: best = loss best_t = epoch cnt_wait =",
"None) loss = b_xent(logits, lbl) print('Loss:', loss) if loss < best: best =",
"torch.nn as nn import networkx as nx import time from embed_methods.dgi.models import DGI,",
"else: cnt_wait += 1 if cnt_wait == patience: print(\"epochs: \", epoch) ... |
[
"if tag.name == f\"v{version}\": keep_trying = False # Tag now exists break if",
"= parser.parse_args() # Make sure our cwd is the root of the repository",
"parser.parse_args() # Make sure our cwd is the root of the repository os.chdir(os.path.abspath(os.path.join(THIS_FILE_DIRECTORY,",
"keep_trying = True wh... |
[
"loss_mz_to=1000.0) -> SpectrumType: \"\"\"Derive losses based on precursor mass. Parameters ---------- spectrum_in: Input",
"---------- spectrum_in: Input spectrum. loss_mz_from: Minimum allowed m/z value for losses. Default is",
"Add losses which are within given boundaries mask = numpy.where((losses_mz >= lo... |
[
"name, content = item if \"type\" not in content: if \"$ref\" in content:",
"{...}}) :return: The schema name \"\"\" name, content = item content = content[\"items\"]",
"0, it is added to the schema name. :return: the corresponding schema name.",
"and schema_dict. :param json_type: the type in jsonschema :ret... |
[
"test_directory_pattern_filter(self): dpf = rf.directory_pattern_predicate(\"abc\") self.assertTrue(dpf(\"foo/babcd/bar/some.txt\")) self.assertTrue(dpf(\"/abc/bar/some.txt\")) self.assertTrue(dpf(\"/foo/bar/abc/some.txt\")) # self.assertFalse(dpf(\"/foo/bar/baz/abc.txt\")) # ## dpf =",
"self.assertTrue(dpf(\"/fo... |
[
"host.package('grafana').is_installed def test_service(host): \"\"\" Testing whether the service is running and enabled \"\"\"",
"def test_package(host): \"\"\" check if packages are installed \"\"\" assert host.package('grafana').is_installed def test_service(host):",
"testinfra.utils.ansible_runner.AnsibleRun... |
[
"8) and (2.9 * 10**4 <= RayleighNbrOverallDiameter <= 2.3 * 10**5): nnInT =",
"= self.cylinderDiameter + (2 * finRadius) self.ambAirTemp = ambAirTemp # degrees kelvin self.maxJunctionTemp",
"class variables. NOTE: all models are based off of the finSpacing variable NOTE:",
"+ (0.0154 * cdoD) - (0.0433 * cdoD*... |
[] |
[
"ownerWallet, idr): identity = Identity(identifier=idr) req = senderWallet.requestIdentity(identity, sender=senderWallet.defaultId) senderClient.submitReqs(req) def chk(): retrievedVerkey",
"def checkAbbrVerkeySize(verkey): # A base58 encoding of 32 bytes string can be either",
"def fetchFullVerkeyFromSovrin(lo... |
[
"isinstance(sp.date, str) assert isinstance(sp.datetime, datetime.datetime) assert isinstance(sp.v_bary, float) assert isinstance(sp.wave_units, str) assert isinstance(sp.flux_units,",
"isinstance(sp.raw_flux, np.ndarray) assert len(sp.raw_wave) == len(sp.raw_bary_wave) assert len(sp.raw_wave) == len(sp.raw_flux)... |
[
"device: %s' % quote(device or '')) elif invalid_partition: raise ValueError('Invalid partition: %s' %",
"directory :param devices: parent directory of the devices to be audited :param datadir:",
":param account: Account :param container: Container :param object: Object :param raw_digest: If True,",
"if mount... |
[
"_g_cache return _g_cache def buildCache(): vehiclesByLevel = {} vehiclesByTag = {'beast': set(),'sinai': set(),'patton':",
"Embedded file name: scripts/common/dossiers2/custom/cache.py import nations from items import vehicles def getCache(): global",
"scripts/common/dossiers2/custom/cache.py import nations fr... |
[
"input_file + ' does not exist') sys.exit(1) input_code = open(input_file, 'r').read() if input_code[len(input_code)-1]",
"''' parsed.append(p.slice) p[0] = TreeNode('assign_op', p[1], 'OPERATOR') return def p_IfStmt(p): '''IfStmt : IF",
"SymbolTable() var_list = [] generated = {'temp': [], 'scope': ['scope_0']... |
[
"0.2*green red = 0.1 + 0.8*red + green**3 green = 0.2 + 0.21*green",
"(2560, 1440), \"1080p\": (1920, 1080), \"720p\": (1280, 720), \"480p\": (854, 480), \"360p\": (640,",
"in range(max_iter): # cut_buf[i] *= 0.05**args.dt bg = (im < 0) im /=",
"= [channel + random(channel.shape)*dither for channel in rgb] if... |
[
"anyio.run(SubscribePacket.from_stream, stream) (topic, qos) = message.payload.topics[0] self.assertEqual(topic, 'a/b') self.assertEqual(qos, QOS_1) (topic, qos) =",
"hbmqtt.mqtt.packet import PacketIdVariableHeader from hbmqtt.mqtt.constants import QOS_1, QOS_2 from hbmqtt.adapters import BufferAdapter class",
... |
[
"logger.info(\"***** Running training *****\") logger.info(\" Num orig examples = %d\", len(train_examples)) logger.info(\" Num",
"or n_gpu > 1: if args.local_rank != -1: raise NotImplementedError elif n_gpu >",
"exists and is not empty.\") if args.gradient_accumulation_steps < 1: raise ValueError(\"Invalid gra... |
[
"'max_timesteps': int(4e7), 'reward_floor': -20.7, 'reward_ceiling': 21.0, }, { 'env_id': 'QbertNoFrameskip-v4', 'trials': 2, 'max_timesteps':",
"'max_timesteps': 6000000, 'reward_floor': -1000.0, 'reward_ceiling': 1000.0, }, ]) bandit_tasks = [] for n_arms",
"-1000.0, 'reward_ceiling': 1000.0, }, ]) register_b... |
[
"{} with open(fpath_conf_data) as f: for line in f: tokens = line.split() #",
"(data was copied from website into txt file) - number of samples: we",
"# Take files from all three data sets since we repartition anyway. fpaths",
"#!/usr/bin/env python3 # Copyright 2020 <NAME> # # Licensed under the Apache Licen... |
[
"auth_pk=request.data['auth_pk']): code = status.HTTP_201_CREATED post = Post.objects.latest(\"published\") data = PostSerializer(post).data else: code =",
"'POST',]) @authentication_classes([CustomAuthentication]) @permission_classes([AccessPermission]) def commentListView(request, post_pk, auth_pk=None): page_n... |
[
"[[0.05, 0.1], [-0.9, 0.05]]]], 1, \"y\", [[[0.05, 0.1], [-0.9, 0.05]]], ('t','x','band')), ]) def",
"= execute_array_element_process(index=5) assert ex.value.args[0] == \"The argument 'index' in process 'array_element' is invalid:",
"xr import numpy as np sys.path.append(os.path.dirname(os.path.dirname(os.path... |
[
"// or set enable_profile_use property to false. cc_defaults { name: \"skia_pgo\", pgo: {",
"not s.endswith('.h')} dm_srcs = {s for s in dm_srcs if not s.endswith('.h')} nanobench_srcs",
"= {s for s in srcs if not s.endswith('.h')} dm_srcs = {s for",
"include directories. bp = string.Template('''// This file ... |
[
"tag # value says 'type' instead of 'kind'. TAG_RAY_NODE_KIND = \"ray-node-type\" NODE_KIND_HEAD =",
"multi # node type clusters. TAG_RAY_USER_NODE_TYPE = \"ray-user-node-type\" # Tag for autofilled node",
"# Tag for user defined node types (e.g., m4xl_spot). This is used for",
"for user defined node types (e... |
[
"y)) for x in range(1, world.width - 1): borders_total_elevation += world.elevation_at((x, 0)) borders_total_elevation",
"@staticmethod def _mean_elevation_at_borders(world): borders_total_elevation = 0.0 for y in range(world.height): borders_total_elevation += world.elevation_at((0,",
"from worldengine.world i... |
[
"net(inputs.cuda()) assert output.shape == (2, 1) # pretrained should be str or None",
"assert output.shape == (2, 1) # pretrained should be str or None with",
"import MaxFeature def test_max_feature(): # cpu conv2d = MaxFeature(16, 16, filter_type='conv2d') x1 =",
"in_channels=3) net = build_component(cfg) n... |
[
"'ssl_keyfile or other certificate-related inputs shall be defined Usage: Connection is activated not",
"class Consumer: GROUP_ID = 'web_metrics_consumer' CLIENT_ID = 'website-monitoring-consumer-service' def __init__( self, *topics, **connection_kwargs",
"**connection_kwargs ): \"\"\"Class for creating Kafka c... |
[
"out = self.bn4(out) out = self.relu4(out) out = self.dpout(out) out = self.conv5(out) out",
"= 64 # layer2 = build_resblock(filters_num[6], layer_dims[1], stride=2) # filters_num = 128 #",
"self.bn2 = layers.BatchNormalization() ############################### 注意力机制 ############################### self.ca = Ch... |
[
"Python 2 is even more evil, because it catches ALL exceptions. Therefore this",
"without dependencies. \"\"\" import sys import contextlib import functools import re import os",
"def next(self): \"\"\" Python 2 Compatibility \"\"\" return self.__next__() def __next__(self): if self.pushes:",
"or some code in... |
[
"1. Run Bioconductor Software package transition 2. Run Bioconductor Experiment Data package transition",
"software packages Manual tasks which need to be done: 1. Copy over bare",
"--> Git transition can be run in a sequential manner. It runs the",
"logging.basicConfig(filename='transition.log', format='%(le... |
[
"a sequence of keys derived from the function itself and the arguments passed",
"async_creator) as value: return value def get_or_create_multi( self, keys, creator, expiration_time=None, should_cache_fn=None): \"\"\"Return",
"or not. If it returns False, the value is still returned, but isn't",
"region.get_or... |
[
"Deze functie voert alle versies uit zodat deze vergeleken kunnen worden qua timing.",
"= import_module(version) montecarlo.simulatie(100,50) #Deze waarden dienen enkel als test if __name__ == \"__main__\":",
"-*- \"\"\" Module projectparallelprogrammeren.codesimulatie ==========================================... |
[
"# the encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self):",
"encrypted, b\"\\x97\\x92+\\xe5\\x0b\\xc3\\x18\\x91ky9m&\\xb3\\xb5@\\xe6'\\xc2\\x96.\\xc8u\\x88\\xab9-[\\x9e|\\xf1\\xcd\") def test_decrypt_text(self): password = intlist_to_bytes(... |
[
"https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import scrapbook as sb from utils_cv.common.data",
"kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps[\"keypoints\"].data) == len( nb_output.scraps[\"bboxes\"].data ... |
[
"dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10])",
"for a batch size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config",
"[ '../retinanet_r50_fpn_1x_... |
[] |
[
"import os import pytest import pandas as pd import numpy as np from",
"as pd import numpy as np from os import path from sklearn import",
"from cognito.check import Check from cognito.table import Table import os import pytest import",
"from cognito.table import Table import os import pytest import pandas as... |