Added incr and decr functionality to cache service and cache backends

Author: eadwinCode

ellar/cache/backends/__init__.py

@@ -0,0 +1,3 @@
+from .serializer import AioCacheSerializer, ICacheSerializer, RedisSerializer
+
+__all__ = ["ICacheSerializer", "RedisSerializer", "AioCacheSerializer"]

ellar/cache/backends/aio_cache.py

@@ -11,10 +11,10 @@
         "To use `AioMemCacheBackend`, you have to install 'aiomcache' package e.g. `pip install aiomcache`"
     ) from e
 
-
 from ..interface import IBaseCacheBackendAsync
 from ..make_key_decorator import make_key_decorator, make_key_decorator_and_validate
 from ..model import BaseCacheBackend
+from .serializer import AioCacheSerializer, ICacheSerializer
 
 
 class _AioMemCacheBackendSync(IBaseCacheBackendAsync, ABC):
@@ -48,6 +48,14 @@ def touch(
         )
         return bool(res)
 
+    def incr(self, key: str, delta: int = 1, version: str = None) -> int:
+        res = self._async_executor(self.incr_async(key, delta=delta, version=version))
+        return t.cast(int, res)
+
+    def decr(self, key: str, delta: int = 1, version: str = None) -> int:
+        res = self._async_executor(self.decr_async(key, delta=delta, version=version))
+        return t.cast(int, res)
+
 
 class AioMemCacheBackend(_AioMemCacheBackendSync, BaseCacheBackend):
     """Memcached-based cache backend."""
@@ -61,17 +69,15 @@ def __init__(
         port: int = 11211,
         pool_size: int = 2,
         pool_minsize: int = None,
-        serializer: t.Callable = pickle.dumps,
-        deserializer: t.Callable = pickle.loads,
+        serializer: ICacheSerializer = None,
         **kwargs: t.Any
     ) -> None:
         super().__init__(**kwargs)
         self._client: Client = None  # type: ignore[assignment]
         self._client_options = dict(
             host=host, port=port, pool_size=pool_size, pool_minsize=pool_minsize
         )
-        self._serializer = serializer
-        self._deserializer = deserializer
+        self._serializer = serializer or AioCacheSerializer()
 
     def get_backend_timeout(self, timeout: t.Union[float, int] = None) -> int:
         return int(super().get_backend_timeout(timeout))
@@ -86,7 +92,7 @@ def _cache_client(self) -> Client:
     async def get_async(self, key: str, version: str = None) -> t.Optional[t.Any]:
         value = await self._cache_client.get(key.encode("utf-8"))
         if value:
-            return self._deserializer(value)
+            return self._serializer.load(value)
         return None  # pragma: no cover
 
     @make_key_decorator_and_validate
@@ -99,7 +105,7 @@ async def set_async(
     ) -> bool:
         return await self._cache_client.set(
             key.encode("utf-8"),
-            self._serializer(value, self.pickle_protocol),
+            self._serializer.dumps(value),
             exptime=self.get_backend_timeout(timeout),
         )
 
@@ -114,3 +120,13 @@ async def touch_async(
         return await self._cache_client.touch(
             key.encode("utf-8"), exptime=self.get_backend_timeout(timeout)
         )
+
+    @make_key_decorator
+    async def incr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+        res = await self._cache_client.incr(key.encode("utf-8"), increment=delta)
+        return t.cast(int, res)
+
+    @make_key_decorator
+    async def decr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+        res = await self._cache_client.decr(key.encode("utf-8"), decrement=delta)
+        return t.cast(int, res)

ellar/cache/backends/base.py

@@ -44,6 +44,16 @@ def touch(
         result = self._cache_client.touch(key, self.get_backend_timeout(timeout))
         return bool(result)
 
+    @make_key_decorator
+    def incr(self, key: str, delta: int = 1, version: str = None) -> int:
+        result = self._cache_client.incr(key, delta)
+        return t.cast(int, result)
+
+    @make_key_decorator
+    def decr(self, key: str, delta: int = 1, version: str = None) -> int:
+        result = self._cache_client.decr(key, delta)
+        return t.cast(int, result)
+
     def close(self, **kwargs: t.Any) -> None:
         # Many clients don't clean up connections properly.
         self._cache_client.disconnect_all()
@@ -111,3 +121,11 @@ async def clear_async(self) -> None:
     def validate_key(self, key: str) -> None:
         super().validate_key(key)
         self._memcache_key_warnings(key)
+
+    async def incr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+        res = await self.executor(self.incr, key, delta=delta, version=version)
+        return t.cast(int, res)
+
+    async def decr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+        res = await self.executor(self.decr, key, delta=delta, version=version)
+        return t.cast(int, res)

ellar/cache/backends/local_cache.py

@@ -44,6 +44,14 @@ def touch(
         )
         return bool(res)
 
+    def incr(self, key: str, delta: int = 1, version: str = None) -> int:
+        res = self._async_executor(self.incr_async(key, delta=delta, version=version))
+        return t.cast(int, res)
+
+    def decr(self, key: str, delta: int = 1, version: str = None) -> int:
+        res = self._async_executor(self.decr_async(key, delta=delta, version=version))
+        return t.cast(int, res)
+
 
 class LocalMemCacheBackend(_LocalMemCacheBackendSync, BaseCacheBackend):
     pickle_protocol = pickle.HIGHEST_PROTOCOL
@@ -116,3 +124,25 @@ async def touch_async(
     def has_key(self, key: str, version: str = None) -> bool:
         res = self._async_executor(self.has_key_async(key, version=version))
         return bool(res)
+
+    def _incr_decr_action(self, key: str, delta: int) -> int:
+        pickled = self._cache[key]
+        value = t.cast(int, pickle.loads(pickled))
+        new_value = value + delta
+        pickled = pickle.dumps(new_value, self.pickle_protocol)
+        self._cache[key] = pickled
+        return new_value
+
+    async def incr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+        async with self._lock:
+            if self._has_expired(key):
+                await self._delete(key)
+                raise ValueError("Key '%s' not found" % key)
+            return self._incr_decr_action(key, delta)
+
+    async def decr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+        async with self._lock:
+            if self._has_expired(key):
+                await self._delete(key)
+                raise ValueError("Key '%s' not found" % key)
+            return self._incr_decr_action(key, delta * -1)

ellar/cache/backends/redis/__init__.py

@@ -1,4 +1,3 @@
 from .backend import RedisCacheBackend
-from .serializer import IRedisSerializer
 
-__all__ = ["IRedisSerializer", "RedisCacheBackend"]
+__all__ = ["RedisCacheBackend"]

ellar/cache/backends/redis/backend.py

@@ -14,7 +14,7 @@
 from ...interface import IBaseCacheBackendAsync
 from ...make_key_decorator import make_key_decorator, make_key_decorator_and_validate
 from ...model import BaseCacheBackend
-from .serializer import IRedisSerializer, RedisSerializer
+from ..serializer import ICacheSerializer, RedisSerializer
 
 
 class _RedisCacheBackendSync(IBaseCacheBackendAsync, ABC):
@@ -48,6 +48,18 @@ def touch(
         )
         return bool(res)
 
+    def has_key(self, key: str, version: str = None) -> bool:
+        res = self._async_executor(self.has_key_async(key, version=version))
+        return bool(res)
+
+    def incr(self, key: str, delta: int = 1, version: str = None) -> int:
+        res = self._async_executor(self.incr_async(key, delta=delta, version=version))
+        return t.cast(int, res)
+
+    def decr(self, key: str, delta: int = 1, version: str = None) -> int:
+        res = self._async_executor(self.decr_async(key, delta=delta, version=version))
+        return t.cast(int, res)
+
 
 class RedisCacheBackend(_RedisCacheBackendSync, BaseCacheBackend):
     MEMCACHE_CLIENT: t.Any = Redis
@@ -68,7 +80,7 @@ def __init__(
         self,
         servers: t.List[str],
         options: t.Dict = None,
-        serializer: IRedisSerializer = None,
+        serializer: ICacheSerializer = None,
         **kwargs: t.Any
     ) -> None:
         super().__init__(**kwargs)
@@ -152,3 +164,21 @@ async def touch_async(
             return bool(res)
         res = await client.expire(key, self.get_backend_timeout(timeout))
         return bool(res)
+
+    @make_key_decorator
+    async def has_key_async(self, key: str, version: str = None) -> bool:
+        client = self._get_client()
+        res = await client.exists(key)
+        return bool(res)
+
+    @make_key_decorator
+    async def incr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+        client = self._get_client()
+        res = await client.incr(key, amount=delta)
+        return t.cast(int, res)
+
+    @make_key_decorator
+    async def decr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+        client = self._get_client()
+        res = await client.decr(key, amount=delta)
+        return t.cast(int, res)

ellar/cache/backends/redis/serializer.py ellar/cache/backends/serializer.pyellar/cache/backends/redis/serializer.py renamed to ellar/cache/backends/serializer.py

@@ -3,7 +3,7 @@
 from abc import ABC, abstractmethod
 
 
-class IRedisSerializer(ABC):
+class ICacheSerializer(ABC):
     default_protocol: int = pickle.HIGHEST_PROTOCOL
 
     @abstractmethod
@@ -15,7 +15,7 @@ def dumps(self, data: t.Any) -> t.Any:  # pragma: no cover
         ...
 
 
-class RedisSerializer(IRedisSerializer):
+class RedisSerializer(ICacheSerializer):
     def __init__(self, protocol: int = None) -> None:
         self._protocol = protocol or self.default_protocol
 
@@ -31,3 +31,18 @@ def dumps(self, data: t.Any) -> t.Any:
         if type(data) is int:
             return data
         return pickle.dumps(data, self._protocol)
+
+
+class AioCacheSerializer(RedisSerializer):
+    def load(self, data: t.Any) -> t.Any:
+        try:
+            return int(data.decode("utf-8"))
+        except ValueError:
+            return pickle.loads(data)
+
+    def dumps(self, data: t.Any) -> t.Any:
+        # Only skip pickling for integers, an int subclasses as bool should be
+        # pickled.
+        if type(data) is int:
+            return str(data).encode("utf-8")
+        return pickle.dumps(data, self._protocol)

ellar/cache/interface.py

@@ -54,6 +54,23 @@ async def touch_async(
         or False if the key does not exist.
         """
 
+    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.
+        """
+
+    @abstractmethod
+    async def incr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+        """
+        Increments the number stored at key by one. If the key does not exist, it is set to 0
+        """
+
+    @abstractmethod
+    async def decr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+        """
+        Decrements the number stored at key by one. If the key does not exist, it is set to 0
+        """
+
 
 class IBaseCacheBackendSync(ABC):
     @abstractmethod
@@ -104,6 +121,23 @@ def touch(
         or False if the key does not exist.
         """
 
+    def has_key(self, key: str, version: str = None) -> bool:
+        """
+        Return True if the key is in the cache and has not expired.
+        """
+
+    @abstractmethod
+    def incr(self, key: str, delta: int = 1, version: str = None) -> int:
+        """
+        Increments the number stored at key by one. If the key does not exist, it is set to 0
+        """
+
+    @abstractmethod
+    def decr(self, key: str, delta: int = 1, version: str = None) -> int:
+        """
+        Decrements the number stored at key by one. If the key does not exist, it is set to 0
+        """
+
 
 class ICacheServiceSync(ABC):
     @abstractmethod
@@ -168,6 +202,22 @@ def has_key(self, key: str, version: str = None, backend: str = None) -> bool:
         Return True if the key is in the cache and has not expired.
         """
 
+    @abstractmethod
+    def incr(
+        self, key: str, delta: int = 1, version: str = None, backend: str = None
+    ) -> int:
+        """
+        Increments the number stored at key by one. If the key does not exist, it is set to 0
+        """
+
+    @abstractmethod
+    def decr(
+        self, key: str, delta: int = 1, version: str = None, backend: str = None
+    ) -> int:
+        """
+        Decrements the number stored at key by one. If the key does not exist, it is set to 0
+        """
+
 
 class ICacheServiceAsync(ABC):
     @abstractmethod
@@ -238,6 +288,22 @@ async def has_key_async(
         Return True if the key is in the cache and has not expired.
         """
 
+    @abstractmethod
+    async def incr_async(
+        self, key: str, delta: int = 1, version: str = None, backend: str = None
+    ) -> int:
+        """
+        Increments the number stored at key by one. If the key does not exist, it is set to 0
+        """
+
+    @abstractmethod
+    async def decr_async(
+        self, key: str, delta: int = 1, version: str = None, backend: str = None
+    ) -> int:
+        """
+        Decrements the number stored at key by one. If the key does not exist, it is set to 0
+        """
+
 
 class ICacheService(ICacheServiceSync, ICacheServiceAsync, ABC):
     """Cache Service Interface"""

ellar/cache/service.py

@@ -12,6 +12,18 @@ class InvalidCacheBackendKeyException(Exception):
 
 
 class _CacheServiceSync(ICacheServiceSync):
+    def incr(
+        self, key: str, delta: int = 1, version: str = None, backend: str = None
+    ) -> int:
+        _backend = self.get_backend(backend)
+        return _backend.incr(key, delta=delta, version=version)
+
+    def decr(
+        self, key: str, delta: int = 1, version: str = None, backend: str = None
+    ) -> int:
+        _backend = self.get_backend(backend)
+        return _backend.decr(key, delta=delta, version=version)
+
     get_backend: t.Callable[..., BaseCacheBackend]
 
     def get(self, key: str, version: str = None, backend: str = None) -> t.Any:
@@ -110,3 +122,15 @@ async def has_key_async(
     ) -> bool:
         _backend = self.get_backend(backend)
         return await _backend.has_key_async(key, version=version)
+
+    async def incr_async(
+        self, key: str, delta: int = 1, version: str = None, backend: str = None
+    ) -> int:
+        _backend = self.get_backend(backend)
+        return await _backend.incr_async(key, delta=delta, version=version)
+
+    async def decr_async(
+        self, key: str, delta: int = 1, version: str = None, backend: str = None
+    ) -> int:
+        _backend = self.get_backend(backend)
+        return await _backend.decr_async(key, delta=delta, version=version)

ellar/common/decorators/modules.py

@@ -60,7 +60,7 @@ def Module(
     template_folder: t.Optional[str] = "templates",
     base_directory: t.Optional[t.Union[Path, str]] = None,
     static_folder: str = "static",
-    modules: t.Sequence[t.Type] = tuple(),
+    modules: t.Sequence[t.Union[t.Type, t.Any]] = tuple(),
     commands: t.Sequence[t.Union[t.Callable, "EllarTyper"]] = tuple(),
 ) -> t.Callable:
     """