¿Existe una biblioteca de almacenamiento en caché de Python?

Estoy buscando una biblioteca de almacenamiento en caché de Python pero no puedo encontrar nada hasta ahora. Necesito una dictinterfaz sencilla en la que pueda configurar las claves y su caducidad y volver a almacenarlas en caché. Algo así como:

cache.get(myfunction, duration=300)

que me dará el elemento del caché si existe o llamará a la función y lo almacenará si no lo hace o ha expirado. ¿Alguien sabe algo como esto?

Eche un vistazo a Beaker:

• Página de inicio
• Documentación de almacenamiento en caché
• Buen artículo de inicio rápido sobre el uso de Beaker con Django (pero también útil en cualquier otra aplicación)

Desde Python 3.2 puede usar el decorador @lru_cache de la biblioteca functools. Es un caché de último uso reciente, por lo que no hay tiempo de vencimiento para los elementos que contiene, pero como un truco rápido es muy útil.

from functools import lru_cache

@lru_cache(maxsize=256)
def f(x):
  return x*x

for x in range(20):
  print f(x)
for x in range(20):
  print f(x)

También puede echar un vistazo al decorador Memoize . Probablemente podrías conseguir que haga lo que quieras sin demasiadas modificaciones.

Joblib https://joblib.readthedocs.io admite funciones de almacenamiento en caché en el patrón Memoize. Principalmente, la idea es almacenar en caché funciones computacionalmente costosas.

>>> from joblib import Memory
>>> mem = Memory(cachedir='/tmp/joblib')
>>> import numpy as np
>>> square = mem.cache(np.square)
>>> 
>>> a = np.vander(np.arange(3)).astype(np.float)
>>> b = square(a)                                   
________________________________________________________________________________
[Memory] Calling square...
square(array([[ 0.,  0.,  1.],
       [ 1.,  1.,  1.],
       [ 4.,  2.,  1.]]))
___________________________________________________________square - 0...s, 0.0min

>>> c = square(a)

También puedes hacer cosas sofisticadas como usar el decorador @ memory.cache en funciones. La documentación está aquí: https://joblib.readthedocs.io/en/latest/generated/joblib.Memory.html

Nadie ha mencionado la estantería todavía. https://docs.python.org/2/library/shelve.html

No está almacenado en Memcached, pero parece mucho más simple y podría adaptarse a sus necesidades.

Creo que la API memcached de Python es la herramienta predominante, pero no la he usado yo mismo y no estoy seguro de si es compatible con las funciones que necesita.

import time

class CachedItem(object):
    def __init__(self, key, value, duration=60):
        self.key = key
        self.value = value
        self.duration = duration
        self.timeStamp = time.time()

    def __repr__(self):
        return '<CachedItem {%s:%s} expires at: %s>' % (self.key, self.value, time.time() + self.duration)

class CachedDict(dict):

    def get(self, key, fn, duration):
        if key not in self \
            or self[key].timeStamp + self[key].duration < time.time():
                print 'adding new value'
                o = fn(key)
                self[key] = CachedItem(key, o, duration)
        else:
            print 'loading from cache'

        return self[key].value



if __name__ == '__main__':

    fn = lambda key: 'value of %s  is None' % key

    ci = CachedItem('a', 12)
    print ci 
    cd = CachedDict()
    print cd.get('a', fn, 5)
    time.sleep(2)
    print cd.get('a', fn, 6)
    print cd.get('b', fn, 6)
    time.sleep(2)
    print cd.get('a', fn, 7)
    print cd.get('b', fn, 7)

Puedes usar mi sencilla solución al problema. Es realmente sencillo, nada sofisticado:

class MemCache(dict):
    def __init__(self, fn):
        dict.__init__(self)
        self.__fn = fn

    def __getitem__(self, item):
        if item not in self:
            dict.__setitem__(self, item, self.__fn(item))
        return dict.__getitem__(self, item)

mc = MemCache(lambda x: x*x)

for x in xrange(10):
    print mc[x]

for x in xrange(10):
    print mc[x]

De hecho, carece de funcionalidad de caducidad, pero puede ampliarla fácilmente especificando una regla particular en MemCache c-tor.

El código de Hope se explica por sí mismo, pero si no, solo para mencionar, que a la caché se le está pasando una función de traducción como uno de sus parámetros de c-tor. Se usa a su vez para generar una salida en caché con respecto a la entrada.

Espero eso ayude

Prueba redis, es una de las soluciones más limpias y sencillas para que las aplicaciones compartan datos de forma atómica o si tienes alguna plataforma de servidor web. Es muy fácil de configurar, necesitará un cliente python redis http://pypi.python.org/pypi/redis

Mire gocept.cache en pypi, administre el tiempo de espera.

Este proyecto tiene como objetivo proporcionar "Almacenamiento en caché para humanos" (aunque parece que es bastante desconocido)

Alguna información de la página del proyecto:

Instalación

caché de instalación de pip

Uso:

import pylibmc
from cache import Cache

backend = pylibmc.Client(["127.0.0.1"])

cache = Cache(backend)

@cache("mykey")
def some_expensive_method():
    sleep(10)
    return 42

# writes 42 to the cache
some_expensive_method()

# reads 42 from the cache
some_expensive_method()

# re-calculates and writes 42 to the cache
some_expensive_method.refresh()

# get the cached value or throw an error
# (unless default= was passed to @cache(...))
some_expensive_method.cached()

Mire bda.cache http://pypi.python.org/pypi/bda.cache : usa ZCA y se prueba con zope y bfg.

keyring es la mejor biblioteca de almacenamiento en caché de Python. Puedes usar

keyring.set_password("service","jsonkey",json_res)

json_res= keyring.get_password("service","jsonkey")

json_res= keyring.core.delete_password("service","jsonkey")