feat: Adding extra flag to allow uncached results (#13)

* Add optional use_cache param

* Add optional use_cache param

* Test optional use_cache param, use black code format

Co-authored-by: Yuniia Olkhova <yuniia.olkhova@yalantis.net>

Author: y-u-n-ii-a

README.rst

@@ -80,3 +80,7 @@ Advanced Usage
     #   2. request object
     #   3. any other custom object type.
 
+
+    # If you want to refresh the function result use the `use_cache=False`
+    # param in the function invocation
+    func(*args, use_cache=False, **kwargs)

cache/__init__.py

@@ -1,2 +1,2 @@
 from .async_lru import AsyncLRU
-from .async_ttl import AsyncTTL
+from .async_ttl import AsyncTTL

cache/async_lru.py

@@ -3,17 +3,16 @@
 
 
 class AsyncLRU:
-
     def __init__(self, maxsize=128):
         """
         :param maxsize: Use maxsize as None for unlimited size cache
         """
         self.lru = LRU(maxsize=maxsize)
 
     def __call__(self, func):
-        async def wrapper(*args, **kwargs):
+        async def wrapper(*args, use_cache=True, **kwargs):
             key = KEY(args, kwargs)
-            if key in self.lru:
+            if key in self.lru and use_cache:
                 return self.lru[key]
             else:
                 self.lru[key] = await func(*args, **kwargs)

cache/async_ttl.py

@@ -1,16 +1,17 @@
+import datetime
+
 from .key import KEY
 from .lru import LRU
-import datetime
 
 
 class AsyncTTL:
     class _TTL(LRU):
         def __init__(self, time_to_live, maxsize):
             super().__init__(maxsize=maxsize)
 
-            self.time_to_live = datetime.timedelta(
-                seconds=time_to_live
-            ) if time_to_live else None
+            self.time_to_live = (
+                datetime.timedelta(seconds=time_to_live) if time_to_live else None
+            )
 
             self.maxsize = maxsize
 
@@ -31,13 +32,13 @@ def __getitem__(self, key):
 
         def __setitem__(self, key, value):
             ttl_value = (
-                    datetime.datetime.now() + self.time_to_live
-            ) if self.time_to_live else None
+                (datetime.datetime.now() + self.time_to_live)
+                if self.time_to_live
+                else None
+            )
             super().__setitem__(key, (value, ttl_value))
 
-    def __init__(
-            self, time_to_live=60, maxsize=1024, skip_args: int = 0
-    ):
+    def __init__(self, time_to_live=60, maxsize=1024, skip_args: int = 0):
         """
 
         :param time_to_live: Use time_to_live as None for non expiring cache
@@ -48,9 +49,9 @@ def __init__(
         self.skip_args = skip_args
 
     def __call__(self, func):
-        async def wrapper(*args, **kwargs):
+        async def wrapper(*args, use_cache=True, **kwargs):
             key = KEY(args[self.skip_args:], kwargs)
-            if key in self.ttl:
+            if key in self.ttl and use_cache:
                 val = self.ttl[key]
             else:
                 self.ttl[key] = await func(*args, **kwargs)

cache/key.py

@@ -15,7 +15,7 @@ def _hash(param: Any):
                 return tuple(map(_hash, param))
             if isinstance(param, dict):
                 return tuple(map(_hash, param.items()))
-            elif hasattr(param, '__dict__'):
+            elif hasattr(param, "__dict__"):
                 return str(vars(param))
             else:
                 return str(param)

setup.py

@@ -10,14 +10,14 @@
     author_email="iamsinghrajat@gmail.com",
     description="An asyncio Cache",
     long_description=long_description,
-    long_description_content_type='text/x-rst',
+    long_description_content_type="text/x-rst",
     url="https://github.com/iamsinghrajat/async-cache",
     packages=setuptools.find_packages(),
     classifiers=[
         "Programming Language :: Python :: 3",
         "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
     ],
-    python_requires='>=3.3',
-    keywords=['asyncio', 'lru', 'cache', 'async', 'cache', 'lru-cache', 'ttl'],
+    python_requires=">=3.3",
+    keywords=["asyncio", "lru", "cache", "async", "cache", "lru-cache", "ttl"],
 )

tests/lru_test.py

@@ -1,6 +1,8 @@
-from cache import AsyncLRU, AsyncTTL
 import asyncio
 import time
+from timeit import timeit
+
+from cache import AsyncLRU, AsyncTTL
 
 
 @AsyncLRU(maxsize=128)
@@ -81,8 +83,30 @@ def test_skip_args():
     assert t_second_exec < 4000
 
 
+def test_cache_refreshing_lru():
+    t1 = timeit(
+        "asyncio.get_event_loop().run_until_complete(TestClassFunc().obj_func(1))",
+        globals=globals(),
+        number=1,
+    )
+    t2 = timeit(
+        "asyncio.get_event_loop().run_until_complete(TestClassFunc().obj_func(1))",
+        globals=globals(),
+        number=1,
+    )
+    t3 = timeit(
+        "asyncio.get_event_loop().run_until_complete(TestClassFunc().obj_func(1, use_cache=False))",
+        globals=globals(),
+        number=1,
+    )
+
+    assert t1 > t2
+    assert t1 - t3 <= 0.1
+
+
 if __name__ == "__main__":
     test()
     test_obj_fn()
     test_class_fn()
     test_skip_args()
+    test_cache_refreshing_lru()

tests/ttl_test.py

@@ -1,6 +1,8 @@
-from cache import AsyncTTL
 import asyncio
 import time
+from timeit import timeit
+
+from cache import AsyncTTL
 
 
 @AsyncTTL(time_to_live=60)
@@ -56,7 +58,19 @@ def cache_expiration_test():
     assert t_third_exec > 1000
 
 
+def test_cache_refreshing_ttl():
+    t1 = timeit('asyncio.get_event_loop().run_until_complete(short_cleanup_fn(1))',
+                globals=globals(), number=1)
+    t2 = timeit('asyncio.get_event_loop().run_until_complete(short_cleanup_fn(1))',
+                globals=globals(), number=1)
+    t3 = timeit('asyncio.get_event_loop().run_until_complete(short_cleanup_fn(1, use_cache=False))',
+                globals=globals(), number=1)
+
+    assert t1 > t2
+    assert t1 - t3 <= 0.1
+
+
 if __name__ == "__main__":
     cache_hit_test()
     cache_expiration_test()
-
+    test_cache_refreshing_ttl()