ftrack_api.cache

Caching framework.

Defines a standardised Cache interface for storing data against specific keys. Key generation is also standardised using a KeyMaker interface.

Combining a Cache and KeyMaker allows for memoisation of function calls with respect to the arguments used by using a Memoiser.

As a convenience a simple memoise() decorator is included for quick memoisation of function using a global cache and standard key maker.

class ftrack_api.cache.Cache

Cache interface.

Derive from this to define concrete cache implementations. A cache is centered around the concept of key:value pairings where the key is unique across the cache.

abstract get(key)

Return value for key.

Raise KeyError if key not found.

abstract set(key, value)

Set value for key.

abstract remove(key)

Remove key and return stored value.

Raise KeyError if key not found.

keys()

Return list of keys at this current time.

Warning

Actual keys may differ from those returned due to timing of access.

values()

Return values for current keys.

clear(pattern=None)

Remove all keys matching pattern.

pattern should be a regular expression string.

If pattern is None then all keys will be removed.

__init__()

class ftrack_api.cache.ProxyCache(proxied)

Proxy another cache.

__init__(proxied)

Initialise cache with proxied cache instance.

get(key)

Return value for key.

Raise KeyError if key not found.

set(key, value)

Set value for key.

remove(key)

Remove key and return stored value.

Raise KeyError if key not found.

keys()

Return list of keys at this current time.

Warning

Actual keys may differ from those returned due to timing of access.

clear(pattern=None)

Remove all keys matching pattern.

pattern should be a regular expression string.

If pattern is None then all keys will be removed.

values()

Return values for current keys.

class ftrack_api.cache.LayeredCache(caches)

Layered cache.

__init__(caches)

Initialise cache with caches.

get(key)

Return value for key.

Raise KeyError if key not found.

Attempt to retrieve from cache layers in turn, starting with shallowest. If value retrieved, then also set the value in each higher level cache up from where retrieved.

set(key, value)

Set value for key.

remove(key)

Remove key.

Raise KeyError if key not found in any layer.

keys()

Return list of keys at this current time.

Warning

Actual keys may differ from those returned due to timing of access.

clear(pattern=None)

Remove all keys matching pattern.

pattern should be a regular expression string.

If pattern is None then all keys will be removed.

values()

Return values for current keys.

class ftrack_api.cache.MemoryCache

Memory based cache.

__init__()

Initialise cache.

get(key)

Return value for key.

Raise KeyError if key not found.

set(key, value)

Set value for key.

remove(key)

Remove key.

Raise KeyError if key not found.

keys()

Return list of keys at this current time.

Warning

Actual keys may differ from those returned due to timing of access.

clear(pattern=None)

Remove all keys matching pattern.

pattern should be a regular expression string.

If pattern is None then all keys will be removed.

values()

Return values for current keys.

class ftrack_api.cache.FileCache(path)

File based cache that uses anydbm module.

Note

No locking of the underlying file is performed.

__init__(path)

Initialise cache at path.

get(key)

Return value for key.

Raise KeyError if key not found.

set(key, value)

Set value for key.

remove(key)

Remove key.

Raise KeyError if key not found.

keys()

Return list of keys at this current time.

Warning

Actual keys may differ from those returned due to timing of access.

clear(pattern=None)

Remove all keys matching pattern.

pattern should be a regular expression string.

If pattern is None then all keys will be removed.

values()

Return values for current keys.

class ftrack_api.cache.SerialisedCache(proxied, encode=None, decode=None)

Proxied cache that stores values as serialised data.

__init__(proxied, encode=None, decode=None)

Initialise cache with encode and decode callables.

proxied is the underlying cache to use for storage.

get(key)

Return value for key.

Raise KeyError if key not found.

set(key, value)

Set value for key.

clear(pattern=None)

Remove all keys matching pattern.

pattern should be a regular expression string.

If pattern is None then all keys will be removed.

keys()

Return list of keys at this current time.

Warning

Actual keys may differ from those returned due to timing of access.

remove(key)

Remove key and return stored value.

Raise KeyError if key not found.

values()

Return values for current keys.

class ftrack_api.cache.KeyMaker

Generate unique keys.

__init__()

Initialise key maker.

key(*items)

Return key for items.

class ftrack_api.cache.StringKeyMaker

Generate string key.

__init__()

Initialise key maker.

key(*items)

Return key for items.

class ftrack_api.cache.ObjectKeyMaker

Generate unique keys for objects.

__init__()

Initialise key maker.

key(*items)

Return key for items.

class ftrack_api.cache.Memoiser(cache=None, key_maker=None, return_copies=True)

Memoise function calls using a KeyMaker and Cache.

Example:

>>> memoiser = Memoiser(MemoryCache(), ObjectKeyMaker())
>>> def add(x, y):
...     "Return sum of *x* and *y*."
...     print 'Called'
...     return x + y
...
>>> memoiser.call(add, (1, 2), {})
Called
>>> memoiser.call(add, (1, 2), {})
>>> memoiser.call(add, (1, 3), {})
Called

__init__(cache=None, key_maker=None, return_copies=True)

Initialise with cache and key_maker to use.

If cache is not specified a default MemoryCache will be used. Similarly, if key_maker is not specified a default ObjectKeyMaker will be used.

If return_copies is True then all results returned from the cache will be deep copies to avoid indirect mutation of cached values.

call(function, args=None, kw=None)

Call function with args and kw and return result.

If function was previously called with exactly the same arguments then return cached result if available.

Store result for call in cache.

ftrack_api.cache.memoise_decorator(memoiser)

Decorator to memoise function calls using memoiser.

ftrack_api.cache.memoiser = <ftrack_api.cache.Memoiser object>

Default memoiser.

ftrack_api.cache.memoise(function)

Default memoise decorator using standard cache and key maker.