Existe-t-il une bibliothèque de mise en cache Python?

Je recherche une bibliothèque de mise en cache Python mais je ne trouve rien pour l'instant. J'ai besoin d'une dictinterface simple où je peux définir les clés et leur expiration et les remettre en cache. Une sorte de quelque chose comme:

cache.get(myfunction, duration=300)

qui me donnera l'élément du cache s'il existe ou appellera la fonction et le stockera s'il n'existe pas ou s'il a expiré. Quelqu'un sait-il quelque chose comme ça?

Jetez un œil à Beaker:

• Page d'accueil
• Documentation de mise en cache
• Bon article de démarrage rapide sur l'utilisation de Beaker avec Django (mais utile dans toutes les autres applications également)

Depuis Python 3.2, vous pouvez utiliser le décorateur @lru_cache de la bibliothèque functools. C'est un dernier cache récemment utilisé, il n'y a donc pas de délai d'expiration pour les éléments qu'il contient, mais en tant que piratage rapide, il est très utile.

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)

Vous pouvez également jeter un œil au décorateur Memoize . Vous pourriez probablement le faire faire ce que vous voulez sans trop de modifications.

Joblib https://joblib.readthedocs.io prend en charge les fonctions de mise en cache dans le modèle Memoize. La plupart du temps, l'idée est de mettre en cache les fonctions coûteuses en calcul.

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

Vous pouvez également faire des choses fantaisistes comme utiliser le décorateur @ memory.cache sur les fonctions. La documentation est ici: https://joblib.readthedocs.io/en/latest/generated/joblib.Memory.html

Personne n'a encore mentionné les étagères. https://docs.python.org/2/library/shelve.html

Ce n'est pas memcached, mais semble beaucoup plus simple et pourrait répondre à vos besoins.

Je pense que l'API python memcached est l'outil le plus répandu, mais je ne l'ai pas utilisé moi-même et je ne suis pas sûr qu'il prenne en charge les fonctionnalités dont vous avez besoin.

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)

Vous pouvez utiliser ma solution simple au problème. C'est vraiment simple, rien d'extraordinaire:

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]

Il manque en effet de fonctionnalité d'expiration, mais vous pouvez facilement l'étendre en spécifiant une règle particulière dans MemCache c-tor.

J'espère que le code est suffisamment explicite, mais si ce n'est pas le cas, il suffit de mentionner que le cache reçoit une fonction de traduction comme l'un de ses paramètres c-tor. Il est utilisé à son tour pour générer une sortie mise en cache concernant l'entrée.

J'espère que ça aide

Essayez redis, c'est l'une des solutions les plus propres et les plus simples pour les applications pour partager des données de manière atomique ou si vous avez une plate-forme de serveur Web. C'est très facile à installer, vous aurez besoin d'un client python redis http://pypi.python.org/pypi/redis

Regardez gocept.cache sur pypi, gérez le délai d'expiration.

Ce projet vise à fournir une "mise en cache pour les humains" (cela semble assez inconnu cependant)

Quelques informations de la page du projet:

Installation

cache d'installation de pip

Usage:

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

Regardez bda.cache http://pypi.python.org/pypi/bda.cache - utilise ZCA et est testé avec zope et bfg.

keyring est la meilleure bibliothèque de mise en cache python. Vous pouvez utiliser

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

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

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