move key/value related methods to a function

this was done so people can use them with a raw client

(cherry picked from commit d39a5ab)

Author: amirreza8002

django_valkey/base_client.py

@@ -4,7 +4,6 @@
 import socket
 import time
 from collections.abc import AsyncGenerator, Iterable, Iterator
-from contextlib import suppress
 from typing import (
     Any,
     Dict,
@@ -28,9 +27,9 @@
 from django_valkey import pool
 from django_valkey.base import ATTR_DOES_NOT_EXIST
 from django_valkey.compressors.identity import IdentityCompressor
-from django_valkey.exceptions import CompressorError, ConnectionInterrupted
+from django_valkey.exceptions import ConnectionInterrupted
 from django_valkey.serializers.pickle import PickleSerializer
-from django_valkey.util import CacheKey
+from django_valkey.util import CacheKey, decode, encode, make_key, make_pattern
 
 if TYPE_CHECKING:
     from valkey.lock import Lock
@@ -132,28 +131,16 @@ def decode(self, value: bytes) -> Any:
         """
         Decode the given value.
         """
-        try:
-            if value.isdigit():
-                value = int(value)
-            else:
-                value = 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)
-        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=value, serializer=self._serializer, compressor=self._compressor
+        )
 
     def _decode_iterable_result(
         self, result: Any, convert_to_set: bool = True
@@ -170,32 +157,22 @@ 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,
+            key_func=self._backend.key_func,
+            version=version or self._backend.version,
+            prefix=prefix or self._backend.key_prefix,
+        )
 
     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=pattern,
+            key_func=self._backend.key_func,
+            version=version or self._backend.version,
+            prefix=prefix or self._backend.key_prefix,
+        )
 
 
 class ClientCommands(Generic[Backend]):

django_valkey/util.py

@@ -1,3 +1,14 @@
+import re
+from contextlib import suppress
+from typing import Any
+
+from valkey.typing import KeyT, EncodableT
+
+from django_valkey.compressors.base import BaseCompressor
+from django_valkey.exceptions import CompressorError
+from django_valkey.serializers.base import BaseSerializer
+
+
 class CacheKey(str):
     """
     A stub string class that we can use to check if a key was created already.
@@ -9,3 +20,56 @@ def original_key(self) -> str:
 
 def default_reverse_key(key: str) -> str:
     return key.split(":", 2)[2]
+
+
+special_re = re.compile("([*?[])")
+
+
+def glob_escape(s: str) -> str:
+    return special_re.sub(r"[\1]", s)
+
+
+def make_key(
+    key: KeyT, key_func, version: int | None = None, prefix: str | None = None
+) -> KeyT:
+    if isinstance(key, CacheKey):
+        return key
+
+    return CacheKey(key_func(key, prefix, version))
+
+
+def make_pattern(
+    pattern: str, key_func, version: int | None = None, prefix: str | None = 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 encode(
+    value: EncodableT, serializer: BaseSerializer, compressor: BaseCompressor
+) -> bytes | int | float:
+    if type(value) not in {int, float}:
+        value = serializer.dumps(value)
+        return compressor.compress(value)
+
+    return value
+
+
+def decode(value: bytes, serializer: BaseSerializer, compressor: BaseCompressor) -> Any:
+    try:
+        if value.isdigit():
+            value = int(value)
+        else:
+            value = float(value)
+
+    except (ValueError, TypeError):
+        with suppress(CompressorError):
+            value = compressor.decompress(value)
+        value = serializer.loads(value)
+
+    return value