supercache

supercache

Mise en cache facile à utiliser pour les fonctions et les méthodes.

supercache a été conçu comme un décorateur pour fonctionner avec des fonctions et des méthodes, afin de fournir des exécutions répétées presque instantanées avec une seule ligne de code supplémentaire. Il agit comme une interface avec le moteur de cache, qui peut aller de la mise en cache en mémoire à l'utilisation de Redis (à condition qu'il ait été codé).

Veuillez noter que l'utilisation du décorateur ajoute une petite quantité de frais généraux car il a été conçu pour plus de commodité et de stabilité par rapport aux performances. Il est possible que la mise en cache d'une fonction très simple entraîne de moins bonnes performances (cela prend environ 1 seconde pour 40 000 exécutions).

Installation

 pip install supercache

Usage

supercache import cache # Basic cache @cache() def function(x, y=None): return(x, y) # Set timeout @cache(ttl=60) def function(x, y=None): return(x, y) # Ignore the y argument @cache(ignore=['y']) def function(x, y=None): return(x, y) # Ignore anything after the first 2 arguments @cache(keys=[0, 1]) def function(x, y=None, *args, **kwargs): return(x, y) # Set up a custom cache engine from supercache .engine import Memory cache = Cache(engine=Memory(mode=Memory.FIFO, ttl=600, count=100000, size=100000)) # Manually handle cache to reduce the decorator overhead # This is in danger of collisions if the key is not unique from supercache .exceptions import CacheError def function(x, y=None): key = 'function;{};{}'.format(x, y) try: return cache.get(key) except CacheError: value = (x, y) cache.put(key, value) return value">

 from supercache import cache

# Basic cache
@ cache ()
def function ( x , y = None ):
    return ( x , y )

# Set timeout
@ cache ( ttl = 60 )
def function ( x , y = None ):
    return ( x , y )

# Ignore the y argument
@ cache ( ignore = [ 'y' ])
def function ( x , y = None ):
    return ( x , y )

# Ignore anything after the first 2 arguments
@ cache ( keys = [ 0 , 1 ])
def function ( x , y = None , * args , ** kwargs ):
    return ( x , y )


# Set up a custom cache engine
from supercache . engine import Memory

cache = Cache ( engine = Memory ( mode = Memory . FIFO , ttl = 600 , count = 100000 , size = 100000 ))


# Manually handle cache to reduce the decorator overhead
# This is in danger of collisions if the key is not unique
from supercache . exceptions import CacheError

def function ( x , y = None ):
    key = 'function;{};{}' . format ( x , y )
    try :
        return cache . get ( key )
    except CacheError :
        value = ( x , y )
        cache . put ( key , value )
        return value

Types pris en charge

 # Functions
@ cache ()
def function ():
    pass

# Methods
class Class ( object ):
    @ cache ()
    def method ( self ):
        pass

# Generators/iterators
@ cache ()
def generator ():
    yield

# Lambdas
func = cache ()( lambda : None )

Référence API

@cache( keys=Aucun, ignore=Aucun, ttl=Aucun, precalculate=False )

clés

Définissez les paramètres de la fonction à utiliser pour générer la clé de cache. Tous les paramètres disponibles seront utilisés par défaut.

Ceux-ci peuvent être au format int , str , slice (utile pour *args ) ou regex (utile pour **kwargs )

ignorer

Définissez les paramètres à ignorer lors de la génération de la clé de cache. Cela remplacera tous les paramètres fournis dans keys .

Ceux-ci peuvent également être au format int , str , slice ou regex

ttl

Remplacez le paramètre ttl du moteur pour définir le nombre de secondes jusqu'à ce que le cache soit invalidé.

précalculer

Si la fonction mise en cache est un générateur, définir ceci sur True convertira la sortie en tuple lors du premier appel, au lieu de renvoyer l'itérateur.

La raison en est que la mise en cache du générateur entraîne beaucoup de surcharge, ce qui peut devenir très visible lors de l'appel d'un simple générateur des milliers de fois.

cache.get( clé ):

Alias : cache[key]

Lit un élément du cache ou génère une erreur s'il n'existe pas.

cache.put( clé, valeur, **kwargs ) :

Alias : cache[key] = value

Définir un nouvel élément de cache.

cache.delete( key=Aucun, *args, **kwargs )

Alias : del cache[key]

Supprimer le cache d'une clé ou d'une fonction.

• cache.delete() : Supprime toutes les données mises en cache.
• cache.delete(key) : Supprimer les données mises en cache pour une key spécifique.
• cache.delete(func) : supprime les données mises en cache pour chaque exécution de func .
• cache.delete(func, 1, b=2) : supprime les données mises en cache pour func(1, b=2) .

cache.hits( key=Aucun, *args, **kwargs )

Renvoie le nombre de fois où le cache a été lu pour une clé ou une fonction.

• cache.hits() : nombre total d'accès au cache.
• cache.hits(key) : Nombre de hits pour une key spécifique.
• cache.hits(func) : Nombre d'accès au cache pour chaque exécution de func .
• cache.hits(func, 1, b=2) : Nombre d'accès au cache spécifiquement pour func(1, b=2) .

cache.misses( key=Aucun, *args, **kwargs )

Renvoie le nombre de fois où le cache a été généré pour une clé ou une fonction.

• cache.misses() : nombre total d'échecs de cache.
• cache.misses(key) : Nombre d'échecs pour une key spécifique.
• cache.misses(func) : Nombre d'échecs de cache pour chaque exécution de func .
• cache.misses(func, 1, b=2) : Nombre de cache manqués spécifiquement pour func(1, b=2) .

cache.exists( key=Aucun, *args, **kwargs )

Obtenez si le cache existe pour une clé ou une fonction.

• cache.exists() : Si un cache existe.
• cache.exists(key) : Si key existe dans le cache.
• cache.exists(func) : Si une exécution de func existe dans le cache.
• cache.exists(func, 1, b=2) : Si func(1, b=2) existe dans le cache.

moteur.Memory( mode=LRU, ttl=Aucun, count=Aucun, size=Aucun )

Mode

Définissez le mode de purge du cache. Les options sont FIFO (premier entré, premier sorti), FILO (premier entré, dernier sorti), LRU (le moins récemment utilisé), MRU (le plus récemment utilisé) ou LFU (le moins fréquemment utilisé).

ttl

Définissez le nombre de secondes jusqu'à ce que le cache soit invalidé.

compter

Définissez la quantité maximale de résultats mis en cache.

taille

Définissez la taille maximale du cache en octets. Il s'agit d'une limite souple, où la mémoire sera allouée en premier, puis l'ancien cache sera supprimé jusqu'à ce qu'il revienne sous la limite.

La dernière exécution sera toujours mise en cache, même si la taille maximale est inférieure au résultat.

Prévu

• Prise en charge de SQLite
• Prise en charge de Memcached
• Prise en charge de Redis

Limites

• Impossible de mettre en cache si des arguments impossibles à hacher sont utilisés
• Python attribuera le même hachage à deux classes avec le même héritage si elles sont toutes deux initialisées sur la même ligne (heureusement, cela ne devrait jamais arriver en dehors des tests)
• classmethods , staticmethods et properties ne peuvent être mises en cache que si le décorateur de cache est exécuté en premier