supercache

supercache

Caching yang mudah digunakan untuk fungsi dan metode.

supercache telah dirancang sebagai dekorator untuk bekerja dengan fungsi dan metode, untuk menyediakan eksekusi berulang yang hampir instan hanya dengan satu baris kode tambahan. Ini bertindak sebagai antarmuka ke mesin cache, yang bisa berupa apa saja mulai dari caching di memori hingga menggunakan Redis (asalkan sudah dikodekan).

Harap dicatat bahwa penggunaan dekorator menambah sedikit overhead karena dirancang untuk kenyamanan dan stabilitas dibandingkan kinerja. Ada kemungkinan bahwa menyimpan fungsi yang sangat sederhana dapat mengakibatkan kinerja yang lebih buruk (kira-kira memerlukan waktu 1 detik untuk setiap 40.000 eksekusi).

Instalasi

 pip install supercache

Penggunaan

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

 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

Jenis yang Didukung

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

Referensi API

@cache( kunci=Tidak ada, abaikan=Tidak ada, ttl=Tidak ada, hitung sebelumnya=Salah )

kunci

Tetapkan parameter fungsi mana yang akan digunakan dalam menghasilkan kunci cache. Semua parameter yang tersedia akan digunakan secara default.

Ini bisa dalam format int , str , slice (berguna untuk *args ), atau regex (berguna untuk **kwargs )

mengabaikan

Tetapkan parameter mana yang akan diabaikan saat membuat kunci cache. Ini akan mengesampingkan pengaturan apa pun yang disediakan di keys .

Ini juga bisa dalam format int , str , slice atau regex

ttl

Ganti pengaturan ttl mesin untuk mengatur berapa detik hingga cache tidak valid.

menghitung sebelumnya

Jika fungsi yang di-cache adalah generator, menyetelnya ke True akan mengubah output menjadi tuple saat pertama kali dipanggil, alih-alih mengembalikan iterator.

Alasannya adalah caching generator mempunyai banyak overhead, yang bisa menjadi sangat terlihat ketika memanggil generator sederhana ribuan kali.

cache.get( kunci ):

Alias: cache[key]

Membaca item cache, atau memunculkan kesalahan jika tidak ada.

cache.put( kunci, nilai, **kwargs ):

Alias: cache[key] = value

Tetapkan item cache baru.

cache.hapus( kunci=Tidak ada, *args, **kwargs )

Alias: del cache[key]

Hapus cache untuk kunci atau fungsi.

• cache.delete() : Hapus semua data cache.
• cache.delete(key) : Menghapus data cache untuk key tertentu.
• cache.delete(func) : Hapus data cache untuk setiap eksekusi func .
• cache.delete(func, 1, b=2) : Hapus data cache untuk func(1, b=2) .

cache.hits( kunci=Tidak ada, *args, **kwargs )

Mengembalikan hitungan berapa kali cache dibaca untuk suatu kunci atau fungsi.

• cache.hits() : Jumlah total cache yang ditemukan.
• cache.hits(key) : Jumlah hit untuk key tertentu.
• cache.hits(func) : Jumlah cache yang ditemukan untuk setiap eksekusi func .
• cache.hits(func, 1, b=2) : Jumlah cache yang ditemukan khusus untuk func(1, b=2) .

cache.misses( kunci=Tidak ada, *args, **kwargs )

Mengembalikan hitungan berapa kali cache dibuat untuk suatu kunci atau fungsi.

• cache.misses() : Jumlah total cache yang hilang.
• cache.misses(key) : Jumlah kesalahan untuk key tertentu.
• cache.misses(func) : Jumlah cache yang hilang untuk setiap eksekusi func .
• cache.misses(func, 1, b=2) : Jumlah cache yang hilang khusus untuk func(1, b=2) .

cache.ada( kunci=Tidak ada, *args, **kwargs )

Dapatkan apakah cache ada untuk kunci atau fungsi.

• cache.exists() : Jika ada cache.
• cache.exists(key) : Jika key ada di cache.
• cache.exists(func) : Jika ada eksekusi func di cache.
• cache.exists(func, 1, b=2) : Jika func(1, b=2) ada di cache.

mesin.Memori( mode=LRU, ttl=Tidak Ada, hitungan=Tidak Ada, ukuran=Tidak Ada )

Mode

Atur mode untuk membersihkan cache. Pilihannya adalah FIFO (masuk pertama keluar pertama), FILO (masuk pertama keluar terakhir), LRU (paling jarang digunakan), MRU (paling baru digunakan) atau LFU (paling jarang digunakan).

ttl

Atur berapa detik hingga cache tidak valid.

menghitung

Tetapkan jumlah maksimum hasil cache.

ukuran

Tetapkan ukuran maksimum cache dalam byte. Ini adalah batas lunak, dimana memori akan dialokasikan terlebih dahulu, kemudian cache yang lama akan dihapus hingga kembali di bawah batas tersebut.

Eksekusi terbaru akan selalu di-cache, meskipun ukuran maksimum disetel lebih kecil dari hasilnya.

Berencana

• Dukungan untuk SQLite
• Dukungan untuk memcache
• Dukungan untuk Redis

Keterbatasan

• Tidak dapat melakukan cache jika argumen yang tidak dapat di-hash digunakan
• Python akan menetapkan hash yang sama ke dua kelas dengan warisan yang sama jika keduanya diinisialisasi pada baris yang sama (untungnya hal ini tidak boleh terjadi di luar pengujian)
• classmethods , staticmethods dan properties hanya dapat di-cache jika dekorator cache dijalankan terlebih dahulu