supercache

supercache

Cache fácil de usar para funções e métodos.

supercache foi projetado como um decorador para trabalhar com funções e métodos, para fornecer execuções repetidas quase instantâneas com apenas uma única linha extra de código. Ele atua como uma interface para o mecanismo de cache, que pode ser qualquer coisa, desde armazenamento em cache na memória até o uso do Redis (desde que tenha sido codificado).

Observe que o uso do decorador adiciona uma pequena sobrecarga, pois ele foi projetado para oferecer conveniência e estabilidade em relação ao desempenho. É possível que armazenar em cache uma função muito simples resulte em pior desempenho (leva aproximadamente 1 segundo a cada 40.000 execuções).

Instalação

 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 suportados

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

Referência de API

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

chaves

Defina quais parâmetros da função usar na geração da chave de cache. Todos os parâmetros disponíveis serão usados ​​por padrão.

Eles podem estar no formato int , str , slice (útil para *args ) ou regex (útil para **kwargs )

ignorar

Defina quais parâmetros ignorar ao gerar a chave de cache. Isso substituirá quaisquer configurações fornecidas em keys .

Eles também podem estar no formato int , str , slice ou regex

TTL

Substitua a configuração ttl do mecanismo para definir quantos segundos até que o cache seja invalidado.

pré-calcular

Se a função que está sendo armazenada em cache for um gerador, definir isso como True converterá a saída em uma tuple quando chamada pela primeira vez, em vez de retornar o iterador.

A razão para isso é que o cache do gerador tem muita sobrecarga, o que pode se tornar muito perceptível ao chamar um gerador simples milhares de vezes.

cache.get ( chave ):

Alias: cache[key]

Leia um item do cache ou gere um erro se ele não existir.

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

Alias: cache[key] = value

Defina um novo item de cache.

cache.delete( chave=Nenhum, *args, **kwargs )

Alias: del cache[key]

Exclua o cache de uma chave ou função.

• cache.delete() : Exclui todos os dados armazenados em cache.
• cache.delete(key) : Exclui dados armazenados em cache para uma key específica.
• cache.delete(func) : Exclui dados armazenados em cache para cada execução de func .
• cache.delete(func, 1, b=2) : Exclua os dados armazenados em cache para func(1, b=2) .

cache.hits( chave=Nenhum, *args, **kwargs )

Retorna uma contagem de quantas vezes o cache foi lido para uma chave ou função.

• cache.hits() : Número total de acessos ao cache.
• cache.hits(key) : Número de acessos para uma key específica.
• cache.hits(func) : Número de acessos ao cache para cada execução de func .
• cache.hits(func, 1, b=2) : Número de ocorrências de cache especificamente para func(1, b=2) .

cache.misses( chave=Nenhum, *args, **kwargs )

Retorna uma contagem de quantas vezes o cache foi gerado para uma chave ou função.

• cache.misses() : Número total de perdas de cache.
• cache.misses(key) : Número de falhas para uma key específica.
• cache.misses(func) : Número de perdas de cache para cada execução de func .
• cache.misses(func, 1, b=2) : Número de perdas de cache especificamente para func(1, b=2) .

cache.exists( chave=Nenhum, *args, **kwargs )

Obtenha se existe cache para uma chave ou função.

• cache.exists() : se existir algum cache.
• cache.exists(key) : se key existir no cache.
• cache.exists(func) : Se existir alguma execução de func no cache.
• cache.exists(func, 1, b=2) : Se func(1, b=2) existir no cache.

motor.Memory( modo=LRU, ttl=Nenhum, contagem=Nenhum, tamanho=Nenhum )

Modo

Defina o modo de limpeza do cache. As opções são FIFO (primeiro a entrar, primeiro a sair), FILO (primeiro a entrar, último a sair), LRU (usado menos recentemente), MRU (usado mais recentemente) ou LFU (usado com menos frequência).

TTL

Defina quantos segundos até o cache ser invalidado.

contar

Defina a quantidade máxima de resultados armazenados em cache.

tamanho

Defina o tamanho máximo do cache em bytes. Este é um limite flexível, onde a memória será alocada primeiro e, em seguida, o cache mais antigo será excluído até que esteja novamente abaixo do limite.

A última execução sempre será armazenada em cache, mesmo que o tamanho máximo seja menor que o resultado.

Planejado

• Suporte para SQLite
• Suporte para memcached
• Suporte para Redis

Limitações

• Não é possível armazenar em cache se argumentos não laváveis ​​forem usados
• Python atribuirá o mesmo hash a duas classes com a mesma herança se ambas forem inicializadas na mesma linha (felizmente isso nunca deveria acontecer fora dos testes)
• classmethods , staticmethods e properties só podem ser armazenados em cache se o decorador de cache for executado primeiro