Refactor cache module and added cacheModule

Author: eadwinCode

ellar/cache/__init__.py

@@ -1,5 +1,7 @@
+from .decorator import cache
 from .interface import ICacheService
 from .model import BaseCacheBackend
+from .module import CacheModule
 from .service import CacheService
 
-__all__ = ["CacheService", "ICacheService", "BaseCacheBackend"]
+__all__ = ["CacheService", "ICacheService", "BaseCacheBackend", "CacheModule", "cache"]

ellar/cache/backends/_aio_cache.py renamed to ellar/cache/backends/_aio_cache.py.ellar

@@ -19,12 +19,10 @@ def set(
         self,
         key: str,
         value: t.Any,
-        timeout: t.Union[float, int] = None,
+        ttl: t.Union[float, int] = None,
         version: str = None,
     ) -> bool:
-        result = self._cache_client.set(
-            key, value, int(self.get_backend_timeout(timeout))
-        )
+        result = self._cache_client.set(key, value, int(self.get_backend_ttl(ttl)))
         if not result:
             # Make sure the key doesn't keep its old value in case of failure
             # to set (memcached's 1MB limit).
@@ -39,9 +37,9 @@ def delete(self, key: str, version: str = None) -> bool:
 
     @make_key_decorator
     def touch(
-        self, key: str, timeout: t.Union[float, int] = None, version: str = None
+        self, key: str, ttl: t.Union[float, int] = None, version: str = None
     ) -> bool:
-        result = self._cache_client.touch(key, self.get_backend_timeout(timeout))
+        result = self._cache_client.touch(key, self.get_backend_ttl(ttl))
         return bool(result)
 
     @make_key_decorator
@@ -92,22 +90,20 @@ async def set_async(
         self,
         key: str,
         value: t.Any,
-        timeout: t.Union[float, int] = None,
+        ttl: t.Union[float, int] = None,
         version: str = None,
     ) -> bool:
-        result = await self.executor(
-            self.set, key, value, timeout=timeout, version=version
-        )
+        result = await self.executor(self.set, key, value, ttl=ttl, version=version)
         return bool(result)
 
     async def delete_async(self, key: str, version: str = None) -> bool:
         result = await self.executor(self.delete, key, version=version)
         return bool(result)
 
     async def touch_async(
-        self, key: str, timeout: t.Union[float, int] = None, version: str = None
+        self, key: str, ttl: t.Union[float, int] = None, version: str = None
     ) -> bool:
-        result = await self.executor(self.touch, key, timeout=timeout, version=version)
+        result = await self.executor(self.touch, key, ttl=ttl, version=version)
         return bool(result)
 
     async def close_async(self, **kwargs: t.Any) -> None:

ellar/cache/backends/base.py

@@ -28,20 +28,16 @@ def set(
         self,
         key: str,
         value: t.Any,
-        timeout: t.Union[float, int] = None,
+        ttl: t.Union[float, int] = None,
         version: str = None,
     ) -> bool:
-        res = self._async_executor(
-            self.set_async(key, value, timeout=timeout, version=version)
-        )
+        res = self._async_executor(self.set_async(key, value, ttl=ttl, version=version))
         return bool(res)
 
     def touch(
-        self, key: str, timeout: t.Union[float, int] = None, version: str = None
+        self, key: str, ttl: t.Union[float, int] = None, version: str = None
     ) -> bool:
-        res = self._async_executor(
-            self.touch_async(key, timeout=timeout, version=version)
-        )
+        res = self._async_executor(self.touch_async(key, ttl=ttl, version=version))
         return bool(res)
 
     def incr(self, key: str, delta: int = 1, version: str = None) -> int:
@@ -90,12 +86,12 @@ async def set_async(
         self,
         key: str,
         value: t.Any,
-        timeout: t.Union[float, int] = None,
+        ttl: t.Union[float, int] = None,
         version: str = None,
     ) -> bool:
         async with self._lock:
             self._cache[key] = pickle.dumps(value, self.pickle_protocol)
-            self._expire_track[key] = self.get_backend_timeout(timeout)
+            self._expire_track[key] = self.get_backend_ttl(ttl)
             return True
 
     def _has_expired(self, key: str) -> bool:
@@ -112,13 +108,13 @@ async def has_key_async(self, key: str, version: str = None) -> bool:
 
     @make_key_decorator
     async def touch_async(
-        self, key: str, timeout: t.Union[float, int] = None, version: str = None
+        self, key: str, ttl: t.Union[float, int] = None, version: str = None
     ) -> bool:
         async with self._lock:
             if self._has_expired(key):
                 return False
 
-            self._expire_track[key] = self.get_backend_timeout(timeout)
+            self._expire_track[key] = self.get_backend_ttl(ttl)
             return True
 
     def has_key(self, key: str, version: str = None) -> bool:

ellar/cache/backends/local_cache.py

@@ -32,20 +32,16 @@ def set(
         self,
         key: str,
         value: t.Any,
-        timeout: t.Union[float, int] = None,
+        ttl: t.Union[float, int] = None,
         version: str = None,
     ) -> bool:
-        res = self._async_executor(
-            self.set_async(key, value, version=version, timeout=timeout)
-        )
+        res = self._async_executor(self.set_async(key, value, version=version, ttl=ttl))
         return bool(res)
 
     def touch(
-        self, key: str, timeout: t.Union[float, int] = None, version: str = None
+        self, key: str, ttl: t.Union[float, int] = None, version: str = None
     ) -> bool:
-        res = self._async_executor(
-            self.touch_async(key, version=version, timeout=timeout)
-        )
+        res = self._async_executor(self.touch_async(key, version=version, ttl=ttl))
         return bool(res)
 
     def has_key(self, key: str, version: str = None) -> bool:
@@ -116,14 +112,12 @@ def _get_client(self, *, write: bool = False) -> Redis:
         pool = self._get_connection_pool(write)
         return self.MEMCACHE_CLIENT(connection_pool=pool)
 
-    def get_backend_timeout(
-        self, timeout: t.Union[float, int] = None
-    ) -> t.Union[float, int]:
-        if timeout is None:
-            timeout = self._default_timeout
-        # The key will be made persistent if None used as a timeout.
+    def get_backend_ttl(self, ttl: t.Union[float, int] = None) -> t.Union[float, int]:
+        if ttl is None:
+            ttl = self._default_ttl
+        # The key will be made persistent if None used as a ttl.
         # Non-positive values will cause the key to be deleted.
-        return None if timeout is None else max(0, int(timeout))
+        return None if ttl is None else max(0, int(ttl))
 
     @make_key_decorator
     async def get_async(self, key: str, version: str = None) -> t.Any:
@@ -138,15 +132,15 @@ async def set_async(
         self,
         key: str,
         value: t.Any,
-        timeout: t.Union[float, int] = None,
+        ttl: t.Union[float, int] = None,
         version: str = None,
     ) -> bool:
         client = self._get_client()
         value = self._serializer.dumps(value)
-        if timeout == 0:
+        if ttl == 0:
             await client.delete(key)
 
-        return bool(await client.set(key, value, ex=self.get_backend_timeout(timeout)))
+        return bool(await client.set(key, value, ex=self.get_backend_ttl(ttl)))
 
     @make_key_decorator
     async def delete_async(self, key: str, version: str = None) -> bool:
@@ -156,13 +150,13 @@ async def delete_async(self, key: str, version: str = None) -> bool:
 
     @make_key_decorator
     async def touch_async(
-        self, key: str, timeout: t.Union[float, int] = None, version: str = None
+        self, key: str, ttl: t.Union[float, int] = None, version: str = None
     ) -> bool:
         client = self._get_client()
-        if timeout is None:
+        if ttl is None:
             res = await client.persist(key)
             return bool(res)
-        res = await client.expire(key, self.get_backend_timeout(timeout))
+        res = await client.expire(key, self.get_backend_ttl(ttl))
         return bool(res)
 
     @make_key_decorator

ellar/cache/backends/redis/backend.py

@@ -3,13 +3,11 @@
 from functools import wraps
 
 from ellar.cache.interface import ICacheService
+from ellar.common import Context, Provide, extra_args
 from ellar.core import ExecutionContext, IExecutionContext
 from ellar.core.params import ExtraEndpointArg
 from ellar.helper import is_async_callable
 
-from .decorators.extra_args import extra_args
-from .routing.params import Context, Provide
-
 
 class _CacheDecorator:
     __slots__ = (
@@ -18,7 +16,7 @@ class _CacheDecorator:
         "_version",
         "_backend",
         "_func",
-        "_timeout",
+        "_ttl",
         "_cache_service_arg",
         "_context_arg",
         "_make_key_callback",
@@ -27,7 +25,7 @@ class _CacheDecorator:
     def __init__(
         self,
         func: t.Callable,
-        timeout: t.Union[int, float],
+        ttl: t.Union[int, float],
         *,
         key_prefix: str = "",
         version: str = None,
@@ -39,7 +37,7 @@ def __init__(
         self._version = version
         self._backend = backend
         self._func = func
-        self._timeout = timeout
+        self._ttl = ttl
 
         # create extra args
         self._cache_service_arg = ExtraEndpointArg(
@@ -87,7 +85,7 @@ async def _async_wrapper(*args: t.Any, **kwargs: t.Any) -> t.Any:
             await cache_service.set_async(
                 key,
                 response,
-                timeout=self._timeout,
+                ttl=self._ttl,
                 version=self._version,
                 backend=self._backend,
             )
@@ -116,7 +114,7 @@ def _wrapper(*args: t.Any, **kwargs: t.Any) -> t.Any:
             cache_service.set(
                 key,
                 response,
-                timeout=self._timeout,
+                ttl=self._ttl,
                 version=self._version,
                 backend=self._backend,
             )
@@ -126,7 +124,7 @@ def _wrapper(*args: t.Any, **kwargs: t.Any) -> t.Any:
 
 
 def cache(
-    timeout: t.Union[float, int],
+    ttl: t.Union[float, int],
     *,
     key_prefix: str = "",
     version: str = None,
@@ -135,10 +133,20 @@ def cache(
         [t.Union[ExecutionContext, IExecutionContext], str], str
     ] = None,
 ) -> t.Callable:
+    """
+
+    :param ttl: the time to live
+    :param key_prefix: cache key prefix
+    :param version: will be used in constructing the key
+    :param backend: Cache Backend to use. Default is `default`
+    :param make_key_callback: Key dynamic construct.
+    :return: TCallable
+    """
+
     def _wraps(func: t.Callable) -> t.Callable:
         cache_decorator = _CacheDecorator(
             func,
-            timeout,
+            ttl,
             key_prefix=key_prefix,
             version=version,
             backend=backend,