Merge pull request #25 from amirreza8002/refactor

refactoring codebase

Author: amirreza8002

CHANGES.md

@@ -1,3 +1,26 @@
+Version 0.3.0
+-------------
+
+### New
+- now all operations support omitting exceptions
+- `make_key`, `make_pattern`, `encode` and `decode` are now functions, so they can be used outside the backend (e.g: when using the raw client)
+- `django_valkey.get_valkey_connection` now works with shard client as well
+
+### bug fix
+- fixed bug of `omit_exception` not handling generator and async generators
+- fixed bug of async `get_valkey_connection` checking if the client is async.
+
+### internal change
+- moved all operations from `django_valkey.cache` and `django_valkey.async_cache.cache` to `django_valkey.base`.
+- cluster client now uses the same methods as normal client, unless it has to have a specific method.
+- prefixing async methods with `a` is done dynamically now; (so no more `aset = set`), it's all handled in `__getattr__`.
+- moved async client methods to `django_valkey.base_client.AsyncClientCommands`.
+- moved sync client methods to `django_valkey.base_client.ClientCommands`.
+- `make_key`, `make_pattern`, `encode`, `decode`, `_decode_iterable_result` are now all sync methods and moved to `django_valkey.base_client.BaseClient`.
+- `AsyncHerdClient._pack` and `AsyncHerdClient._unpack` are now sync methods.
+- common parts of herd clients now live in `django_valkey.base_client`
+- shard client now has `get_client` instead of `get_server`
+
 Version 0.2.0
 -------------
 

django_valkey/__init__.py

@@ -2,7 +2,7 @@
 __version__ = ".".join(map(str, VERSION))
 
 
-def get_valkey_connection(alias="default", write=True):
+def get_valkey_connection(alias="default", write=True, key=None):
     """
     Helper used for obtaining a raw valkey client.
     """
@@ -18,4 +18,7 @@ def get_valkey_connection(alias="default", write=True):
     if not hasattr(cache.client, "get_client"):
         raise NotImplementedError(error_message)
 
+    if hasattr(cache.client, "get_server_name"):
+        return cache.client.get_client(key=key)
+
     return cache.client.get_client(write)

django_valkey/async_cache/__init__.py

@@ -1,4 +1,4 @@
-from inspect import isawaitable
+from inspect import iscoroutinefunction
 
 
 async def get_valkey_connection(alias="default", write=True):
@@ -17,7 +17,7 @@ async def get_valkey_connection(alias="default", write=True):
     if not hasattr(cache.client, "get_client"):
         raise NotImplementedError(error_message)
 
-    if not isawaitable(cache.client.get_client):
+    if not iscoroutinefunction(cache.client.get_client):
         raise "use django_valkey.get_valkey_connection for sync backends"
 
     return await cache.client.get_client(write)

django_valkey/async_cache/cache.py

@@ -1,163 +1,10 @@
 from valkey.asyncio.client import Valkey as AValkey
 
-from django_valkey.base import BaseValkeyCache
-from django_valkey.cache import omit_exception, CONNECTION_INTERRUPTED
+from django_valkey.base import BaseValkeyCache, AsyncBackendCommands
 from django_valkey.async_cache.client.default import AsyncDefaultClient
 
 
-class AsyncValkeyCache(BaseValkeyCache[AsyncDefaultClient, AValkey]):
+class AsyncValkeyCache(
+    BaseValkeyCache[AsyncDefaultClient, AValkey], AsyncBackendCommands
+):
     DEFAULT_CLIENT_CLASS = "django_valkey.async_cache.client.default.AsyncDefaultClient"
-
-    mset = BaseValkeyCache.amset
-
-    keys = BaseValkeyCache.akeys
-
-    iter_keys = BaseValkeyCache.aiter_keys
-
-    ttl = BaseValkeyCache.attl
-
-    pttl = BaseValkeyCache.apttl
-
-    persist = BaseValkeyCache.apersist
-
-    expire = BaseValkeyCache.aexpire
-
-    expire_at = BaseValkeyCache.aexpire_at
-
-    pexpire = BaseValkeyCache.apexpire
-
-    pexpire_at = BaseValkeyCache.apexpire_at
-
-    lock = alock = get_lock = BaseValkeyCache.aget_lock
-
-    sadd = BaseValkeyCache.asadd
-
-    scard = BaseValkeyCache.ascard
-
-    sdiff = BaseValkeyCache.asdiff
-
-    sdiffstore = BaseValkeyCache.asdiffstore
-
-    sinter = BaseValkeyCache.asinter
-
-    sinterstore = BaseValkeyCache.asinterstore
-
-    sismember = BaseValkeyCache.asismember
-
-    smembers = BaseValkeyCache.asmembers
-
-    smove = BaseValkeyCache.asmove
-
-    spop = BaseValkeyCache.aspop
-
-    srandmember = BaseValkeyCache.asrandmember
-
-    srem = BaseValkeyCache.asrem
-
-    sscan = BaseValkeyCache.asscan
-
-    sscan_iter = BaseValkeyCache.asscan_iter
-
-    smismember = BaseValkeyCache.asmismember
-
-    sunion = BaseValkeyCache.asunion
-
-    sunionstore = BaseValkeyCache.asunionstore
-
-    hset = BaseValkeyCache.ahset
-
-    hdel = BaseValkeyCache.ahdel
-
-    hlen = BaseValkeyCache.ahlen
-
-    hkeys = BaseValkeyCache.ahkeys
-
-    hexists = BaseValkeyCache.ahexists
-
-    @omit_exception
-    async def set(self, *args, **kwargs):
-        return await self.client.aset(*args, **kwargs)
-
-    aset = set
-
-    @omit_exception
-    async def incr_version(self, *args, **kwargs):
-        return await self.client.aincr_version(*args, **kwargs)
-
-    aincr_version = incr_version
-
-    @omit_exception
-    async def add(self, *args, **kwargs):
-        return await self.client.aadd(*args, **kwargs)
-
-    aadd = add
-
-    async def get(self, key, default=None, version=None, client=None):
-        value = await self._get(key, default, version, client)
-        if value is CONNECTION_INTERRUPTED:
-            value = default
-        return value
-
-    aget = get
-
-    @omit_exception(return_value=CONNECTION_INTERRUPTED)
-    async def _get(self, key, default=None, version=None, client=None):
-        return await self.client.aget(key, default, version, client)
-
-    async def delete(self, *args, **kwargs):
-        result = await self.client.adelete(*args, **kwargs)
-        return bool(result)
-
-    adelete = delete
-
-    @omit_exception
-    async def delete_many(self, *args, **kwargs):
-        return await self.client.adelete_many(*args, **kwargs)
-
-    adelete_many = delete_many
-
-    @omit_exception
-    async def clear(self):
-        return await self.client.aclear()
-
-    aclear = clear
-
-    @omit_exception(return_value={})
-    async def get_many(self, *args, **kwargs):
-        return await self.client.aget_many(*args, **kwargs)
-
-    aget_many = get_many
-
-    @omit_exception
-    async def set_many(self, *args, **kwargs):
-        return await self.client.aset_many(*args, **kwargs)
-
-    aset_many = set_many
-
-    @omit_exception
-    async def incr(self, *args, **kwargs):
-        return await self.client.aincr(*args, **kwargs)
-
-    aincr = incr
-
-    @omit_exception
-    async def decr(self, *args, **kwargs):
-        return await self.client.adecr(*args, **kwargs)
-
-    adecr = decr
-
-    @omit_exception
-    async def has_key(self, *args, **kwargs):
-        return await self.client.ahas_key(*args, **kwargs)
-
-    ahas_key = has_key
-
-    @omit_exception
-    async def aclose(self, *args, **kwargs):
-        return await self.client.aclose()
-
-    @omit_exception
-    async def touch(self, *args, **kwargs):
-        return await self.client.touch(*args, **kwargs)
-
-    atouch = touch