coredis 4.24.0__py3-none-any.whl → 5.0.0rc1__py3-none-any.whl

coredis/__init__.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 from typing import cast
 
-from coredis.client import KeyDB, KeyDBCluster, Redis, RedisCluster
+from coredis.client import Redis, RedisCluster
 from coredis.config import Config
 from coredis.connection import (
     BaseConnection,
@@ -30,8 +30,6 @@ from . import _version
 
 __all__ = [
     "Config",
-    "KeyDB",
-    "KeyDBCluster",
     "Redis",
     "RedisCluster",
     "BaseConnection",

coredis/_packer.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 from coredis.constants import SYM_CRLF, SYM_DOLLAR, SYM_EMPTY, SYM_STAR
-from coredis.typing import ValueT
+from coredis.typing import RedisValueT
 
 
 class Packer:
     def __init__(self, encoding: str):
         self.encoding = encoding
 
-    def encode(self, value: ValueT) -> bytes:
+    def encode(self, value: RedisValueT) -> bytes:
         """Returns a bytestring representation of the value"""
         if isinstance(value, str):
             return value.encode(self.encoding)
@@ -18,7 +18,7 @@ class Packer:
             return b"%.15g" % value
         return value
 
-    def pack_command(self, command: bytes, *args: ValueT) -> list[bytes]:
+    def pack_command(self, command: bytes, *args: RedisValueT) -> list[bytes]:
         "Pack a series of arguments into the Redis protocol"
         output: list[bytes] = []
         # the client might have included 1 or more literal arguments in
@@ -50,22 +50,22 @@ class Packer:
         output.append(buff)
         return output
 
-    def pack_commands(self, commands: list[tuple[ValueT, ...]]) -> list[bytes]:
+    def pack_commands(self, commands: list[tuple[RedisValueT, ...]]) -> list[bytes]:
         output: list[bytes] = []
-        pieces: list[bytes] = []
+        command_arguments: list[bytes] = []
         buffer_length = 0
 
         for cmd in commands:
             for chunk in self.pack_command(self.encode(cmd[0]), *cmd[1:]):
-                pieces.append(chunk)
+                command_arguments.append(chunk)
                 buffer_length += len(chunk)
 
             if buffer_length > 6000:
-                output.append(SYM_EMPTY.join(pieces))
+                output.append(SYM_EMPTY.join(command_arguments))
                 buffer_length = 0
-                pieces = []
+                command_arguments = []
 
-        if pieces:
-            output.append(SYM_EMPTY.join(pieces))
+        if command_arguments:
+            output.append(SYM_EMPTY.join(command_arguments))
 
         return output

coredis/_protocols.py

@@ -1,43 +1,50 @@
 from __future__ import annotations
 
 import asyncio
-from types import TracebackType
 
 from typing_extensions import runtime_checkable
 
+from coredis.response._callbacks import NoopCallback
 from coredis.typing import (
+    TYPE_CHECKING,
     Awaitable,
     Callable,
+    ExecutionParameters,
     KeyT,
     Parameters,
     Protocol,
     R,
+    RedisCommandP,
+    RedisValueT,
     ResponseType,
     StringT,
     TypeVar,
+    Unpack,
     ValueT,
 )
 
 T_co = TypeVar("T_co", covariant=True)
 
 
+if TYPE_CHECKING:
+    from coredis.commands import CommandRequest
+
+
 class AbstractExecutor(Protocol):
-    async def execute_command(
+    def execute_command(
         self,
-        command: bytes,
-        *args: ValueT,
-        callback: Callable[..., R] = ...,
-        **options: ValueT | None,
-    ) -> R: ...
-
+        command: RedisCommandP,
+        callback: Callable[..., R] = NoopCallback(),
+        **options: Unpack[ExecutionParameters],
+    ) -> Awaitable[R]: ...
 
-@runtime_checkable
-class SupportsPipeline(Protocol):  # noqa
-    async def pipeline(
+    def create_request(
         self,
-        transaction: bool | None = True,
-        watches: Parameters[StringT] | None = None,
-    ) -> SupportsWatch: ...
+        name: bytes,
+        *arguments: ValueT,
+        callback: Callable[..., R],
+        execution_parameters: ExecutionParameters | None = None,
+    ) -> CommandRequest[R]: ...
 
 
 @runtime_checkable
@@ -46,35 +53,19 @@ class SupportsScript(Protocol[T_co]):  # noqa
         self,
         sha1: StringT,
         keys: Parameters[KeyT] | None = ...,
-        args: Parameters[ValueT] | None = ...,
+        args: Parameters[RedisValueT] | None = ...,
     ) -> ResponseType: ...
 
     async def evalsha_ro(
         self,
         sha1: StringT,
         keys: Parameters[KeyT] | None = ...,
-        args: Parameters[ValueT] | None = ...,
+        args: Parameters[RedisValueT] | None = ...,
     ) -> ResponseType: ...
 
     async def script_load(self, script: StringT) -> T_co: ...
 
 
-@runtime_checkable
-class SupportsWatch(Protocol):  # noqa
-    async def __aenter__(self) -> SupportsWatch: ...
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: TracebackType | None,
-    ) -> Awaitable[bool | None]: ...
-
-    async def watch(self, *keys: KeyT) -> bool: ...
-
-    async def execute(self, raise_on_error: bool = True) -> tuple[object, ...]: ...
-
-
 @runtime_checkable
 class ConnectionP(Protocol):
     decode_responses: bool

coredis/_py_311_typing.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from collections.abc import Hashable
+from typing import Any, TypeAlias
+
+from .typing import MutableSet, RedisError, ResponsePrimitive
+
+#: Represents the total structure of any response for any redis command.
+ResponseType: TypeAlias = (
+    ResponsePrimitive
+    | list[Any]
+    | MutableSet[Hashable]
+    | dict[
+        Hashable,
+        Any,
+    ]
+    | RedisError
+)
+#: Type alias for valid python types that can be represented as json
+JsonType: TypeAlias = str | int | float | bool | dict[str, Any] | list[Any] | None

coredis/_py_312_typing.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from collections.abc import Hashable
+
+from .typing import MutableSet, RedisError, ResponsePrimitive
+
+#: Type alias for valid python types that can be represented as json
+type JsonType = str | int | float | bool | dict[str, JsonType] | list[JsonType] | None
+
+#: Represents the total structure of any response for any redis command.
+type ResponseType = (
+    ResponsePrimitive
+    | RedisError
+    | list[ResponseType]
+    | MutableSet[Hashable]
+    | dict[Hashable, ResponseType]
+)

coredis/_utils.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 import enum
+from collections import UserDict
 from typing import Any
 
-from wrapt import ObjectProxy
-
 from coredis.typing import (
     Hashable,
     Iterable,
     Mapping,
+    MutableMapping,
     ResponseType,
     StringT,
     TypeVar,
@@ -18,61 +18,59 @@ T = TypeVar("T")
 U = TypeVar("U")
 
 
-class EncodingInsensitiveDict(ObjectProxy):  # type: ignore
+class EncodingInsensitiveDict(UserDict[Any, Any]):
     def __init__(
         self,
-        dict: Mapping[Any, Any] | ResponseType | None = None,
+        initial: MutableMapping[Any, Any] | None = None,
         encoding: str = "utf-8",
     ):
-        d = dict or {}
-        super().__init__(d)
-        self._self_encoding = encoding
-
-    def __getitem__(self, item: StringT) -> Any:
-        if isinstance(item, str) and item not in self.__wrapped__:
-            return self.__wrapped__.get(
-                item, self.__wrapped__.get(item.encode(self._self_encoding))
-            )
-        elif isinstance(item, bytes) and item not in self.__wrapped__:
-            return self.__wrapped__.get(
-                item, self.__wrapped__.get(item.decode(self._self_encoding))
-            )
-        return self.__wrapped__[item]
-
-    def get(self, item: StringT, default: object | None = None) -> Any:
-        return self.__getitem__(item) or default
-
-    def pop(self, item: StringT, default: object | None = None) -> Any:
-        if item in self.__wrapped__:
-            return self.__wrapped__.pop(item)
-        if isinstance(item, str):
-            return self.__wrapped__.pop(item.encode(self._self_encoding), default)
-
-    def clear(self) -> None:
-        self.__wrapped__.clear()
-
-    def update(self, updates: Mapping[Any, Any]) -> None:
-        self.__wrapped__.update(updates)
-
-    def __setitem__(self, item: StringT, value: object) -> None:
-        if item in self.__wrapped__:
-            self.__wrapped__[item] = value
-        elif isinstance(item, str) and item.encode(self._self_encoding) in self.__wrapped__:
-            self.__wrapped__[item.encode(self._self_encoding)] = value
-        elif isinstance(item, bytes) and item.decode(self._self_encoding) in self.__wrapped__:
-            self.__wrapped__[item.decode(self._self_encoding)] = value
-        else:
-            self.__wrapped__[item] = value
-
-    def __contains__(self, key: StringT) -> bool:
+        self._encoding = encoding
+        super().__init__(initial or {})
+
+    def _alt_key(self, key: StringT) -> StringT:
         if isinstance(key, str):
-            return key in self.__wrapped__ or key.encode(self._self_encoding) in self.__wrapped__
+            try:
+                byte_alt = key.encode(self._encoding)
+                if byte_alt in self.data:
+                    return byte_alt
+            except UnicodeEncodeError:
+                pass
         elif isinstance(key, bytes):
-            return key in self.__wrapped__ or key.decode(self._self_encoding) in self.__wrapped__
-        return key in self.__wrapped__
-
-    def __repr__(self) -> str:
-        return repr(self.__wrapped__)
+            try:
+                str_alt = key.decode(self._encoding)
+                if str_alt in self.data:
+                    return str_alt
+            except UnicodeDecodeError:
+                pass
+        return key
+
+    def __getitem__(self, key: StringT) -> Any:
+        if key in self.data:
+            return self.data[key]
+        alt = self._alt_key(key)
+        if alt in self.data:
+            return self.data[alt]
+        raise KeyError(key)
+
+    def __setitem__(self, key: StringT, value: Any) -> None:
+        alt = self._alt_key(key)
+        self.data[alt] = value
+
+    def __delitem__(self, key: StringT) -> None:
+        alt = self._alt_key(key)
+        del self.data[alt]
+
+    def __contains__(self, key: Any) -> bool:
+        return key in self.data or self._alt_key(key) in self.data
+
+    def get(self, key: StringT, default: Any = None) -> Any:
+        return self.data.get(key, self.data.get(self._alt_key(key), default))
+
+    def pop(self, key: StringT, default: Any = None) -> Any:
+        if key in self.data:
+            return self.data.pop(key)
+        alt = self._alt_key(key)
+        return self.data.pop(alt, default)
 
 
 @enum.unique

coredis/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-07-05T19:34:23-0700",
+ "date": "2025-07-07T11:41:52-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "cd4583e1ad0eb6d8ca23e80203ab230efe1e3b2e",
- "version": "4.24.0"
+ "full-revisionid": "e2034feabddbed8c1a549ccc53976ca41d724a00",
+ "version": "5.0.0rc1"
 }
 '''  # END VERSION_JSON
 

coredis/cache.py

@@ -18,11 +18,9 @@ from coredis.typing import (
     Literal,
     ModuleType,
     OrderedDict,
-    Protocol,
+    RedisValueT,
     ResponseType,
     TypeVar,
-    ValueT,
-    runtime_checkable,
 )
 
 asizeof: ModuleType | None = None
@@ -73,16 +71,16 @@ class CacheStats:
             counter.clear()
             counter[b"__coredis__internal__stats__total"] = total
 
-    def hit(self, key: ValueT) -> None:
+    def hit(self, key: RedisValueT) -> None:
         self.hits[b(key)] += 1
 
-    def miss(self, key: ValueT) -> None:
+    def miss(self, key: RedisValueT) -> None:
         self.misses[b(key)] += 1
 
-    def invalidate(self, key: ValueT) -> None:
+    def invalidate(self, key: RedisValueT) -> None:
         self.invalidations[b(key)] += 1
 
-    def mark_dirty(self, key: ValueT) -> None:
+    def mark_dirty(self, key: RedisValueT) -> None:
         self.dirty[b(key)] += 1
 
     @property
@@ -135,47 +133,28 @@ class AbstractCache(ABC):
         ...
 
     @abstractmethod
-    def get(self, command: bytes, key: bytes, *args: ValueT) -> ResponseType:
+    def get(self, command: bytes, key: RedisValueT, *args: RedisValueT) -> ResponseType:
         """
         Fetch the cached response for command/key/args combination
         """
         ...
 
     @abstractmethod
-    def put(self, command: bytes, key: bytes, *args: ValueT, value: ResponseType) -> None:
+    def put(
+        self, command: bytes, key: RedisValueT, *args: RedisValueT, value: ResponseType
+    ) -> None:
         """
         Cache the response for command/key/args combination
         """
         ...
 
     @abstractmethod
-    def invalidate(self, *keys: ValueT) -> None:
+    def invalidate(self, *keys: RedisValueT) -> None:
         """
         Invalidate any cached entries for the provided keys
         """
         ...
 
-    @abstractmethod
-    def reset(self) -> None:
-        """
-        Reset the cache
-        """
-        ...
-
-    @abstractmethod
-    def shutdown(self) -> None:
-        """
-        Explicitly shutdown the cache
-        """
-        ...
-
-
-@runtime_checkable
-class SupportsStats(Protocol):
-    """
-    Protocol of a cache that provides cache statistics
-    """
-
     @property
     @abstractmethod
     def stats(self) -> CacheStats:
@@ -184,17 +163,6 @@ class SupportsStats(Protocol):
         """
         ...
 
-
-@runtime_checkable
-class SupportsSampling(Protocol):
-    """
-    If a cache implements :class:`SupportsSampling`, methods that support
-    caching will sample the response from the cache and test it against an uncached
-    response from the server based on the confidence returned by :attr:`confidence`.
-    The outcome of the validation will be fed back to the cache using :meth:`feedback`
-    and in the case that there was no match, the uncached response will be returned.
-    """
-
     @property
     @abstractmethod
     def confidence(self) -> float:
@@ -206,23 +174,13 @@ class SupportsSampling(Protocol):
         ...
 
     @abstractmethod
-    def feedback(self, command: bytes, key: bytes, *args: ValueT, match: bool) -> None:
+    def feedback(self, command: bytes, key: RedisValueT, *args: RedisValueT, match: bool) -> None:
         """
         Provide feedback about a key as having either a match or drift from the actual
         server side value
         """
         ...
 
-
-@runtime_checkable
-class SupportsClientTracking(Protocol):
-    """
-    If a cache implements :class:`SupportsClientTracking`, the :class:`~coredis.Redis`
-    and :class:`~coredis.RedisCluster` clients will ensure that the client
-    returned by :meth:`get_client_id` is set using the :meth:`~coredis.Redis.client_tracking`
-    command on any connection returned by the clients.
-    """
-
     @abstractmethod
     def get_client_id(self, connection: BaseConnection) -> int | None:
         """
@@ -232,6 +190,20 @@ class SupportsClientTracking(Protocol):
         """
         ...
 
+    @abstractmethod
+    def reset(self) -> None:
+        """
+        Reset the cache
+        """
+        ...
+
+    @abstractmethod
+    def shutdown(self) -> None:
+        """
+        Explicitly shutdown the cache
+        """
+        ...
+
 
 ET = TypeVar("ET")
 
@@ -276,7 +248,7 @@ class LRUCache(Generic[ET]):
     def clear(self) -> None:
         self.__cache.clear()
 
-    def popitem(self) -> bool:
+    def popitem(self) -> tuple[Any, Any] | None:
         """
         Recursively remove the oldest entry. If
         the oldest entry is another LRUCache trigger
@@ -287,14 +259,14 @@ class LRUCache(Generic[ET]):
             oldest = next(iter(self.__cache))
             item = self.__cache[oldest]
         except StopIteration:
-            return False
+            return None
 
         if isinstance(item, LRUCache):
-            if item.popitem():
-                return True
-        self.__cache.popitem(last=False)
-
-        return True
+            if popped := item.popitem():
+                return popped
+        if entry := self.__cache.popitem(last=False):
+            return entry
+        return None
 
     def shrink(self) -> None:
         """
@@ -304,11 +276,11 @@ class LRUCache(Generic[ET]):
         """
 
         if self.max_bytes > 0 and asizeof is not None:
-            while asizeof.asizeof(self.__cache) > self.max_bytes:
-                if not self.popitem():
-                    # nothing left to remove
-
+            cur_size = asizeof.asizeof(self.__cache)
+            while cur_size > self.max_bytes:
+                if (popped := self.popitem()) is None:
                     return
+                cur_size -= asizeof.asizeof(popped[0]) + asizeof.asizeof(popped[1])
 
     def __repr__(self) -> str:
         if asizeof is not None:
@@ -316,7 +288,7 @@ class LRUCache(Generic[ET]):
                 f"LruCache<max_items={self.max_items}, "
                 f"current_items={len(self.__cache)}, "
                 f"max_bytes={self.max_bytes}, "
-                f"current_size_bytes={asizeof.asizeof(self)}>"
+                f"current_size_bytes={asizeof.asizeof(self.__cache)}>"
             )
         else:
             return f"LruCache<max_items={self.max_items}, current_items={len(self.__cache)}, "
@@ -329,9 +301,6 @@ class LRUCache(Generic[ET]):
 class NodeTrackingCache(
     Sidecar,
     AbstractCache,
-    SupportsStats,
-    SupportsSampling,
-    SupportsClientTracking,
 ):
     """
     An LRU cache that uses server assisted client caching
@@ -392,7 +361,7 @@ class NodeTrackingCache(
     def stats(self) -> CacheStats:
         return self.__stats
 
-    def get(self, command: bytes, key: bytes, *args: ValueT) -> ResponseType:
+    def get(self, command: bytes, key: RedisValueT, *args: RedisValueT) -> ResponseType:
         try:
             cached = self.__cache.get(b(key)).get(command).get(make_hashable(*args))
             self.__stats.hit(key)
@@ -402,17 +371,19 @@ class NodeTrackingCache(
             self.__stats.miss(key)
             raise
 
-    def put(self, command: bytes, key: bytes, *args: ValueT, value: ResponseType) -> None:
+    def put(
+        self, command: bytes, key: RedisValueT, *args: RedisValueT, value: ResponseType
+    ) -> None:
         self.__cache.setdefault(b(key), LRUCache()).setdefault(command, LRUCache()).insert(
             make_hashable(*args), value
         )
 
-    def invalidate(self, *keys: ValueT) -> None:
+    def invalidate(self, *keys: RedisValueT) -> None:
         for key in keys:
             self.__stats.invalidate(key)
             self.__cache.remove(b(key))
 
-    def feedback(self, command: bytes, key: bytes, *args: ValueT, match: bool) -> None:
+    def feedback(self, command: bytes, key: RedisValueT, *args: RedisValueT, match: bool) -> None:
         if not match:
             self.__stats.mark_dirty(key)
             self.invalidate(key)
@@ -509,7 +480,7 @@ class NodeTrackingCache(
                 break
 
 
-class ClusterTrackingCache(AbstractCache, SupportsStats, SupportsSampling, SupportsClientTracking):
+class ClusterTrackingCache(AbstractCache):
     """
     An LRU cache for redis cluster that uses server assisted client caching
     to ensure local cache entries are invalidated if any operations are performed
@@ -616,7 +587,7 @@ class ClusterTrackingCache(AbstractCache, SupportsStats, SupportsSampling, Suppo
         except KeyError:
             return None
 
-    def get(self, command: bytes, key: bytes, *args: ValueT) -> ResponseType:
+    def get(self, command: bytes, key: RedisValueT, *args: RedisValueT) -> ResponseType:
         try:
             cached = self.__cache.get(b(key)).get(command).get(make_hashable(*args))
             self.__stats.hit(key)
@@ -626,17 +597,19 @@ class ClusterTrackingCache(AbstractCache, SupportsStats, SupportsSampling, Suppo
             self.__stats.miss(key)
             raise
 
-    def put(self, command: bytes, key: bytes, *args: ValueT, value: ResponseType) -> None:
+    def put(
+        self, command: bytes, key: RedisValueT, *args: RedisValueT, value: ResponseType
+    ) -> None:
         self.__cache.setdefault(b(key), LRUCache()).setdefault(command, LRUCache()).insert(
             make_hashable(*args), value
         )
 
-    def invalidate(self, *keys: ValueT) -> None:
+    def invalidate(self, *keys: RedisValueT) -> None:
         for key in keys:
             self.__stats.invalidate(key)
             self.__cache.remove(b(key))
 
-    def feedback(self, command: bytes, key: bytes, *args: ValueT, match: bool) -> None:
+    def feedback(self, command: bytes, key: RedisValueT, *args: RedisValueT, match: bool) -> None:
         if not match:
             self.__stats.mark_dirty(key)
             self.invalidate(key)
@@ -663,7 +636,7 @@ class ClusterTrackingCache(AbstractCache, SupportsStats, SupportsSampling, Suppo
         self.shutdown()
 
 
-class TrackingCache(AbstractCache, SupportsStats, SupportsSampling, SupportsClientTracking):
+class TrackingCache(AbstractCache):
     """
     An LRU cache that uses server assisted client caching to ensure local cache entries
     are invalidated if any operations are performed on the keys by another client.
@@ -772,20 +745,22 @@ class TrackingCache(AbstractCache, SupportsStats, SupportsSampling, SupportsClie
 
         return None
 
-    def get(self, command: bytes, key: bytes, *args: ValueT) -> ResponseType:
+    def get(self, command: bytes, key: RedisValueT, *args: RedisValueT) -> ResponseType:
         assert self.instance
 
         return self.instance.get(command, key, *args)
 
-    def put(self, command: bytes, key: bytes, *args: ValueT, value: ResponseType) -> None:
+    def put(
+        self, command: bytes, key: RedisValueT, *args: RedisValueT, value: ResponseType
+    ) -> None:
         if self.instance:
             self.instance.put(command, key, *args, value=value)
 
-    def invalidate(self, *keys: ValueT) -> None:
+    def invalidate(self, *keys: RedisValueT) -> None:
         if self.instance:
             self.instance.invalidate(*keys)
 
-    def feedback(self, command: bytes, key: bytes, *args: ValueT, match: bool) -> None:
+    def feedback(self, command: bytes, key: RedisValueT, *args: RedisValueT, match: bool) -> None:
         if self.instance:
             self.instance.feedback(command, key, *args, match=match)
 

coredis/client/__init__.py

@@ -2,6 +2,5 @@ from __future__ import annotations
 
 from .basic import Client, Redis
 from .cluster import RedisCluster
-from .keydb import KeyDB, KeyDBCluster
 
-__all__ = ["Client", "Redis", "RedisCluster", "KeyDB", "KeyDBCluster"]
+__all__ = ["Client", "Redis", "RedisCluster"]