`CacheToolsUtils`

CacheTools Utilities. This code is public domain.

Module Contents

Classes

`DebugCache`	Debug class.
`DictCache`	Cache class based on dict.
`LockedCache`	Cache class with a lock.
`PrefixedCache`	Cache class to add a key prefix.
`StatsCache`	Cache class to keep stats.
`TwoLevelCache`	Two-Level Cache class for CacheTools.
`JsonSerde`	JSON serialize/deserialize class for MemCached (`pymemcache`).
`MemCached`	MemCached-compatible wrapper class for cachetools with key encoding.
`PrefixedMemCached`	MemCached-compatible wrapper class for cachetools with a key prefix.
`StatsMemCached`	Cache MemCached-compatible class with stats.
`RedisCache`	Redis TTL-ed wrapper for cachetools (`redis`).
`PrefixedRedisCache`	Prefixed Redis wrapper class for cachetools.
`StatsRedisCache`	TTL-ed Redis wrapper class for cachetools.

Functions

`cached`(cache, args, *kwargs)	Extended decorator with delete and exists.
`cacheMethods`(cache, obj[, gen])	Cache some object methods.
`cacheFunctions`(cache, globs[, gen])	Cache some global functions, with a prefix.

class CacheToolsUtils.DebugCache(cache: MutableMapping, log: logging.Logger, name='cache')

Bases: MutableMapping

Debug class.

Parameters:

cache – actual cache
log – logging instance
name – name of instance for output

clear(): D.clear() -> None. Remove all items from D.

class CacheToolsUtils.DictCache

Bases: _MutMapMix, MutableMapping

Cache class based on dict.

clear(): D.clear() -> None. Remove all items from D.

class CacheToolsUtils.LockedCache(cache: MutableMapping, lock)

Bases: _MutMapMix, _StatsMix, _RedisMix, MutableMapping

Cache class with a lock.

Parameters:

cache – actual cache.
lock – lock (context manager) to use

The locked layer should be the last one before the actual cache.

class CacheToolsUtils.PrefixedCache(cache: MutableMapping, prefix: str | bytes = '')

Bases: _KeyMutMapMix, _StatsMix, MutableMapping

Cache class to add a key prefix.

Parameters:

cache – actual cache.
prefix – prefix to prepend to keys.

class CacheToolsUtils.StatsCache(cache: MutableMapping)

Bases: _MutMapMix, MutableMapping

Cache class to keep stats.

Parameters:: cache – actual cache.

Note that CacheTools cached decorator with info=True provides hits, misses, maxsize and currsize information. However, this only works for its own classes.

hits(): Return the cache hit ratio.

reset(): Reset internal stats data.

clear(): D.clear() -> None. Remove all items from D.

class CacheToolsUtils.TwoLevelCache(cache: MutableMapping, cache2: MutableMapping, resilient=False)

Bases: _MutMapMix, MutableMapping

Two-Level Cache class for CacheTools.

Parameters:

cache – first (smaller, shorter TTL) cache
cache2 – second (larger, longer TTL) cache
resilient – whether to ignore cache2 failures

clear(): D.clear() -> None. Remove all items from D.

CacheToolsUtils.cached(cache, *args, **kwargs)

Extended decorator with delete and exists.

All parameters are forwarded to cachetools.cached.

Parameters:: cache – actual cache.

If f(*args, **kwargs) is the cached function, then:

f.cache_in(*args, **kwargs) tells whether the result is cached.
f.cache_del(*args, **kwargs) deletes (invalidates) the cached result.

CacheToolsUtils.cacheMethods(cache: MutableMapping, obj: Any, gen: MapGen = PrefixedCache, **funs)

Cache some object methods.

Parameters:

cache – cache to use.
obj – object instance to be cached.
gen – generator of PrefixedCache.
funs – name of methods and corresponding prefix

cacheMethods(cache, item, PrefixedCache, compute1="c1.", compute2="c2.")

CacheToolsUtils.cacheFunctions(cache: MutableMapping, globs: MutableMapping[str, Any], gen: MapGen = PrefixedCache, **funs)

Cache some global functions, with a prefix.

Parameters:

cache – cache to use.
globs – global object dictionary.
gen – generator of PrefixedCache.
funs – name of functions and corresponding prefix

cacheFunctions(cache, globals(), PrefixedCache, fun1="f1.", fun2="f2.")

class CacheToolsUtils.JsonSerde

JSON serialize/deserialize class for MemCached (pymemcache).

import pymemcache as pmc
import CacheToolsUtils as ctu
pmc_cache = pmc.Client(server="localhost", serde=ctu.JsonSerde())

class CacheToolsUtils.MemCached(cache)

Bases: _KeyMutMapMix, MutableMapping

MemCached-compatible wrapper class for cachetools with key encoding.

Parameters:: cache – actual memcached cache.

import pymemcache as pmc
import CacheToolsUtils as ctu
cache = ctu.MemCached(pmc.Client(server="localhost", serde=ctu.JsonSerde()))

@ctu.cached(cache=cache)
def whatever(...):

stats() → dict[str, Any]: Return MemCached stats.

clear(): Flush MemCached contents.

hits() → float: Return overall cache hit ratio.

class CacheToolsUtils.PrefixedMemCached(cache, prefix: str = '')

Bases: MemCached

MemCached-compatible wrapper class for cachetools with a key prefix.

Parameters:

cache – actual memcached cache.
prefix – post key-encoding prepended prefix.

import pymemcache as pmc
import CacheToolsUtils as ctu
# add a "app." prefix to keys, after serialization
cache = ctu.PrefixedMemCached(pmc.Client(server="localhost", serde=ctu.JsonSerde()), "app.")

class CacheToolsUtils.StatsMemCached(cache)

Bases: MemCached

Cache MemCached-compatible class with stats.

This class is empty and only kept for compatibility.

class CacheToolsUtils.RedisCache(cache, ttl=600)

Bases: MutableMapping

Redis TTL-ed wrapper for cachetools (redis).

Parameters:

cache – actual redis cache.
ttl – time-to-live in seconds, used as default expiration (ex), default is 600.

Keys and values are serialized in JSON.

import redis
import CacheToolsUtils as ctu
# redis with 1 hour expiration
cache = ctu.RedisCache(redis.Redis(host="localhost"), 3600)

clear(): Flush Redis contents.

info(*args, **kwargs): Return redis informations.

dbsize(*args, **kwargs): Return redis database size.

set(index, value, **kwargs): Set cache contents.

get(index, default=None): Get cache contents.

delete(index): Delete cache contents.

hits(): Return cache hits.

class CacheToolsUtils.PrefixedRedisCache(cache, prefix: str = '', ttl=600)

Bases: RedisCache

Prefixed Redis wrapper class for cachetools.

Parameters:

cache – actual redis cache.
prefix – post key encoding prefix, default is empty.
ttl – time-to-live in seconds, used as default expiration (ex), default is 600.

import redis
import CacheToolsUtils as ctu
# redis with "app." prefix and 1 hour expiration
cache = ctu.PrefixedRedisCache(redis.Redis(host="localhost"), "app.", 3600)

class CacheToolsUtils.StatsRedisCache(cache, prefix: str = '', ttl=600)

Bases: PrefixedRedisCache

TTL-ed Redis wrapper class for cachetools.

This class is empty and only kept for compatibility.

CacheToolsUtils

Module Contents

Classes

Functions

`CacheToolsUtils`