coredis 4.24.0__tar.gz → 5.0.0rc1__tar.gz

{coredis-4.24.0 → coredis-5.0.0rc1}/HISTORY.rst

@@ -3,6 +3,29 @@
 Changelog
 =========
 
+v5.0.0rc1
+---------
+Release Date: 2025-07-07
+
+* Features
+
+  * Add support for using custom types with redis commands
+    by registering serializers and deserializers
+  * Allow stacking pipeline commands syncronously
+  * Expose statically types responses for pipeline commands
+
+
+* Compatibility
+
+  * Add support for redis 8.0 vector set commands
+  * Add support for redis 8.0 hash expiry commands
+  * Remove deprecated pubsub ``listen`` and threaded worker APIs
+  * Remove support for KeyDB
+
+* Performance
+
+  * Streamline client side cache shrinking
+
 v4.24.0
 -------
 Release Date: 2025-07-05
@@ -1939,3 +1962,4 @@ v1.0.1
 
 
 
+

{coredis-4.24.0/coredis.egg-info → coredis-5.0.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coredis
-Version: 4.24.0
+Version: 5.0.0rc1
 Summary: Python async client for Redis key-value store
 Home-page: https://github.com/alisaifee/coredis
 Author: Ali-Akber Saifee
@@ -26,11 +26,11 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: async_timeout<6,>4
+Requires-Dist: beartype>=0.20
 Requires-Dist: deprecated>=1.2
-Requires-Dist: typing_extensions>=4.3
+Requires-Dist: typing_extensions>=4.13
 Requires-Dist: packaging<26,>=21
 Requires-Dist: pympler<2,>1
-Requires-Dist: wrapt<2,>=1.1.0
 Provides-Extra: recipes
 Requires-Dist: aiobotocore>=2.15.2; extra == "recipes"
 Requires-Dist: asyncache>=0.3.1; extra == "recipes"
@@ -201,7 +201,7 @@ Details about supported Redis modules and their commands can be found
 
 ## Compatibility
 
-coredis is tested against redis versions >= `6.4`
+coredis is tested against redis versions >= `7.0`
 The test matrix status can be reviewed
 [here](https://github.com/alisaifee/coredis/actions/workflows/main.yml)
 
@@ -221,7 +221,6 @@ coredis is additionally tested against:
 
 **coredis** is known to work with the following databases that have redis protocol compatibility:
 
-- [KeyDB](https://docs.keydb.dev/)
 - [Dragonfly](https://dragonflydb.io/)
 - [Redict](https://redict.io/)
 - [Valkey](https://github.com/valkey-io/valkey)

{coredis-4.24.0 → coredis-5.0.0rc1}/README.md

@@ -148,7 +148,7 @@ Details about supported Redis modules and their commands can be found
 
 ## Compatibility
 
-coredis is tested against redis versions >= `6.4`
+coredis is tested against redis versions >= `7.0`
 The test matrix status can be reviewed
 [here](https://github.com/alisaifee/coredis/actions/workflows/main.yml)
 
@@ -168,7 +168,6 @@ coredis is additionally tested against:
 
 **coredis** is known to work with the following databases that have redis protocol compatibility:
 
-- [KeyDB](https://docs.keydb.dev/)
 - [Dragonfly](https://dragonflydb.io/)
 - [Redict](https://redict.io/)
 - [Valkey](https://github.com/valkey-io/valkey)

{coredis-4.24.0 → coredis-5.0.0rc1}/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-4.24.0 → coredis-5.0.0rc1}/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-5.0.0rc1/coredis/_protocols.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import asyncio
+
+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):
+    def execute_command(
+        self,
+        command: RedisCommandP,
+        callback: Callable[..., R] = NoopCallback(),
+        **options: Unpack[ExecutionParameters],
+    ) -> Awaitable[R]: ...
+
+    def create_request(
+        self,
+        name: bytes,
+        *arguments: ValueT,
+        callback: Callable[..., R],
+        execution_parameters: ExecutionParameters | None = None,
+    ) -> CommandRequest[R]: ...
+
+
+@runtime_checkable
+class SupportsScript(Protocol[T_co]):  # noqa
+    async def evalsha(
+        self,
+        sha1: StringT,
+        keys: Parameters[KeyT] | None = ...,
+        args: Parameters[RedisValueT] | None = ...,
+    ) -> ResponseType: ...
+
+    async def evalsha_ro(
+        self,
+        sha1: StringT,
+        keys: Parameters[KeyT] | None = ...,
+        args: Parameters[RedisValueT] | None = ...,
+    ) -> ResponseType: ...
+
+    async def script_load(self, script: StringT) -> T_co: ...
+
+
+@runtime_checkable
+class ConnectionP(Protocol):
+    decode_responses: bool
+    encoding: str
+    push_messages: asyncio.Queue[ResponseType]

coredis-5.0.0rc1/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-5.0.0rc1/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-4.24.0 → coredis-5.0.0rc1}/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-4.24.0 → coredis-5.0.0rc1}/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