restructure the hierarchy of clients for better logical isolation

Author: amirreza8002

django_valkey/async_cache/client/default.py

@@ -22,7 +22,7 @@
     from valkey.asyncio.lock import Lock
 
 
-class AsyncClientMethod(BaseClient):
+class AsyncClientMethods(BaseClient):
     async def aset(
         self,
         key,
@@ -1252,7 +1252,7 @@ async def ahrandfield(
     hrandfield = ahrandfield
 
 
-class AsyncDefaultClient(AsyncClientMethod):
+class BaseAsyncDefaultClient:
     CONNECTION_FACTORY_PATH = "django_valkey.async_cache.pool.AsyncConnectionFactory"
 
     def __contains__(self, item):
@@ -1298,3 +1298,7 @@ async def adisconnect(self, index: int = 0, client=None):
             await self.connection_factory.disconnect(client)
 
     disconnect = adisconnect
+
+
+class AsyncDefaultClient(BaseAsyncDefaultClient, AsyncClientMethods):
+    pass

django_valkey/async_cache/client/herd.py

@@ -9,40 +9,18 @@
 from valkey.exceptions import ConnectionError, ResponseError, TimeoutError
 from valkey.typing import EncodableT
 
-from django_valkey.async_cache.client import AsyncDefaultClient
+from django_valkey.async_cache.client.default import (
+    BaseAsyncDefaultClient,
+    AsyncClientMethods,
+)
 from django_valkey.client.herd import Marker, _is_expired
 from django_valkey.exceptions import ConnectionInterrupted
 from django_valkey.typings import KeyT
 
 _main_exceptions = (ConnectionError, ResponseError, TimeoutError, socket.timeout)
 
 
-class AsyncHerdClient(AsyncDefaultClient):
-    def __init__(self, *args, **kwargs):
-        self._marker = Marker()
-        self._herd_timeout: int = getattr(settings, "CACHE_HERD_TIMEOUT", 60)
-        super().__init__(*args, **kwargs)
-
-    async def _pack(self, value: Any, timeout) -> tuple[Marker, Any, int]:
-        herd_timeout = (timeout or self._backend.default_timeout) + int(time.time())
-        return self._marker, value, herd_timeout
-
-    async def _unpack(self, value: tuple[Marker, Any, int]) -> tuple[Any, bool]:
-        try:
-            marker, unpacked, herd_timeout = value
-        except (ValueError, TypeError):
-            return value, False
-
-        if not isinstance(marker, Marker):
-            return value, False
-
-        now = time.time()
-        if herd_timeout < now:
-            x = now - herd_timeout
-            return unpacked, _is_expired(x, self._herd_timeout)
-
-        return unpacked, False
-
+class AsyncHerdMethods(AsyncClientMethods):
     async def aset(
         self,
         key: KeyT,
@@ -199,3 +177,34 @@ async def atouch(self, key, timeout=DEFAULT_TIMEOUT, version=None, client=None):
         return True
 
     touch = atouch
+
+
+class BaseAsyncHerdClient(BaseAsyncDefaultClient):
+    def __init__(self, *args, **kwargs):
+        self._marker = Marker()
+        self._herd_timeout: int = getattr(settings, "CACHE_HERD_TIMEOUT", 60)
+        super().__init__(*args, **kwargs)
+
+    async def _pack(self, value: Any, timeout) -> tuple[Marker, Any, int]:
+        herd_timeout = (timeout or self._backend.default_timeout) + int(time.time())
+        return self._marker, value, herd_timeout
+
+    async def _unpack(self, value: tuple[Marker, Any, int]) -> tuple[Any, bool]:
+        try:
+            marker, unpacked, herd_timeout = value
+        except (ValueError, TypeError):
+            return value, False
+
+        if not isinstance(marker, Marker):
+            return value, False
+
+        now = time.time()
+        if herd_timeout < now:
+            x = now - herd_timeout
+            return unpacked, _is_expired(x, self._herd_timeout)
+
+        return unpacked, False
+
+
+class AsyncHerdClient(BaseAsyncHerdClient, AsyncHerdMethods):
+    pass

django_valkey/client/default.py

@@ -10,14 +10,14 @@
 
 from django_valkey.base_client import BaseClient, _main_exceptions
 from django_valkey.exceptions import ConnectionInterrupted
-from django_valkey.typing import KeyT
+from django_valkey.typings import KeyT
 from django_valkey.util import CacheKey
 
 if TYPE_CHECKING:
     from valkey.lock import Lock
 
 
-class SyncClientMethod(BaseClient):
+class SyncClientMethods(BaseClient):
     def set(
         self,
         key: KeyT,
@@ -1202,7 +1202,7 @@ def hrandfield(
         return self.reverse_key(result.decode())
 
 
-class DefaultClient(SyncClientMethod):
+class BaseDefaultClient:
     CONNECTION_FACTORY_PATH = "django_valkey.pool.ConnectionFactory"
 
     def _get_client(self, write=True, tried=None, client=None) -> Valkey:
@@ -1245,3 +1245,7 @@ def get_client_with_index(
             self._clients[index] = self.connect(index)
 
         return self._clients[index], index
+
+
+class DefaultClient(BaseDefaultClient, SyncClientMethods):
+    pass

django_valkey/client/herd.py

@@ -11,9 +11,9 @@
 from valkey.exceptions import ConnectionError, ResponseError, TimeoutError
 from valkey.typing import EncodableT
 
-from django_valkey.client.default import DefaultClient
+from django_valkey.client.default import BaseDefaultClient, SyncClientMethods
 from django_valkey.exceptions import ConnectionInterrupted
-from django_valkey.typing import KeyT
+from django_valkey.typings import KeyT
 
 _main_exceptions = (ConnectionError, ResponseError, TimeoutError, socket.timeout)
 
@@ -33,32 +33,7 @@ def _is_expired(x, herd_timeout: int) -> bool:
     return val >= herd_timeout
 
 
-class HerdClient(DefaultClient):
-    def __init__(self, *args, **kwargs):
-        self._marker = Marker()
-        self._herd_timeout: int = getattr(settings, "CACHE_HERD_TIMEOUT", 60)
-        super().__init__(*args, **kwargs)
-
-    def _pack(self, value: Any, timeout) -> tuple[Marker, Any, int]:
-        herd_timeout = (timeout or self._backend.default_timeout) + int(time.time())
-        return self._marker, value, herd_timeout
-
-    def _unpack(self, value: tuple[Marker, Any, int]) -> tuple[Any, bool]:
-        try:
-            marker, unpacked, herd_timeout = value
-        except (ValueError, TypeError):
-            return value, False
-
-        if not isinstance(marker, Marker):
-            return value, False
-
-        now = time.time()
-        if herd_timeout < now:
-            x = now - herd_timeout
-            return unpacked, _is_expired(x, self._herd_timeout)
-
-        return unpacked, False
-
+class SyncHerdMethods(SyncClientMethods):
     def set(
         self,
         key: KeyT,
@@ -207,3 +182,34 @@ def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None, client=None):
 
         self.set(key, value, timeout=timeout, version=version, client=client)
         return True
+
+
+class BaseHerdClient(BaseDefaultClient):
+    def __init__(self, *args, **kwargs):
+        self._marker = Marker()
+        self._herd_timeout: int = getattr(settings, "CACHE_HERD_TIMEOUT", 60)
+        super().__init__(*args, **kwargs)
+
+    def _pack(self, value: Any, timeout) -> tuple[Marker, Any, int]:
+        herd_timeout = (timeout or self._backend.default_timeout) + int(time.time())
+        return self._marker, value, herd_timeout
+
+    def _unpack(self, value: tuple[Marker, Any, int]) -> tuple[Any, bool]:
+        try:
+            marker, unpacked, herd_timeout = value
+        except (ValueError, TypeError):
+            return value, False
+
+        if not isinstance(marker, Marker):
+            return value, False
+
+        now = time.time()
+        if herd_timeout < now:
+            x = now - herd_timeout
+            return unpacked, _is_expired(x, self._herd_timeout)
+
+        return unpacked, False
+
+
+class HerdClient(BaseHerdClient, SyncHerdMethods):
+    pass

django_valkey/client/sharded.py

@@ -10,44 +10,13 @@
 from valkey.exceptions import ConnectionError
 from valkey.typing import EncodableT
 
-from django_valkey.client.default import DefaultClient
+from django_valkey.client.default import BaseDefaultClient, SyncClientMethods
 from django_valkey.exceptions import ConnectionInterrupted
 from django_valkey.hash_ring import HashRing
 from django_valkey.typings import KeyT
 
 
-class ShardClient(DefaultClient):
-    _findhash = re.compile(r".*\{(.*)\}.*", re.I)
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        if not isinstance(self._server, (list, tuple, set)):
-            self._server = [self._server]
-
-        self._ring = HashRing(self._server)
-        self._server_dict = self.connect()
-
-    def get_client(self, *args, **kwargs):
-        raise NotImplementedError
-
-    def connect(self, index: int = 0) -> dict:
-        connection_dict = {}
-        for name in self._server:
-            connection_dict[name] = self.connection_factory.connect(name)
-        return connection_dict
-
-    def get_server_name(self, _key: KeyT) -> str:
-        key = str(_key)
-        g = self._findhash.match(key)
-        if g is not None and len(g.groups()) > 0:
-            key = g.groups()[0]
-        return self._ring.get_node(key)
-
-    def get_server(self, key: KeyT):
-        name = self.get_server_name(key)
-        return self._server_dict[name]
-
+class SyncShardMethods(SyncClientMethods):
     def add(
         self,
         key: KeyT,
@@ -602,3 +571,40 @@ def smismember(
             key = self.make_key(key, version=version)
             client = self.get_server(key)
         return super().smismember(key, *members, version=version, client=client)
+
+
+class BaseShardClient(BaseDefaultClient):
+    _findhash = re.compile(r".*\{(.*)\}.*", re.I)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        if not isinstance(self._server, (list, tuple, set)):
+            self._server = [self._server]
+
+        self._ring = HashRing(self._server)
+        self._server_dict = self.connect()
+
+    def get_client(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def connect(self, index: int = 0) -> dict:
+        connection_dict = {}
+        for name in self._server:
+            connection_dict[name] = self.connection_factory.connect(name)
+        return connection_dict
+
+    def get_server_name(self, _key: KeyT) -> str:
+        key = str(_key)
+        g = self._findhash.match(key)
+        if g is not None and len(g.groups()) > 0:
+            key = g.groups()[0]
+        return self._ring.get_node(key)
+
+    def get_server(self, key: KeyT):
+        name = self.get_server_name(key)
+        return self._server_dict[name]
+
+
+class ShardClient(BaseShardClient, SyncShardMethods):
+    pass

django_valkey/cluster_cache/client/default.py

@@ -2,11 +2,11 @@
 from valkey.typing import KeyT, EncodableT
 
 from django_valkey.base_client import _main_exceptions
-from django_valkey.client.default import SyncClientMethod
+from django_valkey.client.default import SyncClientMethods
 from django_valkey.exceptions import ConnectionInterrupted
 
 
-class DefaultClusterClient(SyncClientMethod):
+class BaseDefaultClusterClient:
     CONNECTION_FACTORY_PATH = (
         "django_valkey.cluster_cache.pool.ClusterConnectionFactory"
     )
@@ -54,6 +54,8 @@ def readwrite(self, target_nodes=None, client=None):
         client = self._get_client(write=True, client=client)
         return client.readwrite(target_nodes)
 
+
+class SyncClusterMethods(SyncClientMethods):
     def keys(
         self,
         pattern="*",
@@ -139,3 +141,7 @@ def flush_cache(self, client=None):
     def invalidate_key_from_cache(self, client=None):
         client = self._get_client(client=client)
         return client.invalidate_key_from_cache()
+
+
+class DefaultClusterClient(BaseDefaultClusterClient, SyncClusterMethods):
+    pass