Esiste una libreria di caching Python?

Question

Sto cercando una libreria di cache di Python ma non riesco a trovare nulla finora. Ho bisogno di una semplice interfaccia dict -like dove posso impostare le chiavi e la loro scadenza e recuperarle nella cache. Un po 'qualcosa di simile:

cache.get(myfunction, duration=300) 

che mi darà la voce dalla cache se esiste o chiamare la funzione e conservarlo se lo fa non è o è scaduta. Qualcuno sa qualcosa del genere?

Answer 1

Date un'occhiata a Beaker:

• Home Page
• Caching Documentation
• Good quick-start article about using Beaker with Django (but useful in any other apps too)

Answer 2

Credo the python memcached API è lo strumento prevalente, ma non l'ho usato io stesso e non sono sicuro se supporta le funzionalità necessarie.

Answer 3

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) 

Answer 4

Si potrebbe anche dare un'occhiata al Memoize decorator. Probabilmente potresti farlo fare ciò che vuoi senza troppe modifiche.

Answer 5

Guarda gocept.cache

Answer 6

Look at bda.cache http://pypi.python.org/pypi/bda.cache - utilizza ZCA ed è testato con Zope e bfg.

Answer 7

Try redis, è una delle soluzioni più semplici e pulite per le applicazioni per condividere dati in modo atomico o se si dispone di una piattaforma di server web. È molto facile da configurare, è necessario un client python redis http://pypi.python.org/pypi/redis

Answer 8

È possibile utilizzare la mia soluzione semplice al problema. E 'davvero semplice, niente di speciale:

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] 

Manca infatti la scadenza funcionality, ma si può facilmente estendere con specificando una particolare regola in MemCache c-tor.

Il codice di speranza è abbastanza auto-esplicativo, ma in caso contrario, solo per citare, quella cache viene passata una funzione di traduzione come uno dei suoi parametri c-tor. A sua volta è usato per generare output in cache per quanto riguarda l'input.

Speranza che aiuta

Answer 9

Joblibhttp://packages.python.org/joblib/ supporta le funzioni di caching nel modello Memoize. Principalmente, l'idea è di memorizzare le funzioni computazionalmente costose.

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

Puoi anche fare cose di fantasia come usare il decoratore @ memory.cache sulle funzioni. La documentazione è qui: http://packages.python.org/joblib/memory.html

Answer 10

keyring è la migliore libreria di cache di Python. È possibile utilizzare

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

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

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

Answer 11

Da Python 3.2 è possibile utilizzare il decoratore @lru_cache dalla libreria functools. Si tratta di una cache utilizzata di recente, quindi non c'è tempo di scadenza per gli elementi in essa contenuti, ma come un attacco rapido è molto 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) 

Answer 12

Nessuno ha ancora accennato. https://docs.python.org/2/library/shelve.html

Non è memcached, ma sembra molto più semplice e potrebbe soddisfare le vostre necessità.