supercache
1.0.0
Einfach zu verwendendes Caching für Funktionen und Methoden.
supercache wurde als Dekorator für die Arbeit mit Funktionen und Methoden entwickelt, um nahezu sofortige Wiederholungsausführungen mit nur einer einzigen zusätzlichen Codezeile zu ermöglichen. Es fungiert als Schnittstelle zur Cache-Engine, die vom Zwischenspeichern im Speicher bis zur Verwendung von Redis reichen kann (vorausgesetzt, es wurde codiert).
Bitte beachten Sie, dass die Verwendung des Dekorators einen kleinen Mehraufwand verursacht, da er eher auf Komfort und Stabilität als auf Leistung ausgelegt ist. Es ist möglich, dass das Zwischenspeichern einer sehr einfachen Funktion zu einer schlechteren Leistung führt (es dauert ungefähr 1 Sekunde pro 40.000 Ausführungen).
pip install supercache
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 # 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 )Legen Sie fest, welche Parameter der Funktion beim Generieren des Cache-Schlüssels verwendet werden sollen. Alle verfügbaren Parameter werden standardmäßig verwendet.
Diese können im Format int , str , slice (nützlich für *args ) oder regex (nützlich für **kwargs ) vorliegen.
Legen Sie fest, welche Parameter beim Generieren des Cache-Schlüssels ignoriert werden sollen. Dadurch werden alle in keys bereitgestellten Einstellungen überschrieben.
Diese können auch im Format int , str , slice oder regex vorliegen
Überschreiben Sie die TTL-Einstellung der Engine, um festzulegen, nach wie vielen Sekunden der Cache ungültig wird.
Wenn es sich bei der zwischengespeicherten Funktion um einen Generator handelt, wird durch die Einstellung „ True die Ausgabe beim ersten Aufruf in ein tuple konvertiert, anstatt den Iterator zurückzugeben.
Der Grund dafür ist, dass das Generator-Caching einen hohen Overhead verursacht, der sich deutlich bemerkbar machen kann, wenn ein einfacher Generator tausende Male aufgerufen wird.
Alias: cache[key]
Liest ein Cache-Element oder löst einen Fehler aus, wenn es nicht vorhanden ist.
Alias: cache[key] = value
Legen Sie ein neues Cache-Element fest.
Alias: del cache[key]
Cache für eine Taste oder Funktion löschen.
cache.delete() : Alle zwischengespeicherten Daten löschen.cache.delete(key) : Zwischengespeicherte Daten für einen bestimmten key löschen.cache.delete(func) : Zwischengespeicherte Daten bei jeder Ausführung von func löschen.cache.delete(func, 1, b=2) : Löschen Sie die zwischengespeicherten Daten für func(1, b=2) .Gibt eine Zählung zurück, wie oft der Cache für eine Taste oder Funktion gelesen wurde.
cache.hits() : Anzahl der gesamten Cache-Treffer.cache.hits(key) : Anzahl der Treffer für einen bestimmten key .cache.hits(func) : Anzahl der Cache-Treffer für jede Ausführung von func .cache.hits(func, 1, b=2) : Anzahl der Cache-Treffer speziell für func(1, b=2) .Gibt eine Zählung zurück, wie oft der Cache für einen Schlüssel oder eine Funktion generiert wurde.
cache.misses() : Anzahl der gesamten Cache-Fehler.cache.misses(key) : Anzahl der Fehlschläge für einen bestimmten key .cache.misses(func) : Anzahl der Cache-Fehler für jede Ausführung von func .cache.misses(func, 1, b=2) : Anzahl der Cache-Fehler speziell für func(1, b=2) .Rufen Sie ab, ob der Cache für einen Schlüssel oder eine Funktion vorhanden ist.
cache.exists() : Wenn ein Cache vorhanden ist.cache.exists(key) : Wenn key im Cache vorhanden ist.cache.exists(func) : Wenn eine Ausführung von func im Cache vorhanden ist.cache.exists(func, 1, b=2) : Wenn func(1, b=2) im Cache vorhanden ist.Legen Sie den Modus zum Löschen des Caches fest. Optionen sind FIFO (First In First Out), FILO (First In Last Out), LRU (Least Latest Used), MRU (Most Latest Used) oder LFU (Am wenigsten häufig verwendet).
Legen Sie fest, nach wie vielen Sekunden der Cache ungültig wird.
Legen Sie die maximale Anzahl zwischengespeicherter Ergebnisse fest.
Legen Sie die maximale Größe des Caches in Bytes fest. Dies ist ein weiches Limit, bei dem zuerst der Speicher zugewiesen wird und dann der ältere Cache gelöscht wird, bis er wieder unter dem Limit liegt.
Die letzte Ausführung wird immer zwischengespeichert, auch wenn die maximale Größe kleiner als das Ergebnis ist.
classmethods , staticmethods und properties können nur zwischengespeichert werden, wenn zuerst der Cache-Dekorator ausgeführt wird
