Merge pull request #152 from Krukov/use-result-in-ttl

use a result of call in cache ttl def #149

Author: Krukov

cashews/decorators/cache/hit.py

@@ -48,20 +48,19 @@ def _decor(func: AsyncCallable_T) -> AsyncCallable_T:
 
         @wraps(func)
         async def _wrap(*args, **kwargs):
-            _ttl = ttl_to_seconds(ttl, *args, **kwargs, with_callable=True)
             _cache_key = get_cache_key(func, _key_template, args, kwargs)
             _tags = [get_cache_key(func, tag, args, kwargs) for tag in tags]
 
-            call_args = (func, args, kwargs, backend, _cache_key, _ttl, condition, _tags)
+            call_args = (func, args, kwargs, backend, _cache_key, ttl, condition, _tags)
 
             cached, hits = await asyncio.gather(
                 backend.get(_cache_key, default=_empty),
-                backend.incr(_cache_key + ":counter", expire=_ttl, tags=_tags),
+                backend.incr(_cache_key + ":counter", expire=ttl, tags=_tags),
             )
             if cached is not _empty and hits and hits <= cache_hits:
                 context_cache_detect._set(
                     _cache_key,
-                    ttl=_ttl,
+                    ttl=ttl,
                     cache_hits=cache_hits,
                     name="hit",
                     template=_key_template,
@@ -84,6 +83,7 @@ async def _get_and_save(func, args, kwargs, backend: "Cache", key: Key, ttl, sto
         _exc = exc
         result = exc
 
+    ttl = ttl_to_seconds(ttl, *args, result=result, **kwargs, with_callable=True)
     cond_result = store(result, args, kwargs, key=key)
     to_cache = None
     if isinstance(cond_result, bool) and cond_result and not isinstance(result, Exception):

cashews/decorators/cache/simple.py

@@ -44,13 +44,12 @@ def _decor(func: AsyncCallable_T) -> AsyncCallable_T:
 
         @wraps(func)
         async def _wrap(*args, **kwargs):
-            _ttl = ttl_to_seconds(ttl, *args, **kwargs, with_callable=True)
             _tags = [get_cache_key(func, tag, args, kwargs) for tag in tags]
             _cache_key = get_cache_key(func, _key_template, args, kwargs)
 
             cached = await backend.get(_cache_key, default=_empty)
             if cached is not _empty:
-                context_cache_detect._set(_cache_key, ttl=_ttl, name="simple", template=_key_template)
+                context_cache_detect._set(_cache_key, ttl=ttl, name="simple", template=_key_template)
                 return return_or_raise(cached)
             _exc = None
             try:
@@ -59,6 +58,7 @@ async def _wrap(*args, **kwargs):
                 _exc = exc
                 result = exc
 
+            _ttl = ttl_to_seconds(ttl, *args, **kwargs, result=result, with_callable=True)
             cond_result = condition(result, args, kwargs, key=_cache_key)
             if isinstance(cond_result, bool) and cond_result and not isinstance(result, Exception):
                 await backend.set(_cache_key, result, expire=_ttl, tags=_tags)

cashews/decorators/cache/soft.py

@@ -51,18 +51,16 @@ def _decor(func: AsyncCallable_T) -> AsyncCallable_T:
 
         @wraps(func)
         async def _wrap(*args, **kwargs):
-            _ttl = ttl_to_seconds(ttl, *args, **kwargs, with_callable=True)
             _tags = [get_cache_key(func, tag, args, kwargs) for tag in tags]
-            _soft_ttl = ttl_to_seconds(soft_ttl, *args, **kwargs) or _ttl * 0.33
             _cache_key = get_cache_key(func, _key_template, args, kwargs)
             cached = await backend.get(_cache_key, default=_empty)
             if cached is not _empty:
                 soft_expire_at, result = cached
                 if soft_expire_at > datetime.utcnow():
                     context_cache_detect._set(
                         _cache_key,
-                        ttl=_ttl,
-                        soft_ttl=_soft_ttl,
+                        ttl=ttl,
+                        soft_ttl=soft_ttl,
                         name="soft",
                         template=_key_template,
                     )
@@ -75,15 +73,17 @@ async def _wrap(*args, **kwargs):
                     _, result = cached
                     context_cache_detect._set(
                         _cache_key,
-                        ttl=_ttl,
-                        soft_ttl=_soft_ttl,
+                        ttl=ttl,
+                        soft_ttl=soft_ttl,
                         name="soft",
                         template=_key_template,
                     )
                     return result
                 raise
             else:
                 if condition(result, args, kwargs, _cache_key):
+                    _ttl = ttl_to_seconds(ttl, *args, result=result, **kwargs, with_callable=True)
+                    _soft_ttl = ttl_to_seconds(soft_ttl, *args, result=result, **kwargs) or _ttl * 0.33
                     soft_expire_at = datetime.utcnow() + timedelta(seconds=_soft_ttl)
                     await backend.set(_cache_key, [soft_expire_at, result], expire=_ttl, tags=_tags)
                 return result

cashews/ttl.py

@@ -4,7 +4,9 @@
 from cashews._typing import TTL
 
 
-def ttl_to_seconds(ttl: Union[float, None, TTL], *args, with_callable=False, **kwargs) -> Union[int, None, float]:
+def ttl_to_seconds(
+    ttl: Union[float, None, TTL], *args, with_callable=False, result=None, **kwargs
+) -> Union[int, None, float]:
     if ttl is None:
         return None
     _type = type(ttl)
@@ -15,7 +17,11 @@ def ttl_to_seconds(ttl: Union[float, None, TTL], *args, with_callable=False, **k
     if _type == str:
         return _ttl_from_str(ttl)
     if callable(ttl) and with_callable:
-        return ttl_to_seconds(ttl(*args, **kwargs))
+        try:
+            ttl = ttl(*args, result=result, **kwargs)
+        except TypeError:
+            ttl = ttl(*args, **kwargs)
+        return ttl_to_seconds(ttl)
     return ttl
 
 

examples/condition.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from cashews import NOT_NONE, cache
+from cashews import NOT_NONE, cache, with_exceptions
 
 cache.setup("redis://")
 
@@ -21,6 +21,11 @@ async def cache_only_none_more_1000(foo):
     return foo if foo < 100 else None
 
 
+@cache(ttl="10m", condition=with_exceptions())
+async def cache_exception():
+    raise Exception()
+
+
 @cache(ttl="10m", time_condition="1s")
 async def time_condition(foo):
     await asyncio.sleep(foo)

examples/more_decorators.py

@@ -16,7 +16,7 @@ async def function_with_limit(foo):
 
 @cache.failover(ttl="1m", prefix="fast:failover")
 @cache.failover(ttl="10m", exceptions=(CircuitBreakerOpen,))
-@cache.circuit_breaker(errors_rate=10, period="10m", ttl="5m", half_open_ttl="1m")
+@cache.circuit_breaker(errors_rate=10, period="10m", ttl="5m", half_open_ttl="1m", min_calls=4)
 async def function_that_may_fail(foo):
     await asyncio.sleep(0.1)
     if random.choice([0, 0, 0, 1]):

examples/simple.py

@@ -10,7 +10,6 @@ async def basic():
     await cache.clear()
 
     await cache.set("key", 1)
-    print(await cache.get("key"))
     assert await cache.get("key") == 1
     await cache.set("key1", value={"any": True}, expire="1m")
 
@@ -36,6 +35,7 @@ async def basic():
         print("Locked: ", await cache.is_locked("lock"))
 
     print("Ping: ", await cache.ping())  # -> bytes
+    print("Count: ", await cache.get_keys_count())
 
     await cache.close()
 

tests/test_backend_commands.py

@@ -3,51 +3,52 @@
 
 import pytest
 
-from cashews.backends.interface import NOT_EXIST, UNLIMITED, Backend
+from cashews import Cache
+from cashews.backends.interface import NOT_EXIST, UNLIMITED
 from cashews.backends.memory import Memory
 
 pytestmark = pytest.mark.asyncio
 VALUE = Decimal("100.2")
 
 
-async def test_set_get(cache):
+async def test_set_get(cache: Cache):
     await cache.set("key", VALUE)
     assert await cache.get("key") == VALUE
 
 
-async def test_set_get_bytes(cache):
+async def test_set_get_bytes(cache: Cache):
     await cache.set("key", b"10")
     assert await cache.get("key") == b"10"
 
 
-async def test_incr_get(cache):
+async def test_incr_get(cache: Cache):
     await cache.incr("key")
     assert await cache.get("key") == 1
 
 
-async def test_incr_value_get(cache):
+async def test_incr_value_get(cache: Cache):
     await cache.incr("key")
     await cache.incr("key", 2)
     assert await cache.get("key") == 3
 
 
-async def test_incr_expire(cache):
+async def test_incr_expire(cache: Cache):
     await cache.incr("key", expire=10)
     assert await cache.get_expire("key") == 10
 
 
-async def test_set_get_many(cache):
+async def test_set_get_many(cache: Cache):
     await cache.set("key", VALUE)
     assert await cache.get_many("key", "no_exists") == (VALUE, None)
 
 
-async def test_diff_types_get_many(cache):
+async def test_diff_types_get_many(cache: Cache):
     await cache.incr("key")
     await cache.incr_bits("key2", 0)
     assert await cache.get_many("key", "key2") == (1, None)
 
 
-async def test_set_exist(cache):
+async def test_set_exist(cache: Cache):
     assert await cache.set("key", "value")
     assert await cache.set("key", VALUE, exist=True)
     assert await cache.get("key") == VALUE
@@ -62,49 +63,49 @@ async def test_set_exist(cache):
     assert await cache.get("key2") == "value"
 
 
-async def test_set_many(cache):
+async def test_set_many(cache: Cache):
     await cache.set_many({"key1": VALUE, "key2": "value2"}, expire=1)
     assert await cache.get("key1", VALUE)
     assert await cache.get("key2", "value2")
 
 
-async def test_get_no_value(cache):
+async def test_get_no_value(cache: Cache):
     assert await cache.get("key2") is None
     assert await cache.get("key2", default=VALUE) is VALUE
 
 
-async def test_incr(cache):
+async def test_incr(cache: Cache):
     assert await cache.incr("incr") == 1
     assert await cache.incr("incr") == 2
     assert await cache.incr("incr", 5) == 7
     assert await cache.get("incr") == 7
 
 
-async def test_incr_set(cache):
+async def test_incr_set(cache: Cache):
     await cache.set("incr", "test")
     with pytest.raises(Exception):
         assert await cache.incr("incr") == 1
     assert await cache.get("incr") == "test"
 
 
-async def test_ping(cache):
+async def test_ping(cache: Cache):
     assert await cache.ping() == b"PONG"
 
 
-async def test_exists(cache):
+async def test_exists(cache: Cache):
     assert not await cache.exists("not")
     await cache.set("yes", VALUE)
     assert await cache.exists("yes")
 
 
-async def test_expire(cache):
+async def test_expire(cache: Cache):
     await cache.set("key", VALUE, expire=0.01)
     assert await cache.get("key") == VALUE
     await asyncio.sleep(0.01)
     assert await cache.get("key") is None
 
 
-async def test_get_set_expire(cache):
+async def test_get_set_expire(cache: Cache):
     assert await cache.get_expire("key") == NOT_EXIST
     await cache.set("key", VALUE)
     assert await cache.get("key") == VALUE
@@ -113,7 +114,7 @@ async def test_get_set_expire(cache):
     assert await cache.get_expire("key") == 1
 
 
-async def test_delete_many(cache: Backend):
+async def test_delete_many(cache: Cache):
     await cache.set("key1", VALUE)
     await cache.set("key2", VALUE)
     await cache.set("key3", VALUE)
@@ -125,7 +126,7 @@ async def test_delete_many(cache: Backend):
     assert await cache.get("key3") == VALUE
 
 
-async def test_delete_match(cache: Backend):
+async def test_delete_match(cache: Cache):
     await cache.set("pref:test:test", VALUE)
     await cache.set("pref:value:test", b"value2")
     await cache.set("pref:-:test", b"-")
@@ -145,7 +146,7 @@ async def test_delete_match(cache: Backend):
     assert await cache.get("pref:test:tests") is not None
 
 
-async def test_scan(cache: Backend):
+async def test_scan(cache: Cache):
     await cache.set("pref:test:test", VALUE)
     await cache.set("pref:value:test", b"value2")
     await cache.set("pref:-:test", b"-")
@@ -160,7 +161,7 @@ async def test_scan(cache: Backend):
     assert set(keys) == {"pref:test:test", "pref:value:test", "pref:-:test", "pref:*:test"}
 
 
-async def test_get_match(cache: Backend):
+async def test_get_match(cache: Cache):
     await cache.set("pref:test:test", VALUE)
     await cache.set("pref:value:test", b"value2")
     await cache.set("pref:-:test", b"-")
@@ -182,39 +183,39 @@ async def test_get_match(cache: Backend):
     assert len(match) == 0
 
 
-async def test_set_lock_unlock(cache: Backend):
+async def test_set_lock_unlock(cache: Cache):
     await cache.set_lock("lock", "lock", 10)
     assert await cache.is_locked("lock")
     await cache.unlock("lock", "lock")
     assert not await cache.is_locked("lock")
 
 
-async def test_lock(cache: Backend):
+async def test_lock(cache: Cache):
     async with cache.lock("lock", 10):
         assert await cache.is_locked("lock")
 
     assert not await cache.is_locked("lock")
 
 
-async def test_diff_types_get_match(cache):
+async def test_diff_types_get_match(cache: Cache):
     await cache.incr("key")
     await cache.incr_bits("key2", 0)
     match = [(key, value) async for key, value in cache.get_match("*")]
     assert len(match) == 1, match
     assert dict(match) == {"key": 1}
 
 
-async def test_get_size(cache: Backend):
+async def test_get_size(cache: Cache):
     await cache.set("test", b"1")
     assert isinstance(await cache.get_size("test"), int)
 
 
-async def test_get_keys_count(cache: Backend):
+async def test_get_keys_count(cache: Cache):
     await cache.set("test", b"1")
     assert await cache.get_keys_count() == 1
 
 
-async def test_get_bits(cache: Backend):
+async def test_get_bits(cache: Cache):
     assert await cache.get_bits("test", 0, 2, 10, 50000, size=1) == (0, 0, 0, 0)
     assert await cache.get_bits("test", 0, 1, 3, size=15) == (
         0,
@@ -223,17 +224,17 @@ async def test_get_bits(cache: Backend):
     )
 
 
-async def test_incr_bits(cache: Backend):
+async def test_incr_bits(cache: Cache):
     await cache.incr_bits("test", 0, 1, 4)
     assert await cache.get_bits("test", 0, 1, 2, 3, 4) == (1, 1, 0, 0, 1)
 
 
-async def test_bits_size(cache: Backend):
+async def test_bits_size(cache: Cache):
     await cache.incr_bits("test", 0, 1, 4, size=5, by=3)
     assert await cache.get_bits("test", 0, 1, 2, 3, 4, size=5) == (3, 3, 0, 0, 3)
 
 
-async def test_slice_incr(cache: Backend):
+async def test_slice_incr(cache: Cache):
     assert await cache.slice_incr("test", 0, 5, maxvalue=10) == 1
     assert await cache.slice_incr("test", 1, 6, maxvalue=10) == 2
     assert await cache.slice_incr("test", 2, 7, maxvalue=10) == 3