coredis 5.0.0rc2__tar.gz → 5.0.1__tar.gz

{coredis-5.0.0rc2 → coredis-5.0.1}/HISTORY.rst

@@ -3,6 +3,41 @@
 Changelog
 =========
 
+v5.0.1
+------
+Release Date: 2025-07-18
+
+* Bug Fix
+
+  * Fix regression caused by ``5.0.0`` which completely broke the use of Sentinel
+    with ``decode_responses=False``.
+
+v5.0.0
+------
+Release Date: 2025-07-16
+
+* Features
+
+  * Add support for using custom types with redis commands
+    by registering serializers and deserializers
+  * Allow stacking pipeline commands synchronously
+  * Expose statically typed responses for pipeline commands
+
+
+* Compatibility
+
+  * Redis command methods are no longer coroutines and instead
+    synchronous methods that return subclasses of ``Awaitable``
+    (``CommandRequest``) which can be awaited as before.
+  * 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
+
 v5.0.0rc2
 ---------
 Release Date: 2025-07-10
@@ -1965,10 +2000,3 @@ v1.0.1
 * fix bug of `PubSub.run_in_thread`
 * add more examples
 * change `Script.register` to `Script.execute`
-
-
-
-
-
-
-

{coredis-5.0.0rc2/coredis.egg-info → coredis-5.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coredis
-Version: 5.0.0rc2
+Version: 5.0.1
 Summary: Python async client for Redis key-value store
 Home-page: https://github.com/alisaifee/coredis
 Author: Ali-Akber Saifee
@@ -14,7 +14,6 @@ Project-URL: Documentation, https://coredis.readthedocs.org
 Keywords: Redis,key-value store,asyncio
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.10

{coredis-5.0.0rc2 → coredis-5.0.1}/coredis/_protocols.py

@@ -10,14 +10,10 @@ from coredis.typing import (
     Awaitable,
     Callable,
     ExecutionParameters,
-    KeyT,
-    Parameters,
     Protocol,
     R,
     RedisCommandP,
-    RedisValueT,
     ResponseType,
-    StringT,
     TypeVar,
     Unpack,
     ValueT,
@@ -47,25 +43,6 @@ class AbstractExecutor(Protocol):
     ) -> CommandRequest[R]: ...
 
 
-@runtime_checkable
-class SupportsScript(Protocol[T_co]):  # noqa
-    def evalsha(
-        self,
-        sha1: StringT,
-        keys: Parameters[KeyT] | None = ...,
-        args: Parameters[RedisValueT] | None = ...,
-    ) -> CommandRequest[ResponseType]: ...
-
-    def evalsha_ro(
-        self,
-        sha1: StringT,
-        keys: Parameters[KeyT] | None = ...,
-        args: Parameters[RedisValueT] | None = ...,
-    ) -> CommandRequest[ResponseType]: ...
-
-    def script_load(self, script: StringT) -> CommandRequest[T_co]: ...
-
-
 @runtime_checkable
 class ConnectionP(Protocol):
     decode_responses: bool

{coredis-5.0.0rc2 → coredis-5.0.1}/coredis/_utils.py

@@ -72,6 +72,14 @@ class EncodingInsensitiveDict(UserDict[Any, Any]):
         alt = self._alt_key(key)
         return self.data.pop(alt, default)
 
+    def stringify_keys(self) -> dict[str, Any]:
+        d = {}
+        for key, value in self.items():
+            d[key.decode(self._encoding) if isinstance(key, bytes) else key] = (
+                value.stringify_keys() if isinstance(value, EncodingInsensitiveDict) else value
+            )
+        return d
+
 
 @enum.unique
 class CaseAndEncodingInsensitiveEnum(bytes, enum.Enum):
@@ -120,10 +128,6 @@ def b(x: ResponseType, encoding: str | None = None) -> bytes:
     return _v.encode(encoding) if encoding else _v.encode()
 
 
-def defaultvalue(value: U | None, default: T) -> U | T:
-    return default if value is None else value
-
-
 def nativestr(x: ResponseType, encoding: str = "utf-8") -> str:
     if isinstance(x, (str, bytes)):
         return x if isinstance(x, str) else x.decode(encoding, "replace")

{coredis-5.0.0rc2 → coredis-5.0.1}/coredis/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-07-10T16:37:52-0700",
+ "date": "2025-07-18T09:26:51-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "500ec3f7c2c644928da3459bf3242872e672728c",
- "version": "5.0.0rc2"
+ "full-revisionid": "dbec024933c248c144549a88927631eb9294a9a2",
+ "version": "5.0.1"
 }
 '''  # END VERSION_JSON
 

{coredis-5.0.0rc2 → coredis-5.0.1}/coredis/commands/core.py

@@ -7,7 +7,7 @@ from typing import overload
 from deprecated.sphinx import versionadded
 
 from coredis._json import json
-from coredis._utils import defaultvalue, dict_to_flat_list, tuples_to_flat_list
+from coredis._utils import dict_to_flat_list, tuples_to_flat_list
 from coredis.commands import CommandMixin
 from coredis.commands._utils import (
     normalized_milliseconds,
@@ -5269,8 +5269,8 @@ class CoreCommands(CommandMixin[AnyStr]):
         """
 
         command_arguments: CommandArgList = [
-            defaultvalue(start, "-"),
-            defaultvalue(end, "+"),
+            start if start is not None else "-",
+            end if end is not None else "+",
         ]
 
         if count is not None:
@@ -5298,8 +5298,8 @@ class CoreCommands(CommandMixin[AnyStr]):
         IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE
         """
         command_arguments: CommandArgList = [
-            defaultvalue(end, "+"),
-            defaultvalue(start, "-"),
+            end if end is not None else "+",
+            start if start is not None else "-",
         ]
 
         if count is not None:
@@ -8110,6 +8110,37 @@ class CoreCommands(CommandMixin[AnyStr]):
         filter_ef: int | None = ...,
         truth: bool | None = ...,
     ) -> CommandRequest[dict[AnyStr, float]]: ...
+    @overload
+    def vsim(
+        self,
+        key: KeyT,
+        *,
+        element: StringT | None = ...,
+        values: Parameters[float] | bytes | None = ...,
+        withattribs: Literal[True],
+        count: int | None = ...,
+        epsilon: float | None = ...,
+        ef: int | None = ...,
+        filter: StringT | None = ...,
+        filter_ef: int | None = ...,
+        truth: bool | None = ...,
+    ) -> CommandRequest[dict[AnyStr, JsonType]]: ...
+    @overload
+    def vsim(
+        self,
+        key: KeyT,
+        *,
+        element: StringT | None = ...,
+        values: Parameters[float] | bytes | None = ...,
+        withscores: Literal[True],
+        withattribs: Literal[True],
+        count: int | None = ...,
+        epsilon: float | None = ...,
+        ef: int | None = ...,
+        filter: StringT | None = ...,
+        filter_ef: int | None = ...,
+        truth: bool | None = ...,
+    ) -> CommandRequest[dict[AnyStr, tuple[float, JsonType]]]: ...
 
     @versionadded(version="5.0.0")
     @mutually_exclusive_parameters("values", "element", required=True)
@@ -8117,6 +8148,7 @@ class CoreCommands(CommandMixin[AnyStr]):
         CommandName.VSIM,
         version_introduced="8.0.0",
         group=CommandGroup.VECTOR_SET,
+        arguments={"withattribs": {"version_introduced": "8.1.240"}},
     )
     def vsim(
         self,
@@ -8125,13 +8157,19 @@ class CoreCommands(CommandMixin[AnyStr]):
         element: StringT | None = None,
         values: Parameters[float] | bytes | None = None,
         withscores: bool | None = None,
+        withattribs: bool | None = None,
         count: int | None = None,
         epsilon: float | None = None,
         ef: int | None = None,
         filter: StringT | None = None,
         filter_ef: int | None = None,
         truth: bool | None = None,
-    ) -> CommandRequest[tuple[AnyStr, ...] | dict[AnyStr, float]]:
+    ) -> CommandRequest[
+        tuple[AnyStr, ...]
+        | dict[AnyStr, float]
+        | dict[AnyStr, JsonType]
+        | dict[AnyStr, tuple[float, JsonType]]
+    ]:
         """
         Return elements similar to a given vector or element
 
@@ -8140,6 +8178,7 @@ class CoreCommands(CommandMixin[AnyStr]):
         :param values: either a byte representation of a 32-bit floating point (FP32) blob of values
          or a sequence of doubles representing the vector to use as the similarity reference.
         :param withscores: whether to return similarity scores for each result
+        :param withattribs: whether to include attributes for for each result
         :param count: number of results to limit to
         :param epsilon: distance threshold; results with distance greater than this are
          excluded.
@@ -8148,7 +8187,8 @@ class CoreCommands(CommandMixin[AnyStr]):
         :param filter_ef: limits the number of filtering attempts
         :param truth: forces an exact linear scan of all elements bypassing the HSNW graph
         :return: the matching elements or a mapping of the matching elements to their scores
-         if :paramref:`withscores` is ``True``
+         if :paramref:`withscores` is ``True`` and/or their attributes if :paramref:`withattribs`
+         is ``True``
         """
         command_arguments: CommandArgList = [key]
         if values is not None:
@@ -8162,6 +8202,8 @@ class CoreCommands(CommandMixin[AnyStr]):
 
         if withscores:
             command_arguments.append(PureToken.WITHSCORES)
+        if withattribs:
+            command_arguments.append(PureToken.WITHATTRIBS)
         if count is not None:
             command_arguments.extend([PrefixToken.COUNT, count])
         if ef is not None:
@@ -8177,7 +8219,7 @@ class CoreCommands(CommandMixin[AnyStr]):
         return self.create_request(
             CommandName.VSIM,
             *command_arguments,
-            callback=VSimCallback[AnyStr](withscores=withscores),
+            callback=VSimCallback[AnyStr](withscores=withscores, withattribs=withattribs),
         )
 
     @versionadded(version="5.0.0")

{coredis-5.0.0rc2 → coredis-5.0.1}/coredis/commands/script.py

@@ -8,9 +8,7 @@ from typing import TYPE_CHECKING, Any, cast
 
 from deprecated.sphinx import versionadded
 
-from coredis._protocols import SupportsScript
 from coredis._utils import b
-from coredis.commands import CommandRequest
 from coredis.exceptions import NoScriptError
 from coredis.retry import ConstantRetryPolicy, retryable
 from coredis.typing import (
@@ -25,6 +23,7 @@ from coredis.typing import (
     RedisValueT,
     ResponseType,
     StringT,
+    ValueT,
     add_runtime_checks,
     safe_beartype,
 )
@@ -53,7 +52,7 @@ class Script(Generic[AnyStr]):
 
     def __init__(
         self,
-        registered_client: SupportsScript[AnyStr] | None = None,
+        registered_client: coredis.client.Client[AnyStr] | None = None,
         script: StringT | None = None,
         readonly: bool = False,
     ):
@@ -66,7 +65,7 @@ class Script(Generic[AnyStr]):
         :param readonly: If ``True`` the script will be called with
          :meth:`coredis.Redis.evalsha_ro` instead of :meth:`coredis.Redis.evalsha`
         """
-        self.registered_client: SupportsScript[AnyStr] | None = registered_client
+        self.registered_client: coredis.client.Client[AnyStr] | None = registered_client
         self.script: StringT
         if not script:
             raise RuntimeError("No script provided")
@@ -77,10 +76,10 @@ class Script(Generic[AnyStr]):
     def __call__(
         self,
         keys: Parameters[KeyT] | None = None,
-        args: Parameters[RedisValueT] | None = None,
-        client: SupportsScript[AnyStr] | None = None,
+        args: Parameters[ValueT] | None = None,
+        client: coredis.client.Client[AnyStr] | None = None,
         readonly: bool | None = None,
-    ) -> CommandRequest[ResponseType]:
+    ) -> Awaitable[ResponseType]:
         """
         Executes the script registered in :paramref:`Script.script` using
         :meth:`coredis.Redis.evalsha`. Additionally, if the script was not yet
@@ -113,19 +112,16 @@ class Script(Generic[AnyStr]):
             cast(Pipeline[AnyStr], client).scripts.add(self)
             return method(self.sha, keys=keys, args=args)
         else:
-            return cast(
-                CommandRequest[ResponseType],
-                retryable(
-                    ConstantRetryPolicy((NoScriptError,), 1, 0),
-                    failure_hook=lambda _: client.script_load(self.script),
-                )(method)(self.sha, keys=keys, args=args),
-            )
+            return retryable(
+                ConstantRetryPolicy((NoScriptError,), 1, 0),
+                failure_hook=lambda _: client.script_load(self.script),
+            )(method)(self.sha, keys=keys, args=args)
 
     async def execute(
         self,
         keys: Parameters[KeyT] | None = None,
-        args: Parameters[RedisValueT] | None = None,
-        client: SupportsScript[AnyStr] | None = None,
+        args: Parameters[ValueT] | None = None,
+        client: coredis.client.Client[AnyStr] | None = None,
         readonly: bool | None = None,
     ) -> ResponseType:
         """

{coredis-5.0.0rc2 → coredis-5.0.1}/coredis/commands/sentinel.py

@@ -16,7 +16,7 @@ from coredis.response._callbacks.sentinel import (
 from coredis.typing import (
     AnyStr,
     RedisValueT,
-    ResponseType,
+    ResponsePrimitive,
     StringT,
 )
 
@@ -105,7 +105,7 @@ class SentinelCommands(CommandMixin[AnyStr]):
     @redis_command(CommandName.SENTINEL_INFO_CACHE)
     def sentinel_infocache(
         self, *nodenames: StringT
-    ) -> CommandRequest[dict[AnyStr, dict[int, dict[str, ResponseType]]]]:
+    ) -> CommandRequest[dict[AnyStr, dict[int, dict[str, ResponsePrimitive]]]]:
         """
         Return cached INFO output from masters and replicas.
         """
@@ -119,7 +119,9 @@ class SentinelCommands(CommandMixin[AnyStr]):
     @redis_command(
         CommandName.SENTINEL_MASTER,
     )
-    def sentinel_master(self, service_name: StringT) -> CommandRequest[dict[str, int | bool | str]]:
+    def sentinel_master(
+        self, service_name: StringT
+    ) -> CommandRequest[dict[str, ResponsePrimitive]]:
         """Returns a dictionary containing the specified masters state."""
 
         return CommandRequest(
@@ -129,7 +131,7 @@ class SentinelCommands(CommandMixin[AnyStr]):
     @redis_command(
         CommandName.SENTINEL_MASTERS,
     )
-    def sentinel_masters(self) -> CommandRequest[dict[str, dict[str, int | bool | str]]]:
+    def sentinel_masters(self) -> CommandRequest[dict[str, dict[str, ResponsePrimitive]]]:
         """Returns a list of dictionaries containing each master's state."""
 
         return CommandRequest(self, CommandName.SENTINEL_MASTERS, callback=PrimariesCallback())
@@ -173,7 +175,7 @@ class SentinelCommands(CommandMixin[AnyStr]):
     )
     def sentinel_sentinels(
         self, service_name: StringT
-    ) -> CommandRequest[tuple[dict[str, int | bool | str], ...]]:
+    ) -> CommandRequest[tuple[dict[str, ResponsePrimitive], ...]]:
         """Returns a list of sentinels for :paramref:`service_name`"""
 
         return CommandRequest(
@@ -205,7 +207,7 @@ class SentinelCommands(CommandMixin[AnyStr]):
     )
     def sentinel_slaves(
         self, service_name: StringT
-    ) -> CommandRequest[tuple[dict[str, int | bool | str], ...]]:
+    ) -> CommandRequest[tuple[dict[str, ResponsePrimitive], ...]]:
         """Returns a list of slaves for paramref:`service_name`"""
 
         return CommandRequest(
@@ -217,7 +219,7 @@ class SentinelCommands(CommandMixin[AnyStr]):
     )
     def sentinel_replicas(
         self, service_name: StringT
-    ) -> CommandRequest[tuple[dict[str, int | bool | str], ...]]:
+    ) -> CommandRequest[tuple[dict[str, ResponsePrimitive], ...]]:
         """Returns a list of replicas for :paramref:`service_name`"""
 
         return CommandRequest(

{coredis-5.0.0rc2 → coredis-5.0.1}/coredis/pipeline.py

@@ -89,8 +89,6 @@ def wrap_pipeline_method(
     def wrapper(*args: P.args, **kwargs: P.kwargs) -> Awaitable[R]:
         return func(*args, **kwargs)
 
-    wrapper.__annotations__ = wrapper.__annotations__.copy()
-    wrapper.__annotations__["return"] = kls
     wrapper.__doc__ = textwrap.dedent(wrapper.__doc__ or "")
     wrapper.__doc__ = f"""
 .. note:: Pipeline variant of :meth:`coredis.Redis.{func.__name__}` that does not execute
@@ -165,13 +163,12 @@ class PipelineCommandRequest(CommandRequest[CommandResponseT]):
         if hasattr(self, "response"):
             return self.response.__await__()
         elif self.parent:
-            parent = self.parent
 
             async def _transformed() -> CommandResponseT:
-                if hasattr(parent, "response"):
-                    return self.callback(await parent.response)
+                if (r := await self.parent) == self.client:  # type: ignore
+                    return r  # type: ignore
                 else:
-                    return await parent  # type: ignore[no-any-return]
+                    return self.callback(r)
 
             return _transformed().__await__()
         else:
@@ -541,6 +538,8 @@ class Pipeline(Client[AnyStr], metaclass=PipelineMeta):
     ) -> None:
         """
         Queue a command for execution on the next `execute()` call.
+
+        :meta private:
         """
         self.command_stack.append(command)
 

{coredis-5.0.0rc2 → coredis-5.0.1}/coredis/response/_callbacks/sentinel.py

@@ -7,7 +7,6 @@ from coredis.response._callbacks import ResponseCallback
 from coredis.response._callbacks.server import InfoCallback
 from coredis.typing import (
     AnyStr,
-    MutableMapping,
     ResponsePrimitive,
     ResponseType,
 )
@@ -41,9 +40,9 @@ SENTINEL_STATE_INT_FIELDS = {
 
 def sentinel_state_typed(
     response: list[str],
-) -> dict[str, str | int | bool]:
+) -> EncodingInsensitiveDict[str, str | int | bool]:
     it = iter(response)
-    result: dict[str, str | int | bool] = {}
+    result: EncodingInsensitiveDict[str, str | int | bool] = EncodingInsensitiveDict()
 
     for key, value in zip(it, it):
         if key in SENTINEL_STATE_INT_FIELDS:
@@ -54,8 +53,8 @@ def sentinel_state_typed(
 
 
 def add_flags(
-    result: MutableMapping[str, int | str | bool],
-) -> MutableMapping[str, int | str | bool]:
+    result: EncodingInsensitiveDict[str, int | str | bool],
+) -> EncodingInsensitiveDict[str, int | str | bool]:
     flags = set(nativestr(result["flags"]).split(","))
     for name, flag in (
         ("is_master", "master"),
@@ -72,7 +71,7 @@ def add_flags(
 
 def parse_sentinel_state(
     item: list[ResponsePrimitive],
-) -> MutableMapping[str, int | str | bool]:
+) -> EncodingInsensitiveDict[str, int | str | bool]:
     result = sentinel_state_typed([nativestr(k) for k in item])
     result = add_flags(result)
     return result
@@ -82,34 +81,34 @@ class PrimaryCallback(
     ResponseCallback[
         ResponseType,
         dict[ResponsePrimitive, ResponsePrimitive],
-        dict[str, str | int | bool],
+        dict[str, ResponsePrimitive],
     ]
 ):
     def transform(
         self,
         response: ResponseType,
-    ) -> dict[str, str | int | bool]:
-        return dict(parse_sentinel_state(cast(list[ResponsePrimitive], response)))
+    ) -> dict[str, ResponsePrimitive]:
+        return parse_sentinel_state(cast(list[ResponsePrimitive], response)).stringify_keys()
 
     def transform_3(
         self,
         response: dict[ResponsePrimitive, ResponsePrimitive],
-    ) -> dict[str, str | int | bool]:
-        return dict(add_flags(EncodingInsensitiveDict(response)))
+    ) -> dict[str, ResponsePrimitive]:
+        return add_flags(EncodingInsensitiveDict(response)).stringify_keys()
 
 
 class PrimariesCallback(
     ResponseCallback[
         list[ResponseType],
         list[ResponseType],
-        dict[str, dict[str, str | int | bool]],
+        dict[str, dict[str, ResponsePrimitive]],
     ]
 ):
     def transform(
         self,
         response: list[ResponseType] | dict[ResponsePrimitive, ResponsePrimitive],
-    ) -> dict[str, dict[str, str | int | bool]]:
-        result: dict[str, dict[str, str | int | bool]] = {}
+    ) -> dict[str, dict[str, ResponsePrimitive]]:
+        result: dict[str, dict[str, ResponseType]] = {}
 
         for item in response:
             state = PrimaryCallback()(item)
@@ -120,11 +119,11 @@ class PrimariesCallback(
     def transform_3(
         self,
         response: list[ResponseType],
-    ) -> dict[str, dict[str, str | int | bool]]:
-        states: dict[str, dict[str, str | int | bool]] = {}
+    ) -> dict[str, dict[str, ResponsePrimitive]]:
+        states: dict[str, dict[str, ResponsePrimitive]] = {}
         for state in response:
-            proxy = add_flags(EncodingInsensitiveDict(state))
-            states[nativestr(proxy["name"])] = dict(proxy)
+            state = add_flags(EncodingInsensitiveDict(state)).stringify_keys()
+            states[nativestr(state["name"])] = state
         return states
 
 
@@ -132,20 +131,24 @@ class SentinelsStateCallback(
     ResponseCallback[
         list[ResponseType],
         list[ResponseType],
-        tuple[dict[str, str | bool | int], ...],
+        tuple[dict[str, ResponsePrimitive], ...],
     ]
 ):
     def transform(
         self,
         response: list[ResponseType],
-    ) -> tuple[dict[str, str | bool | int], ...]:
-        return tuple(dict(parse_sentinel_state([nativestr(i) for i in item])) for item in response)
+    ) -> tuple[dict[str, ResponsePrimitive], ...]:
+        return tuple(
+            parse_sentinel_state([nativestr(i) for i in item]).stringify_keys() for item in response
+        )
 
     def transform_3(
         self,
         response: list[ResponseType],
-    ) -> tuple[dict[str, str | bool | int], ...]:
-        return tuple(dict(add_flags(EncodingInsensitiveDict(state))) for state in response)
+    ) -> tuple[dict[str, ResponsePrimitive], ...]:
+        return tuple(
+            add_flags(EncodingInsensitiveDict(state)).stringify_keys() for state in response
+        )
 
 
 class GetPrimaryCallback(
@@ -166,11 +169,11 @@ class SentinelInfoCallback(
     ResponseCallback[
         list[ResponseType],
         list[ResponseType],
-        dict[AnyStr, dict[int, dict[str, ResponseType]]],
+        dict[AnyStr, dict[int, dict[str, ResponsePrimitive]]],
     ]
 ):
     def transform(
         self,
         response: list[ResponseType],
-    ) -> dict[AnyStr, dict[int, dict[str, ResponseType]]]:
+    ) -> dict[AnyStr, dict[int, dict[str, ResponsePrimitive]]]:
         return {response[0]: {r[0]: InfoCallback()(r[1]) for r in response[1]}}

{coredis-5.0.0rc2 → coredis-5.0.1}/coredis/response/_callbacks/vector_sets.py

@@ -1,36 +1,69 @@
 from __future__ import annotations
 
+from coredis._json import json
 from coredis._utils import nativestr
 from coredis.response._callbacks import ResponseCallback
 from coredis.response._utils import flat_pairs_to_dict
 from coredis.response.types import VectorData
-from coredis.typing import AnyStr, ResponsePrimitive, StringT
+from coredis.typing import AnyStr, JsonType, ResponsePrimitive, StringT
 
 
 class VSimCallback(
     ResponseCallback[
         list[AnyStr],
-        list[AnyStr] | dict[AnyStr, float],
-        tuple[AnyStr, ...] | dict[AnyStr, float],
+        list[AnyStr] | dict[AnyStr, float | list[float | JsonType]],
+        tuple[AnyStr, ...]
+        | dict[AnyStr, float]
+        | dict[AnyStr, JsonType]
+        | dict[AnyStr, tuple[float, JsonType]],
     ],
 ):
     def transform(
         self,
         response: list[AnyStr],
-    ) -> tuple[AnyStr, ...] | dict[AnyStr, float]:
-        if self.options.get("withscores"):
+    ) -> (
+        tuple[AnyStr, ...]
+        | dict[AnyStr, float]
+        | dict[AnyStr, JsonType]
+        | dict[AnyStr, tuple[float, JsonType]]
+    ):
+        withscores, withattribs = self.options.get("withscores"), self.options.get("withattribs")
+        if withscores or withattribs:
             it = iter(response)
-            return dict(list(zip(it, map(float, it))))
+            match withscores, withattribs:
+                case True, None | False:
+                    return dict(list(zip(it, map(float, it))))
+                case None | False, True:
+                    return dict(list(zip(it, map(json.loads, it))))
+                case True, True:
+                    return dict(
+                        list(zip(it, map(lambda x: (float(x[0]), json.loads(x[1])), zip(it, it))))
+                    )
         else:
-            return tuple(response)
+            return self.transform_3(response)
 
     def transform_3(
         self,
-        response: list[AnyStr] | dict[AnyStr, float],
-    ) -> tuple[AnyStr, ...] | dict[AnyStr, float]:
-        if self.options.get("withscores"):
+        response: list[AnyStr]
+        | dict[AnyStr, float]
+        | dict[AnyStr, AnyStr]
+        | dict[AnyStr, list[float | AnyStr]],
+    ) -> (
+        tuple[AnyStr, ...]
+        | dict[AnyStr, float]
+        | dict[AnyStr, JsonType]
+        | dict[AnyStr, tuple[float, JsonType]]
+    ):
+        withscores, withattribs = self.options.get("withscores"), self.options.get("withattribs")
+        if withscores or withattribs:
             assert isinstance(response, dict)
-            return response
+            match withscores, withattribs:
+                case None | False, True:
+                    return {k: json.loads(v) for k, v in response.items()}
+                case True, True:
+                    return {k: (v[0], json.loads(v[1])) for k, v in response.items()}
+                case _:
+                    return response
         else:
             return tuple(response)
 

{coredis-5.0.0rc2 → coredis-5.0.1}/coredis/sentinel.py

@@ -23,7 +23,9 @@ from coredis.typing import (
     Generic,
     Iterable,
     Literal,
+    ResponsePrimitive,
     StringT,
+    TypeAdapter,
 )
 
 
@@ -195,6 +197,7 @@ class Sentinel(Generic[AnyStr]):
         sentinel_kwargs: dict[str, Any] | None = ...,
         decode_responses: Literal[False] = ...,
         cache: AbstractCache | None = None,
+        type_adapter: TypeAdapter | None = ...,
         **connection_kwargs: Any,
     ) -> None: ...
 
@@ -206,6 +209,7 @@ class Sentinel(Generic[AnyStr]):
         sentinel_kwargs: dict[str, Any] | None = ...,
         decode_responses: Literal[True] = ...,
         cache: AbstractCache | None = None,
+        type_adapter: TypeAdapter | None = None,
         **connection_kwargs: Any,
     ) -> None: ...
 
@@ -216,6 +220,7 @@ class Sentinel(Generic[AnyStr]):
         sentinel_kwargs: dict[str, Any] | None = None,
         decode_responses: bool = False,
         cache: AbstractCache | None = None,
+        type_adapter: TypeAdapter | None = None,
         **connection_kwargs: Any,
     ) -> None:
         """
@@ -236,6 +241,9 @@ class Sentinel(Generic[AnyStr]):
          and ``protocol_version`` options specified in :paramref:`connection_kwargs` will be used.
         :param cache: If provided the cache will be shared between both primaries and replicas
          returned by this sentinel.
+        :param type_adapter: The adapter to use for serializing / deserializing customs types
+         when interacting with redis commands. If provided this adapter will be used for both
+         primaries and replicas returned by this sentinel.
         :param connection_kwargs: are keyword arguments that will be used when
          establishing a connection to a Redis server (i.e. are passed on to the
          constructor of :class:`Redis` for all primary and replicas).
@@ -260,6 +268,7 @@ class Sentinel(Generic[AnyStr]):
         self.min_other_sentinels = min_other_sentinels
         self.connection_kwargs = connection_kwargs
         self.__cache = cache
+        self.__type_adapter = type_adapter
         self.connection_kwargs["decode_responses"] = self.sentinel_kwargs["decode_responses"] = (
             decode_responses
         )
@@ -283,18 +292,18 @@ class Sentinel(Generic[AnyStr]):
 
     def __check_primary_state(
         self,
-        state: dict[str, int | bool | str],
+        state: dict[str, ResponsePrimitive],
     ) -> bool:
         if not state["is_master"] or state["is_sdown"] or state["is_odown"]:
             return False
 
-        if int(state["num-other-sentinels"]) < self.min_other_sentinels:
+        if int(state["num-other-sentinels"] or 0) < self.min_other_sentinels:
             return False
 
         return True
 
     def __filter_replicas(
-        self, replicas: Iterable[dict[str, str | int | bool]]
+        self, replicas: Iterable[dict[str, ResponsePrimitive]]
     ) -> list[tuple[str, int]]:
         """Removes replicas that are in an ODOWN or SDOWN state"""
         replicas_alive: list[tuple[str, int]] = []
@@ -302,7 +311,9 @@ class Sentinel(Generic[AnyStr]):
         for replica in replicas:
             if replica["is_odown"] or replica["is_sdown"]:
                 continue
-            replicas_alive.append((nativestr(replica["ip"]), int(replica["port"])))
+            ip, port = replica["ip"], replica["port"]
+            assert ip and port
+            replicas_alive.append((nativestr(ip), int(port)))
 
         return replicas_alive
 
@@ -329,7 +340,7 @@ class Sentinel(Generic[AnyStr]):
                     self.sentinels[0],
                 )
 
-                return nativestr(state["ip"]), int(state["port"])
+                return nativestr(state["ip"]), int(state["port"] or -1)
         raise PrimaryNotFoundError(f"No primary found for {service_name!r}")
 
     async def discover_replicas(self, service_name: str) -> list[tuple[str, int]]:
@@ -406,6 +417,7 @@ class Sentinel(Generic[AnyStr]):
                 **connection_kwargs,
             ),
             cache=self.__cache,
+            type_adapter=self.__type_adapter,
         )
 
     @overload
@@ -461,4 +473,5 @@ class Sentinel(Generic[AnyStr]):
                 **connection_kwargs,
             ),
             cache=self.__cache,
+            type_adapter=self.__type_adapter,
         )

{coredis-5.0.0rc2 → coredis-5.0.1}/coredis/tokens.py

@@ -771,6 +771,11 @@ class PureToken(CaseAndEncodingInsensitiveEnum):
     #:  - ``VSIM``
     TRUTH = b"TRUTH"
 
+    #: Used by:
+    #:
+    #:  - ``VSIM``
+    WITHATTRIBS = b"WITHATTRIBS"
+
     #: Used by:
     #:
     #:  - ``VEMB``

{coredis-5.0.0rc2 → coredis-5.0.1/coredis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coredis
-Version: 5.0.0rc2
+Version: 5.0.1
 Summary: Python async client for Redis key-value store
 Home-page: https://github.com/alisaifee/coredis
 Author: Ali-Akber Saifee
@@ -14,7 +14,6 @@ Project-URL: Documentation, https://coredis.readthedocs.org
 Keywords: Redis,key-value store,asyncio
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3.10

{coredis-5.0.0rc2 → coredis-5.0.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [build-system]
 build-backend = "setuptools.build_meta"
 requires = [
-  "mypy==1.16.1",
+  "mypy==1.17.0",
   "packaging>=21,<26",
   "beartype>=0.20",
   "pympler>1,<2",

{coredis-5.0.0rc2 → coredis-5.0.1}/requirements/dev.txt

@@ -2,7 +2,7 @@
 -r publishing.txt
 -r recipes.txt
 ruff
-mypy==1.16.1; implementation_name!='pypy'
+mypy==1.17.0; implementation_name!='pypy'
 redis>=4.2.0
 twine
 types-deprecated

{coredis-5.0.0rc2 → coredis-5.0.1}/setup.py

@@ -147,7 +147,6 @@ setup(
     classifiers=[
         "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Developers",
-        "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
         "Programming Language :: Python",
         "Programming Language :: Python :: 3.10",