coredis 5.0.0rc2__tar.gz → 5.1.0__tar.gz

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

@@ -3,6 +3,50 @@
 Changelog
 =========
 
+v5.1.0
+------
+Release Date: 2025-09-10
+
+* Bug Fix
+
+  * Ensure ``ssl_context`` passed in kwargs of ``from_url`` factory
+    method is respected.
+
+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
@@ -1966,9 +2010,3 @@ v1.0.1
 * add more examples
 * change `Script.register` to `Script.execute`
 
-
-
-
-
-
-

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coredis
-Version: 5.0.0rc2
+Version: 5.1.0
 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.1.0}/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.1.0}/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.1.0}/coredis/_version.py

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

{coredis-5.0.0rc2 → coredis-5.1.0}/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.1.0}/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.1.0}/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.1.0}/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.1.0}/coredis/pool/basic.py

@@ -155,17 +155,20 @@ class ConnectionPool:
                     pass
 
             if parsed_url.scheme == "rediss":
-                keyfile = cast(str | None, url_options.pop("ssl_keyfile", None))
-                certfile = cast(str | None, url_options.pop("ssl_certfile", None))
-                check_hostname = query_param_to_bool(url_options.pop("ssl_check_hostname", None))
-                cert_reqs = cast(
-                    str | VerifyMode | None,
-                    url_options.pop("ssl_cert_reqs", None),
-                )
-                ca_certs = cast(str | None, url_options.pop("ssl_ca_certs", None))
-                url_options["ssl_context"] = RedisSSLContext(
-                    keyfile, certfile, cert_reqs, ca_certs, check_hostname
-                ).get()
+                if "ssl_context" not in kwargs:
+                    keyfile = cast(str | None, url_options.pop("ssl_keyfile", None))
+                    certfile = cast(str | None, url_options.pop("ssl_certfile", None))
+                    check_hostname = query_param_to_bool(
+                        url_options.pop("ssl_check_hostname", None)
+                    )
+                    cert_reqs = cast(
+                        str | VerifyMode | None,
+                        url_options.pop("ssl_cert_reqs", None),
+                    )
+                    ca_certs = cast(str | None, url_options.pop("ssl_ca_certs", None))
+                    url_options["ssl_context"] = RedisSSLContext(
+                        keyfile, certfile, cert_reqs, ca_certs, check_hostname
+                    ).get()
 
         # last shot at the db value
         _db = url_options.get("db", db or 0)

{coredis-5.0.0rc2 → coredis-5.1.0}/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]}}