Added test for incr and decr command and drop aiomemcache support

Author: eadwinCode

ellar/cache/backends/__init__.py

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

ellar/cache/backends/_aio_cache.py

@@ -0,0 +1,132 @@
+# import pickle
+# import typing as t
+# from abc import ABC
+#
+# from ellar.helper.event_loop import get_or_create_eventloop
+#
+# try:
+#     from aiomcache import Client
+# except ImportError as e:  # pragma: no cover
+#     raise RuntimeError(
+#         "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):
+#     def _async_executor(self, func: t.Awaitable) -> t.Any:
+#         return get_or_create_eventloop().run_until_complete(func)
+#
+#     def get(self, key: str, version: str = None) -> t.Any:
+#         return self._async_executor(self.get_async(key, version=version))
+#
+#     def delete(self, key: str, version: str = None) -> bool:
+#         res = self._async_executor(self.delete_async(key, version=version))
+#         return bool(res)
+#
+#     def set(
+#         self,
+#         key: str,
+#         value: t.Any,
+#         timeout: t.Union[float, int] = None,
+#         version: str = None,
+#     ) -> bool:
+#         res = self._async_executor(
+#             self.set_async(key, value, version=version, timeout=timeout)
+#         )
+#         return bool(res)
+#
+#     def touch(
+#         self, key: str, timeout: t.Union[float, int] = None, version: str = None
+#     ) -> bool:
+#         res = self._async_executor(
+#             self.touch_async(key, version=version, timeout=timeout)
+#         )
+#         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."""
+#
+#     pickle_protocol = pickle.HIGHEST_PROTOCOL
+#     MEMCACHE_CLIENT: t.Type = Client
+#
+#     def __init__(
+#         self,
+#         host: str,
+#         port: int = 11211,
+#         pool_size: int = 2,
+#         pool_minsize: int = None,
+#         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 or AioCacheSerializer()
+#
+#     def get_backend_timeout(self, timeout: t.Union[float, int] = None) -> int:
+#         return int(super().get_backend_timeout(timeout))
+#
+#     @property
+#     def _cache_client(self) -> Client:
+#         if self._client is None:
+#             self._client = self.MEMCACHE_CLIENT(**self._client_options)
+#         return self._client
+#
+#     @make_key_decorator
+#     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._serializer.load(value)
+#         return None  # pragma: no cover
+#
+#     @make_key_decorator_and_validate
+#     async def set_async(
+#         self,
+#         key: str,
+#         value: t.Any,
+#         timeout: t.Union[float, int] = None,
+#         version: str = None,
+#     ) -> bool:
+#         return await self._cache_client.set(
+#             key.encode("utf-8"),
+#             self._serializer.dumps(value),
+#             exptime=self.get_backend_timeout(timeout),
+#         )
+#
+#     @make_key_decorator
+#     async def delete_async(self, key: str, version: str = None) -> bool:
+#         return await self._cache_client.delete(key.encode("utf-8"))
+#
+#     @make_key_decorator
+#     async def touch_async(
+#         self, key: str, timeout: t.Union[float, int] = None, version: str = None
+#     ) -> bool:
+#         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/aio_cache.py

@@ -46,17 +46,16 @@ def touch(
 
     @make_key_decorator
     def incr(self, key: str, delta: int = 1, version: str = None) -> int:
-        result = self._cache_client.incr(key, delta)
+        result = self._cache_client.incr(key, abs(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)
+        result = self._cache_client.decr(key, abs(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()
+        """Many clients don't clean up connections properly."""
 
     def clear(self) -> None:
         self._cache_client.flush_all()

ellar/cache/backends/base.py

@@ -133,16 +133,21 @@ def _incr_decr_action(self, key: str, delta: int) -> int:
         self._cache[key] = pickled
         return new_value
 
+    @make_key_decorator
     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)
 
+    @make_key_decorator
     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)
+            res = self._incr_decr_action(key, delta * -1)
+            if res < 0:
+                return self._incr_decr_action(key, res * -1)
+            return res

ellar/cache/backends/local_cache.py

@@ -62,3 +62,6 @@ def __init__(self, servers: t.List[str], options: t.Dict = None, **kwargs: t.Any
         }
 
         super().__init__(servers, options=_options, **kwargs)
+
+    def close(self, **kwargs: t.Any) -> None:
+        self._cache_client.disconnect_all()

ellar/cache/backends/pymem_cache.py

@@ -129,7 +129,7 @@ def get_backend_timeout(
     async def get_async(self, key: str, version: str = None) -> t.Any:
         client = self._get_client()
         value = await client.get(key)
-        if value:
+        if value is not None:
             return self._serializer.load(value)
         return None
 

ellar/cache/backends/redis/backend.py

@@ -33,16 +33,16 @@ def dumps(self, data: t.Any) -> t.Any:
         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)
+# 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/backends/serializer.py

@@ -1,7 +1,7 @@
 import typing as t
 from abc import ABC, abstractmethod
 
-if t.TYPE_CHECKING:
+if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.cache.model import BaseCacheBackend