moved common functionality out of the client class and into functions

functions that are used by almost all the operations, `encode`, `decode`, `make_key` and `make_pattern` are moved out of the client class
the reason is the give an easy interface to users who want to use the raw client in their code

Author: amirreza8002

django_valkey/base_client.py

@@ -1,9 +1,7 @@
 import builtins
 from collections.abc import Iterable
 import random
-import re
 import socket
-from contextlib import suppress
 from typing import (
     Any,
     TYPE_CHECKING,
@@ -22,9 +20,8 @@
 
 from django_valkey import pool
 from django_valkey.compressors.identity import IdentityCompressor
-from django_valkey.exceptions import CompressorError
 from django_valkey.serializers.pickle import PickleSerializer
-from django_valkey.util import CacheKey
+from django_valkey.util import make_key, make_pattern, encode, decode
 from django_valkey.typings import KeyT
 
 if TYPE_CHECKING:
@@ -33,12 +30,6 @@
 
 _main_exceptions = (TimeoutError, ResponseError, ConnectionError, socket.timeout)
 
-special_re = re.compile("([*?[])")
-
-
-def glob_escape(s: str) -> str:
-    return special_re.sub(r"[\1]", s)
-
 
 class BaseClient:
     def __init__(
@@ -127,59 +118,34 @@ def decode(self, value: bytes) -> Any:
         """
         Decode the given value.
         """
-        try:
-            value = int(value) if value.isdigit() else float(value)
-        except (ValueError, TypeError):
-            # Handle little values, chosen to be not compressed
-            with suppress(CompressorError):
-                value = self._compressor.decompress(value)
-            value = self._serializer.loads(value)
-        except AttributeError:
-            # if value is None:
-            return value
-        return value
+        return decode(value, serializer=self._serializer, compressor=self._compressor)
 
     def encode(self, value: EncodableT) -> bytes | int | float:
         """
         Encode the given value.
         """
-
-        if type(value) is not int and type(value) is not float:
-            value = self._serializer.dumps(value)
-            return self._compressor.compress(value)
-
-        return value
+        return encode(value, serializer=self._serializer, compressor=self._compressor)
 
     def make_key(
         self, key: KeyT, version: int | None = None, prefix: str | None = None
     ) -> KeyT:
         """Return key as a CacheKey instance so it has additional methods"""
-        if isinstance(key, CacheKey):
-            return key
-
-        if prefix is None:
-            prefix = self._backend.key_prefix
-
-        if version is None:
-            version = self._backend.version
-
-        return CacheKey(self._backend.key_func(key, prefix, version))
+        return make_key(
+            key,
+            version=version or self._backend.version,
+            prefix=prefix or self._backend.key_prefix,
+            key_func=self._backend.key_func,
+        )
 
     def make_pattern(
         self, pattern: str, version: int | None = None, prefix: str | None = None
     ) -> KeyT:
-        if isinstance(pattern, CacheKey):
-            return pattern
-
-        if prefix is None:
-            prefix = self._backend.key_prefix
-        prefix = glob_escape(prefix)
-
-        if version is None:
-            version = self._backend.version
-        version_str = glob_escape(str(version))
-
-        return CacheKey(self._backend.key_func(pattern, prefix, version_str))
+        return make_pattern(
+            pattern,
+            version=version or self._backend.version,
+            prefix=prefix or self._backend.key_prefix,
+            key_func=self._backend.key_func,
+        )
 
     def _decode_iterable_result(
         self, result: Any, convert_to_set: bool = True

django_valkey/util.py

@@ -1,3 +1,17 @@
+from contextlib import suppress
+import re
+from typing import Any
+
+from django.core.cache.backends.base import get_key_func
+
+from valkey.typing import EncodableT
+
+from django_valkey.compressors.identity import IdentityCompressor
+from django_valkey.exceptions import CompressorError
+from django_valkey.serializers.pickle import PickleSerializer
+from django_valkey.typings import KeyT
+
+
 class CacheKey(str):
     """
     A stub string class that we can use to check if a key was created already.
@@ -9,3 +23,73 @@ def original_key(self) -> str:
 
 def default_reverse_key(key: str) -> str:
     return key.split(":", 2)[2]
+
+
+def make_key(
+    key: KeyT,
+    version: int | None = 1,
+    prefix: str | None = "",
+    key_func=get_key_func(None),
+) -> KeyT:
+    """Return key as a CacheKey instance so it has additional methods"""
+    if isinstance(key, CacheKey):
+        return key
+
+    return CacheKey(key_func(key, prefix, version))
+
+
+special_re = re.compile("([*?[])")
+
+
+def glob_escape(s: str) -> str:
+    return special_re.sub(r"[\1]", s)
+
+
+def make_pattern(
+    pattern: str,
+    version: int | None = 1,
+    prefix: str | None = "",
+    key_func=get_key_func(None),
+) -> KeyT:
+    if isinstance(pattern, CacheKey):
+        return pattern
+
+    prefix = glob_escape(prefix)
+    version_str = glob_escape(str(version))
+
+    return CacheKey(key_func(pattern, prefix, version_str))
+
+
+def decode(
+    value: bytes, serializer=PickleSerializer({}), compressor=IdentityCompressor({})
+) -> Any:
+    """
+    Decode the given value with the specified serializer and compressor.
+    """
+    try:
+        value = int(value) if value.isdigit() else float(value)  # type: ignore[assignment]
+    except (ValueError, TypeError):
+        # Handle little values, chosen to be not compressed
+        with suppress(CompressorError):
+            value = compressor.decompress(value)
+        value = serializer.loads(value)
+    except AttributeError:
+        # if value is None:
+        return value
+    return value
+
+
+def encode(
+    value: EncodableT,
+    serializer=PickleSerializer({}),
+    compressor=IdentityCompressor({}),
+) -> bytes | int | float:
+    """
+    Encode the given value using the specified serializer and compressor.
+    """
+
+    if type(value) is not int and type(value) is not float:
+        value = serializer.dumps(value)
+        return compressor.compress(value)
+
+    return value

tests/test_client.py

@@ -159,7 +159,7 @@ def test_delete_pattern_calls_pipeline_delete_and_execute(
 
 
 class TestShardClient:
-    @patch("tests.test_client.DefaultClient.make_pattern")
+    @patch("django_valkey.base_client.BaseClient.make_pattern")
     @patch("tests.test_client.ShardClient.__init__", return_value=None)
     def test_delete_pattern_calls_scan_iter_with_count_if_itersize_given(
         self, init_mock, make_pattern_mock
@@ -178,7 +178,7 @@ def test_delete_pattern_calls_scan_iter_with_count_if_itersize_given(
             count=10, match=make_pattern_mock.return_value
         )
 
-    @patch("tests.test_client.DefaultClient.make_pattern")
+    @patch("django_valkey.base_client.BaseClient.make_pattern")
     @patch("tests.test_client.ShardClient.__init__", return_value=None)
     def test_delete_pattern_calls_scan_iter(self, init_mock, make_pattern_mock):
         client = ShardClient()
@@ -194,7 +194,7 @@ def test_delete_pattern_calls_scan_iter(self, init_mock, make_pattern_mock):
             match=make_pattern_mock.return_value
         )
 
-    @patch("tests.test_client.DefaultClient.make_pattern")
+    @patch("django_valkey.base_client.BaseClient.make_pattern")
     @patch("tests.test_client.ShardClient.__init__", return_value=None)
     def test_delete_pattern_calls_delete_for_given_keys(
         self, init_mock, make_pattern_mock