Cache Feature completely documented

Author: eadwinCode

docs/caching.md

@@ -17,7 +17,7 @@
 from ..model import BaseCacheBackend
 
 
-class AioMemCacheBackendSync(IBaseCacheBackendAsync, ABC):
+class _AioMemCacheBackendSync(IBaseCacheBackendAsync, ABC):
     def _async_executor(self, func: t.Awaitable) -> t.Any:
         return get_or_create_eventloop().run_until_complete(func)
 
@@ -49,7 +49,7 @@ def touch(
         return bool(res)
 
 
-class AioMemCacheBackend(AioMemCacheBackendSync, BaseCacheBackend):
+class AioMemCacheBackend(_AioMemCacheBackendSync, BaseCacheBackend):
     """Memcached-based cache backend."""
 
     pickle_protocol = pickle.HIGHEST_PROTOCOL

ellar/cache/backends/aio_cache.py

@@ -7,7 +7,7 @@
 from ..model import BaseCacheBackend
 
 
-class BasePylibMemcachedCacheSync(BaseCacheBackend, ABC):
+class _BasePylibMemcachedCacheSync(BaseCacheBackend, ABC):
     _cache_client: t.Any
 
     @make_key_decorator
@@ -52,7 +52,7 @@ def clear(self) -> None:
         self._cache_client.flush_all()
 
 
-class BasePylibMemcachedCache(BasePylibMemcachedCacheSync):
+class BasePylibMemcachedCache(_BasePylibMemcachedCacheSync):
     MEMCACHE_CLIENT: t.Type
 
     def __init__(self, servers: t.List[str], options: t.Dict = None, **kwargs: t.Any):

ellar/cache/backends/base.py

@@ -13,7 +13,7 @@
 from ..model import BaseCacheBackend
 
 
-class LocalMemCacheBackendSync(IBaseCacheBackendAsync, ABC):
+class _LocalMemCacheBackendSync(IBaseCacheBackendAsync, ABC):
     def _async_executor(self, func: t.Awaitable) -> t.Any:
         return get_or_create_eventloop().run_until_complete(func)
 
@@ -45,7 +45,7 @@ def touch(
         return bool(res)
 
 
-class LocalMemCacheBackend(LocalMemCacheBackendSync, BaseCacheBackend):
+class LocalMemCacheBackend(_LocalMemCacheBackendSync, BaseCacheBackend):
     pickle_protocol = pickle.HIGHEST_PROTOCOL
 
     def __init__(self, **kwargs: t.Any) -> None:

ellar/cache/backends/local_cache.py

@@ -17,7 +17,7 @@
 from .serializer import IRedisSerializer, RedisSerializer
 
 
-class RedisCacheBackendSync(IBaseCacheBackendAsync, ABC):
+class _RedisCacheBackendSync(IBaseCacheBackendAsync, ABC):
     def _async_executor(self, func: t.Awaitable) -> t.Any:
         return get_or_create_eventloop().run_until_complete(func)
 
@@ -49,7 +49,7 @@ def touch(
         return bool(res)
 
 
-class RedisCacheBackend(RedisCacheBackendSync, BaseCacheBackend):
+class RedisCacheBackend(_RedisCacheBackendSync, BaseCacheBackend):
     MEMCACHE_CLIENT: t.Any = Redis
     """Redis-based cache backend.
 

ellar/cache/backends/redis/backend.py

@@ -1,6 +1,9 @@
 import typing as t
 from abc import ABC, abstractmethod
 
+if t.TYPE_CHECKING:
+    from ellar.cache.model import BaseCacheBackend
+
 
 class IBaseCacheBackendAsync(ABC):
     @abstractmethod
@@ -238,3 +241,10 @@ async def has_key_async(
 
 class ICacheService(ICacheServiceSync, ICacheServiceAsync, ABC):
     """Cache Service Interface"""
+
+    def get_backend(self, backend: str = None) -> "BaseCacheBackend":
+        """
+        Return a given Cache Backend configured by configuration backend name.
+        :param backend: Cache Backend configuration name. If not set, 'default' backend will be returned
+        :return: BaseCacheBackend
+        """

ellar/cache/interface.py

@@ -23,6 +23,10 @@ def __init__(
         self._version = version or 1
         self._default_timeout = int(timeout) if timeout else 300
 
+    @property
+    def key_prefix(self) -> str:
+        return self._key_prefix
+
     async def has_key_async(self, key: str, version: str = None) -> bool:
         """
         Return True if the key is in the cache and has not expired.

ellar/cache/model.py

@@ -7,7 +7,11 @@
 from .model import BaseCacheBackend
 
 
-class CacheServiceSync(ICacheServiceSync):
+class InvalidCacheBackendKeyException(Exception):
+    pass
+
+
+class _CacheServiceSync(ICacheServiceSync):
     _get_backend: t.Callable[..., BaseCacheBackend]
 
     def get(self, key: str, version: str = None, backend: str = None) -> t.Any:
@@ -45,7 +49,11 @@ def has_key(self, key: str, version: str = None, backend: str = None) -> bool:
 
 
 @injectable  # type: ignore
-class CacheService(CacheServiceSync, ICacheService):
+class CacheService(_CacheServiceSync, ICacheService):
+    """
+    A Cache Backend Service that wraps Ellar cache backends
+    """
+
     def __init__(self, backends: t.Dict[str, BaseCacheBackend] = None) -> None:
         if backends:
             assert backends.get(
@@ -55,20 +63,25 @@ def __init__(self, backends: t.Dict[str, BaseCacheBackend] = None) -> None:
             "default": LocalMemCacheBackend(key_prefix="ellar", version=1, timeout=300)
         }
 
-    def _get_backend(self, backend: str = None) -> BaseCacheBackend:
+    def get_backend(self, backend: str = None) -> BaseCacheBackend:
         _backend = backend or "default"
-        return self._backends[_backend]
+        try:
+            return self._backends[_backend]
+        except KeyError:
+            raise InvalidCacheBackendKeyException(
+                f"There is no backend configured with the name: '{_backend}'"
+            )
 
     async def get_async(
         self, key: str, version: str = None, backend: str = None
     ) -> t.Any:
-        _backend = self._get_backend(backend)
+        _backend = self.get_backend(backend)
         return await _backend.get_async(key, version=version)
 
     async def delete_async(
         self, key: str, version: str = None, backend: str = None
     ) -> bool:
-        _backend = self._get_backend(backend)
+        _backend = self.get_backend(backend)
         return bool(await _backend.delete_async(key, version=version))
 
     async def set_async(
@@ -79,7 +92,7 @@ async def set_async(
         version: str = None,
         backend: str = None,
     ) -> bool:
-        _backend = self._get_backend(backend)
+        _backend = self.get_backend(backend)
         return await _backend.set_async(key, value, timeout=timeout, version=version)
 
     async def touch_async(
@@ -89,11 +102,11 @@ async def touch_async(
         version: str = None,
         backend: str = None,
     ) -> bool:
-        _backend = self._get_backend(backend)
+        _backend = self.get_backend(backend)
         return await _backend.touch_async(key, timeout=timeout, version=version)
 
     async def has_key_async(
         self, key: str, version: str = None, backend: str = None
     ) -> bool:
-        _backend = self._get_backend(backend)
+        _backend = self.get_backend(backend)
         return await _backend.has_key_async(key, version=version)

ellar/cache/service.py

@@ -3,7 +3,7 @@
 from functools import wraps
 
 from ellar.cache.interface import ICacheService
-from ellar.core import IExecutionContext
+from ellar.core import ExecutionContext, IExecutionContext
 from ellar.core.params import ExtraEndpointArg
 from ellar.helper import is_async_callable
 
@@ -59,9 +59,7 @@ def get_decorator_wrapper(self) -> t.Callable:
             return self.get_async_cache_wrapper()
         return self.get_cache_wrapper()
 
-    def route_cache_make_key(
-        self, context: IExecutionContext, key_prefix: str = ""
-    ) -> str:
+    def route_cache_make_key(self, context: IExecutionContext, key_prefix: str) -> str:
         """Defaults key generator for caching view"""
         connection = context.switch_to_http_connection()
         return f"{connection.get_client().url}:{key_prefix or 'view'}"
@@ -73,7 +71,11 @@ def get_async_cache_wrapper(self) -> t.Callable:
         async def _async_wrapper(*args: t.Any, **kwargs: t.Any) -> t.Any:
             cache_service: ICacheService = self._cache_service_arg.resolve(kwargs)
             context: IExecutionContext = self._context_arg.resolve(kwargs)
-            key = self._make_key_callback(context, self._key_prefix or "")
+
+            backend = cache_service.get_backend(backend=self._backend)
+            key = self._make_key_callback(
+                context, self._key_prefix or backend.key_prefix
+            )
 
             cached_value = await cache_service.get_async(
                 key, self._version, backend=self._backend
@@ -99,9 +101,12 @@ def get_cache_wrapper(self) -> t.Callable:
         @wraps(self._func)
         def _wrapper(*args: t.Any, **kwargs: t.Any) -> t.Any:
             cache_service: ICacheService = self._cache_service_arg.resolve(kwargs)
-
             context: IExecutionContext = self._context_arg.resolve(kwargs)
-            key = self._make_key_callback(context, self._key_prefix or "")
+
+            backend = cache_service.get_backend(backend=self._backend)
+            key = self._make_key_callback(
+                context, self._key_prefix or backend.key_prefix
+            )
 
             cached_value = cache_service.get(key, self._version, backend=self._backend)
             if cached_value:
@@ -126,7 +131,9 @@ def cache(
     key_prefix: str = "",
     version: str = None,
     backend: str = "default",
-    make_key_callback: t.Callable[[IExecutionContext, str], str] = None,
+    make_key_callback: t.Callable[
+        [t.Union[ExecutionContext, IExecutionContext], str], str
+    ] = None,
 ) -> t.Callable:
     def _wraps(func: t.Callable) -> t.Callable:
         cache_decorator = CacheDecorator(