From 1c7b3ddb83bbbecd7f190069398be0ba0a30a765 Mon Sep 17 00:00:00 2001 From: Grant Jenks Date: Fri, 22 Jan 2021 13:11:39 -0800 Subject: [PATCH] Memoizing cache decorator with cache lease. def memoize_lease(cache, expire, lease, name=None, typed=False, tag=None): The `expire` argument is a "hard deadline" for evicting cache entries. Set `expire` to `None` to avoid evictions due to expiration. The `lease` represents a "soft deadline" for the memoized cache entry. Once the lease time has passed, cache entries will be updated asynchronously using a background thread. At most one background thread will be started for each cache entry. While the background thread is executing, memoized cache entries will continue to be treated as "cache hits" until expiration. If name is set to None (default), the callable name will be determined automatically. If typed is set to True, function arguments of different types will be cached separately. For example, f(3) and f(3.0) will be treated as distinct calls with distinct results. The original underlying function is accessible through the `__wrapped__` attribute. This is useful for introspection, for bypassing the cache, or for rewrapping the function with a different cache. >>> from diskcache import Cache >>> cache = Cache() >>> @memoize_lease(cache, expire=10, lease=1) ... def fib(number): ... if number == 0: ... return 0 ... elif number == 1: ... return 1 ... else: ... return fib(number - 1) + fib(number - 2) >>> print(fib(100)) 354224848179261915075 An additional `__cache_key__` attribute can be used to generate the cache key used for the given arguments. >>> key = fib.__cache_key__(100) >>> del cache[key] Remember to call memoize when decorating a callable. If you forget, then a TypeError will occur. :param cache: cache to store callable arguments and return values :param float expire: seconds until arguments expire :param float lease: minimum seconds after last execution we want to update the cache value :param str name: name given for callable (default None, automatic) :param bool typed: cache different types separately (default False) :param str tag: text to associate with arguments (default None) :return: callable decorator --- diskcache/recipes.py | 128 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 128 insertions(+) diff --git a/diskcache/recipes.py b/diskcache/recipes.py index 8f7bd32..d7432f3 100644 --- a/diskcache/recipes.py +++ b/diskcache/recipes.py @@ -466,3 +466,131 @@ def __cache_key__(*args, **kwargs): return wrapper return decorator + + +def memoize_lease(cache, expire, lease, name=None, typed=False, tag=None): + """Memoizing cache decorator with cache lease. + + The `expire` argument is a "hard deadline" for evicting cache entries. Set + `expire` to `None` to avoid evictions due to expiration. + + The `lease` represents a "soft deadline" for the memoized cache entry. Once + the lease time has passed, cache entries will be updated asynchronously + using a background thread. At most one background thread will be started + for each cache entry. While the background thread is executing, memoized + cache entries will continue to be treated as "cache hits" until expiration. + + If name is set to None (default), the callable name will be determined + automatically. + + If typed is set to True, function arguments of different types will be + cached separately. For example, f(3) and f(3.0) will be treated as distinct + calls with distinct results. + + The original underlying function is accessible through the `__wrapped__` + attribute. This is useful for introspection, for bypassing the cache, or + for rewrapping the function with a different cache. + + >>> from diskcache import Cache + >>> cache = Cache() + >>> @memoize_lease(cache, expire=10, lease=1) + ... def fib(number): + ... if number == 0: + ... return 0 + ... elif number == 1: + ... return 1 + ... else: + ... return fib(number - 1) + fib(number - 2) + >>> print(fib(100)) + 354224848179261915075 + + An additional `__cache_key__` attribute can be used to generate the cache + key used for the given arguments. + + >>> key = fib.__cache_key__(100) + >>> del cache[key] + + Remember to call memoize when decorating a callable. If you forget, then a + TypeError will occur. + + :param cache: cache to store callable arguments and return values + :param float expire: seconds until arguments expire + :param float lease: minimum seconds after last execution + we want to update the cache value + :param str name: name given for callable (default None, automatic) + :param bool typed: cache different types separately (default False) + :param str tag: text to associate with arguments (default None) + :return: callable decorator + + """ + # Caution: Nearly identical code exists in recipes.memoize_stampede + def decorator(func): + "Decorator created by memoize call for callable." + base = (full_name(func),) if name is None else (name,) + + def timer(*args, **kwargs): + "Time execution of `func` and return result and time delta." + start = time.time() + result = func(*args, **kwargs) + delta = time.time() - start + return result, delta, time.time() + + @functools.wraps(func) + def wrapper(*args, **kwargs): + "Wrapper for callable to cache arguments and return values." + key = wrapper.__cache_key__(*args, **kwargs) + trio, expire_time = cache.get( + key, + default=ENOVAL, + expire_time=True, + retry=True, + ) + + if trio is not ENOVAL: + result, delta, last_exec = trio + now = time.time() + + if (now - last_exec) < lease: + return result # Cache hit. + + # Check whether a thread has started for early recomputation. + + thread_key = key + (ENOVAL,) + thread_added = cache.add( + thread_key, + None, + expire=delta, + retry=True, + ) + + if thread_added: + # Start thread for early recomputation. + def recompute(): + with cache: + trio = timer(*args, **kwargs) + cache.set( + key, + trio, + expire=expire, + tag=tag, + retry=True, + ) + + thread = threading.Thread(target=recompute) + thread.daemon = True + thread.start() + + return result + + trio = timer(*args, **kwargs) + cache.set(key, trio, expire=expire, tag=tag, retry=True) + return trio[0] + + def __cache_key__(*args, **kwargs): + "Make key for cache given function arguments." + return args_to_key(base, args, kwargs, typed) + + wrapper.__cache_key__ = __cache_key__ + return wrapper + + return decorator