added Cache model and backends

Author: eadwinCode

ellar/cache/__init__.py

@@ -0,0 +1,104 @@
+import asyncio
+import pickle
+import typing as t
+from abc import ABC
+
+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
+from ..model import BaseCacheBackend
+
+
+class AioMemCacheBackendSync(IBaseCacheBackendAsync, ABC):
+    def _async_executor(self, func: t.Awaitable) -> t.Any:
+        return asyncio.get_event_loop().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: 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: int = None, version: str = None) -> bool:
+        res = self._async_executor(
+            self.touch_async(key, version=version, timeout=timeout)
+        )
+        return bool(res)
+
+
+class AioMemCacheBackend(AioMemCacheBackendSync, BaseCacheBackend):
+    """Memcached-based cache backend."""
+
+    pickle_protocol = pickle.HIGHEST_PROTOCOL
+
+    def __init__(
+        self,
+        host: str,
+        port: int = 11211,
+        pool_size: int = 2,
+        pool_minsize: int = None,
+        serializer: t.Callable = pickle.dumps,
+        deserializer: t.Callable = pickle.loads,
+        **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
+
+    def get_backend_timeout(self, timeout: int = None) -> int:
+        return int(super().get_backend_timeout(timeout))
+
+    @property
+    def _cache_client(self) -> Client:
+        if self._client is None:
+            self._client = 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=key.encode("utf-8"))
+        if value:
+            return self._deserializer(value)
+        return None  # pragma: no cover
+
+    @make_key_decorator
+    async def set_async(
+        self, key: str, value: t.Any, timeout: int = None, version: str = None
+    ) -> bool:
+        return await self._cache_client.set(
+            key.encode("utf-8"),
+            self._serializer(value, self.pickle_protocol),
+            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=key.encode("utf-8"))
+
+    @make_key_decorator
+    async def touch_async(
+        self, key: str, timeout: int = None, version: str = None
+    ) -> bool:
+        return await self._cache_client.touch(
+            key=key.encode("utf-8"), exptime=self.get_backend_timeout(timeout)
+        )

ellar/cache/backends/__init__.py

@@ -0,0 +1,110 @@
+import typing as t
+from abc import ABC
+
+from starlette.concurrency import run_in_threadpool
+
+from ..make_key_decorator import make_key_decorator, make_key_decorator_and_validate
+from ..model import BaseCacheBackend
+
+
+class BasePylibMemcachedCacheSync(BaseCacheBackend, ABC):
+    _cache_client: t.Any
+
+    @make_key_decorator
+    async def get(self, key: str, version: str = None) -> t.Any:
+        return self._cache_client.get(key)
+
+    @make_key_decorator_and_validate
+    def set(
+        self, key: str, value: t.Any, timeout: int = None, version: str = None
+    ) -> bool:
+        result = self._cache_client.set(
+            key, value, int(self.get_backend_timeout(timeout))
+        )
+        if not result:
+            # Make sure the key doesn't keep its old value in case of failure
+            # to set (memcached's 1MB limit).
+            self._cache_client.delete(key)
+            return False
+        return bool(result)
+
+    @make_key_decorator
+    def delete(self, key: str, version: str = None) -> bool:
+        result = self._cache_client.delete(key)
+        return bool(result)
+
+    @make_key_decorator
+    def touch(self, key: str, timeout: int = None, version: str = None) -> bool:
+        result = self._cache_client.touch(key, self.get_backend_timeout(timeout))
+        return bool(result)
+
+    def close(self, **kwargs: t.Any) -> None:
+        # Many clients don't clean up connections properly.
+        self._cache_client.disconnect_all()
+
+    def clear(self) -> None:
+        self._cache_client.flush_all()
+
+
+class BasePylibMemcachedCache(BasePylibMemcachedCacheSync):
+    def __init__(
+        self,
+        server: t.List[str],
+        library_client_type: t.Type,
+        options: t.Dict = None,
+        **kwargs: t.Any
+    ):
+        super().__init__(**kwargs)
+        self._servers = server
+
+        self._cache_client_class: t.Type = library_client_type
+        self._cache_client_init: t.Any = None
+        self._options = options or {}
+
+    @property
+    def client_servers(self) -> t.List[str]:
+        return self._servers
+
+    @property
+    def _cache_client(self) -> t.Any:
+        """
+        Implement transparent thread-safe access to a memcached client.
+        """
+        if self._cache_client_init is None:
+            self._cache_client_init = self._cache_client_class(
+                self.client_servers, **self._options
+            )
+        return self._cache_client_init
+
+    async def executor(self, func: t.Callable, *args: t.Any, **kwargs: t.Any) -> t.Any:
+        return await run_in_threadpool(func, *args, **kwargs)
+
+    async def get_async(self, key: str, version: str = None) -> t.Any:
+        return await self.executor(self.get, key)
+
+    async def set_async(
+        self, key: str, value: t.Any, timeout: int = None, version: str = None
+    ) -> bool:
+        result = await self.executor(self.set, key, value, timeout)
+        return bool(result)
+
+    async def delete_async(self, key: str, version: str = None) -> bool:
+        result = await self.executor(self.delete, key, version)
+        return bool(result)
+
+    async def touch_async(
+        self, key: str, timeout: int = None, version: str = None
+    ) -> bool:
+        result = await self.executor(self.touch, key, timeout)
+        return bool(result)
+
+    async def close_async(self, **kwargs: t.Any) -> None:
+        # Many clients don't clean up connections properly.
+        await self.executor(self._cache_client.disconnect_all)
+
+    async def clear_async(self) -> None:
+        await self.executor(self._cache_client.flush_all)
+
+    def validate_key(self, key: str) -> None:
+        super().validate_key(key)
+        self._memcache_key_warnings(key)

ellar/cache/backends/aio_cache.py

@@ -0,0 +1,35 @@
+"""
+PyLibMCCacheBackend inspired by Django PyLibMCCache
+"""
+import typing as t
+
+try:
+    from pylibmc import Client
+except ImportError as e:  # pragma: no cover
+    raise RuntimeError(
+        "To use `PyLibMCCacheBackend`, you have to install 'pylibmc' package e.g. `pip install pylibmc`"
+    ) from e
+
+from .base import BasePylibMemcachedCache
+
+
+class PyLibMCCacheBackend(BasePylibMemcachedCache):
+    """An implementation of a cache binding using pylibmc"""
+
+    def __init__(self, server: t.List[str], options: t.Dict = None, **kwargs: t.Any):
+        super().__init__(server, library_client_type=Client, options=options, **kwargs)
+
+    @property
+    def client_servers(self) -> t.List[str]:
+        output = []
+        for server in self._servers:
+            output.append(server.replace("unix:", ""))
+        return output
+
+    async def close_async(self, **kwargs: t.Any) -> None:
+        # libmemcached manages its own connections. Don't call disconnect_all()
+        # as it resets the failover state and creates unnecessary reconnects.
+        return None
+
+    def close(self, **kwargs: t.Any) -> None:
+        return None

ellar/cache/backends/base.py

@@ -0,0 +1,32 @@
+"""
+PyMemcacheCacheBackend inspired by Django PyMemcacheCache
+"""
+import typing as t
+
+try:
+    from pymemcache import HashClient
+    from pymemcache.serde import pickle_serde
+except ImportError as e:  # pragma: no cover
+    raise RuntimeError(
+        "To use `PyMemcacheCacheBackend`, you have to install 'pymemcache' package e.g. `pip install pymemcache`"
+    ) from e
+from .base import BasePylibMemcachedCache
+
+
+class PyMemcacheCacheBackend(BasePylibMemcachedCache):
+    """An implementation of a cache binding using pymemcache."""
+
+    def __init__(self, server: t.List[str], options: t.Dict = None, **kwargs: t.Any):
+
+        _default_options = options or {}
+
+        _options = {
+            "allow_unicode_keys": True,
+            "default_noreply": False,
+            "serde": pickle_serde,
+            **_default_options,
+        }
+
+        super().__init__(
+            server, library_client_type=HashClient, options=_options, **kwargs
+        )