supercache

supercache

แคชที่ใช้งานง่ายสำหรับฟังก์ชันและวิธีการ

supercache ได้รับการออกแบบให้เป็นมัณฑนากรเพื่อทำงานกับฟังก์ชันและวิธีการต่างๆ เพื่อให้ดำเนินการซ้ำได้แทบจะในทันทีโดยใช้โค้ดเพิ่มเติมเพียงบรรทัดเดียว มันทำหน้าที่เป็นส่วนต่อประสานกับกลไกแคช ซึ่งสามารถเป็นอะไรก็ได้ตั้งแต่การแคชในหน่วยความจำไปจนถึงการใช้ Redis (หากถูกเข้ารหัส)

โปรดทราบว่าการใช้มัณฑนากรจะเพิ่มค่าใช้จ่ายเล็กน้อย เนื่องจากได้รับการออกแบบมาเพื่อความสะดวกและความเสถียรเหนือประสิทธิภาพ เป็นไปได้ว่าการแคชฟังก์ชันง่ายๆ อาจส่งผลให้ประสิทธิภาพแย่ลง (ใช้เวลาประมาณ 1 วินาทีต่อการดำเนินการ 40,000 ครั้ง)

การติดตั้ง

 pip install supercache

การใช้งาน

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

ประเภทที่รองรับ

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

การอ้างอิง API

@cache( คีย์=ไม่มี, ละเว้น=ไม่มี, ttl=ไม่มี, คำนวณล่วงหน้า=เท็จ )

กุญแจ

ตั้งค่าพารามิเตอร์ของฟังก์ชันที่จะใช้ในการสร้างคีย์แคช พารามิเตอร์ที่มีอยู่ทั้งหมดจะถูกใช้เป็นค่าเริ่มต้น

สิ่งเหล่านี้สามารถอยู่ในรูปแบบของ int , str , slice (มีประโยชน์สำหรับ *args ) หรือ regex (มีประโยชน์สำหรับ **kwargs )

ไม่สนใจ

ตั้งค่าพารามิเตอร์ที่จะละเว้นเมื่อสร้างคีย์แคช การดำเนินการนี้จะแทนที่การตั้งค่าใดๆ ที่ให้ไว้ใน keys

สิ่งเหล่านี้อาจอยู่ในรูปแบบของ int , str , slice หรือ regex

ทีทีแอล

แทนที่การตั้งค่า engine ttl เพื่อกำหนดจำนวนวินาทีจนกว่าแคชจะใช้งานไม่ได้

คำนวณล่วงหน้า

หากฟังก์ชันที่ถูกแคชเป็นตัวสร้าง การตั้งค่านี้เป็น True จะแปลงเอาต์พุตเป็น tuple เมื่อถูกเรียกครั้งแรก แทนที่จะส่งคืนตัววนซ้ำ

เหตุผลก็คือการแคชตัวสร้างมีค่าใช้จ่ายจำนวนมาก ซึ่งอาจสังเกตได้ชัดเจนมากเมื่อเรียกตัวสร้างแบบธรรมดาหลายพันครั้ง

cache.get( กุญแจ ):

นามแฝง: cache[key]

อ่านรายการแคช หรือแจ้งข้อผิดพลาดหากไม่มีอยู่

cache.put( คีย์, ค่า, **kwargs ):

นามแฝง: cache[key] = value

ตั้งค่ารายการแคชใหม่

cache.delete( key=ไม่มี, *args, **kwargs )

นามแฝง: del cache[key]

ลบแคชสำหรับคีย์หรือฟังก์ชัน

• cache.delete() : ลบข้อมูลแคชทั้งหมด
• cache.delete(key) : ลบข้อมูลแคชสำหรับ key เฉพาะ
• cache.delete(func) : ลบข้อมูลแคชสำหรับการดำเนินการ func ทุกครั้ง
• cache.delete(func, 1, b=2) : ลบข้อมูลที่แคชไว้สำหรับ func(1, b=2)

cache.hits( คีย์=ไม่มี, *args, **kwargs )

ส่งกลับจำนวนครั้งที่แคชถูกอ่านสำหรับคีย์หรือฟังก์ชัน

• cache.hits() : จำนวนการเข้าชมแคชทั้งหมด
• cache.hits(key) : จำนวนการเข้าชมสำหรับ key เฉพาะ
• cache.hits(func) : จำนวนการเข้าชมแคชสำหรับการดำเนินการทุกครั้งของ func
• cache.hits(func, 1, b=2) : จำนวนการเข้าชมแคชโดยเฉพาะสำหรับ func(1, b=2)

cache.misses( คีย์ = ไม่มี, *args, **kwargs )

ส่งกลับจำนวนครั้งที่แคชถูกสร้างขึ้นสำหรับคีย์หรือฟังก์ชัน

• cache.misses() : จำนวนแคชที่หายไปทั้งหมด
• cache.misses(key) : จำนวนการพลาดสำหรับ key เฉพาะ
• cache.misses(func) : จำนวนแคชที่พลาดสำหรับการดำเนินการทุกครั้งของ func
• cache.misses(func, 1, b=2) : จำนวนแคชที่พลาดเฉพาะสำหรับ func(1, b=2)

cache.exists( key=ไม่มี, *args, **kwargs )

รับว่ามีแคชสำหรับคีย์หรือฟังก์ชันหรือไม่

• cache.exists() : หากมีแคชอยู่
• cache.exists(key) : หากมี key อยู่ในแคช
• cache.exists(func) : หากมีการดำเนินการของ func ในแคช
• cache.exists(func, 1, b=2) : หากมี func(1, b=2) อยู่ในแคช

engine.Memory ( โหมด=LRU, ttl=ไม่มี, นับ=ไม่มี, ขนาด=ไม่มี )

โหมด

ตั้งค่าโหมดสำหรับการล้างแคช ตัวเลือกได้แก่ FIFO (เข้าก่อนออกก่อน), FILO (เข้าก่อนออกก่อน), LRU (ใช้ล่าสุดน้อยที่สุด), MRU (ใช้ล่าสุด) หรือ LFU (ใช้บ่อยน้อยที่สุด)

ทีทีแอล

กำหนดจำนวนวินาทีจนกว่าแคชจะใช้งานไม่ได้

นับ

กำหนดจำนวนสูงสุดของผลลัพธ์ที่แคชไว้

ขนาด

ตั้งค่าขนาดสูงสุดของแคชเป็นไบต์ นี่เป็นขีดจำกัดแบบซอฟต์ โดยที่หน่วยความจำจะถูกจัดสรรก่อน จากนั้นแคชเก่าจะถูกลบออกจนกว่าจะกลับต่ำกว่าขีดจำกัด

การดำเนินการล่าสุดจะถูกแคชเสมอ แม้ว่าขนาดสูงสุดจะถูกตั้งค่าให้เล็กกว่าผลลัพธ์ก็ตาม

วางแผนแล้ว

• รองรับ SQLite
• รองรับ memcached
• การสนับสนุนสำหรับ Redis

ข้อจำกัด

• ไม่สามารถแคชได้หากใช้อาร์กิวเมนต์ที่ไม่สามารถแฮชได้
• Python จะกำหนดแฮชเดียวกันให้กับสองคลาสที่มีการสืบทอดเหมือนกัน หากทั้งสองคลาสเริ่มต้นได้ในบรรทัดเดียวกัน (โชคดีที่สิ่งนี้ไม่ควรเกิดขึ้นนอกการทดสอบ)
• classmethods , staticmethods และ properties สามารถแคชได้ก็ต่อเมื่อมีการดำเนินการตัวตกแต่งแคชก่อน