Gibt es eine Python-Caching-Bibliothek?

Ich suche nach einer Python-Caching-Bibliothek, kann aber bisher nichts finden. Ich brauche eine einfache dictOberfläche, in der ich Schlüssel und deren Ablauf festlegen und sie wieder zwischengespeichert bekommen kann. So etwas wie:

cache.get(myfunction, duration=300)

Dadurch bekomme ich das Element aus dem Cache, falls es vorhanden ist, oder rufe die Funktion auf und speichere es, wenn es nicht vorhanden ist oder abgelaufen ist. Kennt jemand so etwas?

Schauen Sie sich Beaker an:

• Startseite
• Caching-Dokumentation
• Guter Schnellstartartikel über die Verwendung von Beaker mit Django (aber auch in anderen Apps nützlich)

Ab Python 3.2 können Sie den Decorator @lru_cache aus der functools-Bibliothek verwenden. Es ist ein zuletzt verwendeter Cache, daher gibt es keine Ablaufzeit für die darin enthaltenen Elemente, aber als schneller Hack ist er sehr nützlich.

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)

Sie können sich auch den Memoize-Dekorateur ansehen . Sie könnten es wahrscheinlich dazu bringen, das zu tun, was Sie wollen, ohne zu viel Modifikation.

Joblib https://joblib.readthedocs.io unterstützt Caching-Funktionen im Memoize-Muster. Meistens besteht die Idee darin, rechenintensive Funktionen zwischenzuspeichern.

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

Sie können auch ausgefallene Dinge tun, wie den @ memory.cache-Dekorator für Funktionen. Die Dokumentation finden Sie hier: https://joblib.readthedocs.io/en/latest/generated/joblib.Memory.html

Noch hat niemand das Regal erwähnt. https://docs.python.org/2/library/shelve.html

Es ist nicht zwischengespeichert, sieht aber viel einfacher aus und passt möglicherweise zu Ihren Anforderungen.

Ich denke, die Python Memcached API ist das vorherrschende Tool, aber ich habe sie selbst nicht verwendet und bin mir nicht sicher, ob sie die von Ihnen benötigten Funktionen unterstützt.

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)

Sie können meine einfache Lösung für das Problem verwenden. Es ist wirklich unkompliziert, nichts Besonderes:

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]

Es fehlt zwar die Ablauffunktion, aber Sie können sie leicht erweitern, indem Sie eine bestimmte Regel in MemCache c-tor angeben.

Der Hoffnungscode ist selbsterklärend genug, aber wenn nicht, um nur zu erwähnen, wird dem Cache eine Übersetzungsfunktion als einer seiner C-Tor-Parameter übergeben. Es wird wiederum verwendet, um eine zwischengespeicherte Ausgabe bezüglich der Eingabe zu generieren.

Ich hoffe es hilft

Versuchen Sie es mit redis. Es ist eine der saubersten und einfachsten Lösungen für Anwendungen, um Daten auf atomare Weise gemeinsam zu nutzen, oder wenn Sie über eine Webserverplattform verfügen. Es ist sehr einfach einzurichten, Sie benötigen einen Python Redis Client http://pypi.python.org/pypi/redis

Schauen Sie sich gocept.cache auf pypi an und verwalten Sie das Timeout.

Dieses Projekt zielt darauf ab, "Caching für Menschen" bereitzustellen (scheint jedoch ziemlich unbekannt zu sein)

Einige Infos von der Projektseite:

Installation

Pip Install Cache

Verwendung:

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

Schauen Sie sich bda.cache an http://pypi.python.org/pypi/bda.cache - verwendet ZCA und wird mit zope und bfg getestet.

Schlüsselring ist die beste Python-Caching-Bibliothek. Sie können verwenden

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

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

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