supercache

supercache

Almacenamiento en caché fácil de usar para funciones y métodos.

supercache ha sido diseñado como un decorador para trabajar con funciones y métodos, para proporcionar ejecuciones repetidas casi instantáneas con solo una línea adicional de código. Actúa como una interfaz para el motor de caché, que puede ser cualquier cosa, desde el almacenamiento en caché en la memoria hasta el uso de Redis (siempre que haya sido codificado).

Tenga en cuenta que el uso del decorador agrega una pequeña cantidad de gastos generales, ya que fue diseñado para brindar comodidad y estabilidad sobre el rendimiento. Es posible que el almacenamiento en caché de una función muy simple pueda dar lugar a un peor rendimiento (aproximadamente tarda 1 segundo por cada 40.000 ejecuciones).

Instalación

 pip install supercache

Uso

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

Tipos admitidos

 # 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 )

Referencia de API

@cache( claves=Ninguno, ignorar=Ninguno, ttl=Ninguno, precalcular=Falso )

llaves

Establezca qué parámetros de la función utilizar para generar la clave de caché. Todos los parámetros disponibles se utilizarán de forma predeterminada.

Estos pueden tener el formato int , str , slice (útil para *args ) o regex (útil para **kwargs )

ignorar

Establezca qué parámetros ignorar al generar la clave de caché. Esto anulará cualquier configuración proporcionada en keys .

Estos también pueden tener el formato int , str , slice o regex

ttl

Anule la configuración ttl del motor para establecer cuántos segundos faltan para que se invalide el caché.

precalcular

Si la función que se almacena en caché es un generador, establecer esto en True convertirá la salida en una tuple cuando se llame por primera vez, en lugar de devolver el iterador.

La razón de esto es que el almacenamiento en caché del generador tiene una gran sobrecarga, lo que podría volverse muy notable al llamar a un generador simple miles de veces.

caché.get( clave ):

Alias: cache[key]

Leer un elemento de caché o generar un error si no existe.

cache.put( clave,valor,**kwargs ):

Alias: cache[key] = value

Establecer un nuevo elemento de caché.

cache.delete( clave=Ninguno, *args, **kwargs )

Alias: del cache[key]

Eliminar caché de una clave o función.

• cache.delete() : elimina todos los datos almacenados en caché.
• cache.delete(key) : elimina los datos almacenados en caché para una key específica.
• cache.delete(func) : elimina los datos almacenados en caché para cada ejecución de func .
• cache.delete(func, 1, b=2) : elimina los datos almacenados en caché para func(1, b=2) .

cache.hits( clave=Ninguno, *args, **kwargs )

Devuelve un recuento de cuántas veces se leyó el caché para una clave o función.

• cache.hits() : Número total de aciertos de caché.
• cache.hits(key) : número de visitas para una key específica.
• cache.hits(func) : número de aciertos de caché para cada ejecución de func .
• cache.hits(func, 1, b=2) : número de aciertos de caché específicamente para func(1, b=2) .

cache.misses( clave=Ninguno, *args, **kwargs )

Devuelve un recuento de cuántas veces se generó el caché para una clave o función.

• cache.misses() : Número total de errores de caché.
• cache.misses(key) : número de errores para una key específica.
• cache.misses(func) : número de errores de caché por cada ejecución de func .
• cache.misses(func, 1, b=2) : número de errores de caché específicamente para func(1, b=2) .

caché.existe( clave=Ninguno, *args, **kwargs )

Obtenga si el caché existe para una clave o función.

• cache.exists() : si existe algún caché.
• cache.exists(key) : si key existe en la caché.
• cache.exists(func) : si existe alguna ejecución de func en la caché.
• cache.exists(func, 1, b=2) : si func(1, b=2) existe en la caché.

motor.Memoria( modo=LRU, ttl=Ninguno, recuento=Ninguno, tamaño=Ninguno )

Modo

Configure el modo para purgar el caché. Las opciones son FIFO (primero en entrar, primero en salir), FILO (primero en entrar, último en salir), LRU (usado menos recientemente), MRU (usado más recientemente) o LFU (usado con menos frecuencia).

ttl

Establezca cuántos segundos hasta que se invalide el caché.

contar

Establezca la cantidad máxima de resultados almacenados en caché.

tamaño

Establezca el tamaño máximo de la caché en bytes. Este es un límite flexible, donde la memoria se asignará primero y luego se eliminará el caché más antiguo hasta que vuelva a estar por debajo del límite.

La última ejecución siempre se almacenará en caché, incluso si el tamaño máximo se establece en un tamaño menor que el resultado.

Planificado

• Soporte para SQLite
• Soporte para memcache
• Soporte para Redis

Limitaciones

• No se puede almacenar en caché si se utilizan argumentos que no se pueden dividir
• Python asignará el mismo hash a dos clases con la misma herencia si ambas se inicializan en la misma línea (afortunadamente, esto nunca debería suceder fuera de las pruebas)
• classmethods , staticmethods y properties solo se pueden almacenar en caché si el decorador de caché se ejecuta primero.