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

coredis/response/_callbacks/sorted_set.py

@@ -9,7 +9,6 @@ from coredis.typing import (
     Generic,
     ResponsePrimitive,
     ResponseType,
-    ValueT,
 )
 
 
@@ -23,9 +22,8 @@ class ZRankCallback(
     def transform(
         self,
         response: int | list[ResponsePrimitive] | None,
-        **options: ValueT | None,
     ) -> int | tuple[int, float] | None:
-        if options.get("withscore"):
+        if self.options.get("withscore"):
             return (response[0], float(response[1])) if response else None
         else:
             return cast(int | None, response)
@@ -33,9 +31,8 @@ class ZRankCallback(
     def transform_3(
         self,
         response: int | list[ResponsePrimitive] | None,
-        **options: ValueT | None,
     ) -> int | tuple[int, float] | None:
-        if options.get("withscore"):
+        if self.options.get("withscore"):
             return (response[0], response[1]) if response else None
         else:
             return cast(int | None, response)
@@ -51,11 +48,10 @@ class ZMembersOrScoredMembers(
     def transform(
         self,
         response: list[AnyStr | list[ResponsePrimitive]],
-        **options: ValueT | None,
     ) -> tuple[AnyStr | ScoredMember, ...]:
         if not response:
             return ()
-        elif options.get("withscores"):
+        elif self.options.get("withscores"):
             it = iter(cast(list[AnyStr], response))
             return tuple(ScoredMember(*v) for v in zip(it, map(float, it)))
         else:
@@ -64,9 +60,8 @@ class ZMembersOrScoredMembers(
     def transform_3(
         self,
         response: list[AnyStr | list[ResponsePrimitive]],
-        **options: ValueT | None,
     ) -> tuple[AnyStr | ScoredMember, ...]:
-        if options.get("withscores"):
+        if self.options.get("withscores"):
             return tuple(ScoredMember(*v) for v in cast(list[tuple[AnyStr, float]], response))
         else:
             return cast(tuple[AnyStr, ...], tuple(response))
@@ -81,12 +76,13 @@ class ZSetScorePairCallback(
     Generic[AnyStr],
 ):
     def transform(
-        self, response: list[ResponsePrimitive] | None, **options: ValueT | None
+        self,
+        response: list[ResponsePrimitive] | None,
     ) -> ScoredMember | ScoredMembers | None:
         if not response:
             return None
 
-        if not (options.get("withscores") or options.get("count")):
+        if not (self.options.get("withscores") or self.options.get("count")):
             return ScoredMember(cast(AnyStr, response[0]), float(cast(SupportsFloat, response[1])))
 
         it = iter(response)
@@ -95,12 +91,11 @@ class ZSetScorePairCallback(
     def transform_3(
         self,
         response: list[ResponsePrimitive | list[ResponsePrimitive]] | None,
-        **options: ValueT | None,
     ) -> ScoredMember | ScoredMembers | None:
         if not response:
             return None
 
-        if not (options.get("withscores") or options.get("count")):
+        if not (self.options.get("withscores") or self.options.get("count")):
             return ScoredMember(*cast(tuple[AnyStr, float], response))
 
         return tuple(ScoredMember(*v) for v in cast(list[tuple[AnyStr, float]], response))
@@ -115,7 +110,8 @@ class ZMPopCallback(
     Generic[AnyStr],
 ):
     def transform(
-        self, response: list[ResponseType] | None, **options: ValueT | None
+        self,
+        response: list[ResponseType] | None,
     ) -> tuple[AnyStr, ScoredMembers] | None:
         r = cast(tuple[AnyStr, list[tuple[AnyStr, int]]], response)
         if r:
@@ -128,7 +124,8 @@ class ZMScoreCallback(
     ResponseCallback[list[ResponsePrimitive], list[ResponsePrimitive], tuple[float | None, ...]]
 ):
     def transform(
-        self, response: list[ResponsePrimitive], **options: ValueT | None
+        self,
+        response: list[ResponsePrimitive],
     ) -> tuple[float | None, ...]:
         return tuple(score if score is None else float(score) for score in response)
 
@@ -138,7 +135,8 @@ class ZScanCallback(
     Generic[AnyStr],
 ):
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> tuple[int, ScoredMembers]:
         cursor, r = cast(tuple[int, list[AnyStr]], response)
         it = iter(r)
@@ -157,9 +155,8 @@ class ZRandMemberCallback(
     def transform(
         self,
         response: AnyStr | list[ResponsePrimitive] | None,
-        **options: ValueT | None,
     ) -> AnyStr | tuple[AnyStr, ...] | ScoredMembers | None:
-        if not (response and options.get("withscores")):
+        if not (response and self.options.get("withscores")):
             return tuple(response) if isinstance(response, list) else response
 
         it = iter(response)
@@ -168,9 +165,8 @@ class ZRandMemberCallback(
     def transform_3(
         self,
         response: AnyStr | list[list[ResponsePrimitive]] | list[ResponsePrimitive] | None,
-        **options: ValueT | None,
     ) -> AnyStr | tuple[AnyStr, ...] | ScoredMembers | None:
-        if not (response and options.get("withscores")):
+        if not (response and self.options.get("withscores")):
             return tuple(response) if isinstance(response, list) else response
 
         return tuple(ScoredMember(*v) for v in response)
@@ -184,7 +180,8 @@ class BZPopCallback(
     ]
 ):
     def transform(
-        self, response: list[ResponsePrimitive] | None, **options: ValueT | None
+        self,
+        response: list[ResponsePrimitive] | None,
     ) -> tuple[AnyStr, AnyStr, float] | None:
         if response:
             return response[0], response[1], float(response[2])
@@ -192,10 +189,16 @@ class BZPopCallback(
 
 
 class ZAddCallback(ResponseCallback[ResponsePrimitive, int | float, int | float]):
-    def transform(self, response: ResponsePrimitive, **options: ValueT | None) -> int | float:
-        if options.get("condition"):
+    def transform(
+        self,
+        response: ResponsePrimitive,
+    ) -> int | float:
+        if self.options.get("condition"):
             return float(response)
         return int(response)
 
-    def transform_3(self, response: int | float, **options: ValueT | None) -> int | float:
+    def transform_3(
+        self,
+        response: int | float,
+    ) -> int | float:
         return response

coredis/response/_callbacks/streams.py

@@ -16,13 +16,13 @@ from coredis.typing import (
     OrderedDict,
     ResponseType,
     StringT,
-    ValueT,
 )
 
 
 class StreamRangeCallback(ResponseCallback[ResponseType, ResponseType, tuple[StreamEntry, ...]]):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> tuple[StreamEntry, ...]:
         return tuple(StreamEntry(r[0], flat_pairs_to_ordered_dict(r[1])) for r in response)
 
@@ -31,9 +31,10 @@ class ClaimCallback(
     ResponseCallback[ResponseType, ResponseType, tuple[AnyStr, ...] | tuple[StreamEntry, ...]]
 ):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> tuple[AnyStr, ...] | tuple[StreamEntry, ...]:
-        if options.get("justid") is not None:
+        if self.options.get("justid") is not None:
             return tuple(response)
         else:
             return StreamRangeCallback()(response)
@@ -48,12 +49,13 @@ class AutoClaimCallback(
     ]
 ):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> (
         tuple[AnyStr, tuple[AnyStr, ...]]
         | tuple[AnyStr, tuple[StreamEntry, ...], tuple[AnyStr, ...]]
     ):
-        if options.get("justid") is not None:
+        if self.options.get("justid") is not None:
             return response[0], tuple(response[1])
         else:
             return (
@@ -67,7 +69,8 @@ class MultiStreamRangeCallback(
     ResponseCallback[ResponseType, ResponseType, dict[AnyStr, tuple[StreamEntry, ...]] | None]
 ):
     def transform_3(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> dict[AnyStr, tuple[StreamEntry, ...]] | None:
         if response:
             mapping: dict[AnyStr, tuple[StreamEntry, ...]] = {}
@@ -81,7 +84,8 @@ class MultiStreamRangeCallback(
         return None
 
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> dict[AnyStr, tuple[StreamEntry, ...]] | None:
         if response:
             mapping: dict[AnyStr, tuple[StreamEntry, ...]] = {}
@@ -99,9 +103,10 @@ class PendingCallback(
     ResponseCallback[ResponseType, ResponseType, StreamPending | tuple[StreamPendingExt, ...]]
 ):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> StreamPending | tuple[StreamPendingExt, ...]:
-        if not options.get("count"):
+        if not self.options.get("count"):
             return StreamPending(
                 response[0],
                 response[1],
@@ -114,15 +119,19 @@ class PendingCallback(
 
 class XInfoCallback(ResponseCallback[ResponseType, ResponseType, tuple[dict[AnyStr, AnyStr], ...]]):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> tuple[dict[AnyStr, AnyStr], ...]:
         return tuple(flat_pairs_to_dict(row) for row in response)
 
 
 class StreamInfoCallback(ResponseCallback[ResponseType, ResponseType, StreamInfo]):
-    def transform(self, response: ResponseType, **options: ValueT | None) -> StreamInfo:
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> StreamInfo:
         res: dict[StringT, Any] = EncodingInsensitiveDict(flat_pairs_to_dict(response))
-        if not options.get("full"):
+        if not self.options.get("full"):
             k1 = "first-entry"
             kn = "last-entry"
             e1: StreamEntry | None = None

coredis/response/_callbacks/strings.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Any
+
 from coredis._utils import EncodingInsensitiveDict
 from coredis.response._callbacks import ResponseCallback, SimpleStringCallback
 from coredis.response.types import LCSMatch, LCSResult
@@ -7,13 +9,12 @@ from coredis.typing import (
     AnyStr,
     ResponsePrimitive,
     ResponseType,
-    ValueT,
 )
 
 
 class StringSetCallback(ResponseCallback[AnyStr | None, AnyStr | None, AnyStr | bool | None]):
-    def transform(self, response: AnyStr | None, **options: ValueT | None) -> AnyStr | bool | None:
-        if options.get("get"):
+    def transform(self, response: AnyStr | None, **options: Any) -> AnyStr | bool | None:
+        if self.options.get("get"):
             return response
         else:
             return SimpleStringCallback()(response)
@@ -23,13 +24,13 @@ class LCSCallback(
     ResponseCallback[
         list[ResponseType],
         dict[ResponsePrimitive, ResponseType],
-        AnyStr | int | LCSResult,
+        LCSResult,
     ]
 ):
     def transform(
         self,
         response: (list[ResponseType] | dict[ResponsePrimitive, ResponseType]),
-        **options: ValueT | None,
+        **options: Any,
     ) -> LCSResult:
         assert (
             isinstance(response, list)
@@ -52,7 +53,7 @@ class LCSCallback(
     def transform_3(
         self,
         response: dict[ResponsePrimitive, ResponseType],
-        **options: ValueT | None,
+        **options: Any,
     ) -> LCSResult:
         proxy = EncodingInsensitiveDict(response)
 

coredis/response/_callbacks/vector_sets.py

@@ -0,0 +1,159 @@
+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, JsonType, ResponsePrimitive, StringT
+
+
+class VSimCallback(
+    ResponseCallback[
+        list[AnyStr],
+        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]
+        | 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)
+            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 self.transform_3(response)
+
+    def transform_3(
+        self,
+        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)
+            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)
+
+
+class VLinksCallback(
+    ResponseCallback[
+        list[list[AnyStr]] | None,
+        list[list[AnyStr] | dict[AnyStr, float]] | None,
+        tuple[tuple[AnyStr, ...] | dict[AnyStr, float], ...] | None,
+    ],
+):
+    def transform(
+        self,
+        response: list[list[AnyStr]] | None,
+    ) -> tuple[tuple[AnyStr, ...] | dict[AnyStr, float], ...] | None:
+        if response:
+            if self.options.get("withscores"):
+                return tuple(dict(zip(it := iter(layer), map(float, it))) for layer in response)
+            else:
+                return tuple(tuple(layer) for layer in response)
+        return None
+
+    def transform_3(
+        self,
+        response: list[list[AnyStr] | dict[AnyStr, float]] | None,
+    ) -> tuple[tuple[AnyStr, ...] | dict[AnyStr, float], ...] | None:
+        if response:
+            if self.options.get("withscores"):
+                assert isinstance(response[0], dict)
+                return tuple(response)
+            else:
+                return tuple(tuple(layer) for layer in response)
+        return None
+
+
+class VEmbCallback(
+    ResponseCallback[
+        list[StringT] | list[ResponsePrimitive],
+        list[float] | list[ResponsePrimitive],
+        tuple[float, ...] | VectorData | None,
+    ]
+):
+    def transform(
+        self,
+        response: list[StringT] | list[ResponsePrimitive] | None,
+    ) -> tuple[float, ...] | VectorData | None:
+        if response:
+            if self.options.get("raw"):
+                return VectorData(
+                    quantization=nativestr(response[0]),
+                    blob=response[1],
+                    l2_norm=float(response[2]),
+                    quantization_range=float(response[3]) if len(response) == 4 else None,
+                )
+            else:
+                return tuple(map(float, response))
+        return None
+
+    def transform_3(
+        self,
+        response: list[float] | list[ResponsePrimitive] | None,
+    ) -> tuple[float, ...] | VectorData | None:
+        if response:
+            if self.options.get("raw"):
+                return VectorData(
+                    quantization=nativestr(response[0]),
+                    blob=response[1],
+                    l2_norm=response[2],
+                    quantization_range=response[3] if len(response) == 4 else None,
+                )
+            else:
+                return tuple(response)
+        return None
+
+
+class VInfoCallback(
+    ResponseCallback[
+        list[AnyStr | int] | None,
+        dict[AnyStr, AnyStr | int] | None,
+        dict[AnyStr, AnyStr | int] | None,
+    ]
+):
+    def transform(
+        self,
+        response: list[AnyStr | int] | None,
+    ) -> dict[AnyStr, AnyStr | int] | None:
+        return flat_pairs_to_dict(response) if response else None
+
+    def transform_3(
+        self,
+        response: dict[AnyStr, AnyStr | int] | None,
+    ) -> dict[AnyStr, AnyStr | int] | None:
+        return response

coredis/response/types.py

@@ -13,9 +13,9 @@ from coredis.typing import (
     Mapping,
     NamedTuple,
     OrderedDict,
+    RedisValueT,
     StringT,
     TypedDict,
-    ValueT,
 )
 
 #: Response from `CLIENT INFO <https://redis.io/commands/client-info>`__
@@ -112,8 +112,6 @@ class LibraryDefinition(TypedDict):
     name: StringT
     #: the engine used by the library
     engine: Literal["LUA"]
-    #: the library's description
-    description: StringT
     #: Mapping of function names to functions in the library
     functions: dict[StringT, FunctionDefinition]
     #: The library's source code
@@ -371,7 +369,7 @@ class ClusterNodeDetail(TypedDict):
     pong_recv: int
     link_state: str
     slots: list[int]
-    migrations: list[dict[str, ValueT]]
+    migrations: list[dict[str, RedisValueT]]
 
 
 class PubSubMessage(TypedDict):
@@ -405,3 +403,14 @@ class PubSubMessage(TypedDict):
     #:   this will be an :class:`int` corresponding to the  number of channels and patterns that the
     #:   connection is currently subscribed to.
     data: int | StringT
+
+
+class VectorData(TypedDict):
+    #: The quantization type as a string (``fp32``, ``bin`` or ``q8``)
+    quantization: str
+    #: Raw bytes representation of the vector
+    blob: bytes
+    #: The L2 norm of the vector before normalization
+    l2_norm: float
+    #: If the vector is quantized as q8, the quantization range
+    quantization_range: float

coredis/retry.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 from functools import wraps
 from typing import Any
 
-from coredis.typing import Callable, Coroutine, P, R
+from coredis.typing import Awaitable, Callable, P, R
 
 logger = logging.getLogger(__name__)
 
@@ -31,10 +31,10 @@ class RetryPolicy(ABC):
 
     async def call_with_retries(
         self,
-        func: Callable[..., Coroutine[Any, Any, R]],
-        before_hook: Callable[..., Coroutine[Any, Any, Any]] | None = None,
-        failure_hook: Callable[..., Coroutine[Any, Any, None]]
-        | dict[type[BaseException], Callable[..., Coroutine[Any, Any, None]]]
+        func: Callable[..., Awaitable[R]],
+        before_hook: Callable[..., Awaitable[Any]] | None = None,
+        failure_hook: Callable[..., Awaitable[Any]]
+        | dict[type[BaseException], Callable[..., Awaitable[None]]]
         | None = None,
     ) -> R:
         """
@@ -159,12 +159,11 @@ class CompositeRetryPolicy(RetryPolicy):
 
     async def call_with_retries(
         self,
-        func: Callable[..., Coroutine[Any, Any, R]],
-        before_hook: Callable[..., Coroutine[Any, Any, Any]] | None = None,
+        func: Callable[..., Awaitable[R]],
+        before_hook: Callable[..., Awaitable[Any]] | None = None,
         failure_hook: None
         | (
-            Callable[..., Coroutine[Any, Any, None]]
-            | dict[type[BaseException], Callable[..., Coroutine[Any, Any, None]]]
+            Callable[..., Awaitable[Any]] | dict[type[BaseException], Callable[..., Awaitable[Any]]]
         ) = None,
     ) -> R:
         """
@@ -214,15 +213,15 @@ class CompositeRetryPolicy(RetryPolicy):
 
 def retryable(
     policy: RetryPolicy,
-    failure_hook: Callable[..., Coroutine[Any, Any, None]] | None = None,
-) -> Callable[[Callable[P, Coroutine[Any, Any, R]]], Callable[P, Coroutine[Any, Any, R]]]:
+    failure_hook: Callable[..., Awaitable[Any]] | None = None,
+) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]:
     """
     Decorator to be used to apply a retry policy to a coroutine
     """
 
     def inner(
-        func: Callable[P, Coroutine[Any, Any, R]],
-    ) -> Callable[P, Coroutine[Any, Any, R]]:
+        func: Callable[P, Awaitable[R]],
+    ) -> Callable[P, Awaitable[R]]:
         @wraps(func)
         async def _inner(*args: P.args, **kwargs: P.kwargs) -> R:
             return await policy.call_with_retries(

coredis/sentinel.py

@@ -24,6 +24,7 @@ from coredis.typing import (
     Iterable,
     Literal,
     StringT,
+    TypeAdapter,
 )
 
 
@@ -46,7 +47,7 @@ class SentinelManagedConnection(Connection, Generic[AnyStr]):
         socket_keepalive_options: dict[int, int | bytes] | None = None,
         *,
         client_name: str | None = None,
-        protocol_version: Literal[2, 3] = 2,
+        protocol_version: Literal[2, 3] = 3,
     ):
         self.connection_pool: SentinelConnectionPool = weakref.proxy(connection_pool)
         super().__init__(
@@ -195,6 +196,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 +208,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 +219,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 +240,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 +267,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
         )
@@ -406,6 +414,7 @@ class Sentinel(Generic[AnyStr]):
                 **connection_kwargs,
             ),
             cache=self.__cache,
+            type_adapter=self.__type_adapter,
         )
 
     @overload
@@ -461,4 +470,5 @@ class Sentinel(Generic[AnyStr]):
                 **connection_kwargs,
             ),
             cache=self.__cache,
+            type_adapter=self.__type_adapter,
         )

coredis/stream.py

@@ -19,6 +19,7 @@ from coredis.typing import (
     Generator,
     Generic,
     KeyT,
+    MutableMapping,
     Parameters,
     StringT,
     TypedDict,
@@ -38,7 +39,7 @@ class State(TypedDict, total=False):
 
 
 class Consumer(Generic[AnyStr]):
-    state: dict[KeyT, State]
+    state: MutableMapping[KeyT, State]
     DEFAULT_START_ID: ClassVar[bytes] = b"0-0"
 
     def __init__(
@@ -71,10 +72,10 @@ class Consumer(Generic[AnyStr]):
         """
         self.client: Client[AnyStr] = client
         self.streams: set[KeyT] = set(streams)
-        self.state: dict[StringT, State] = EncodingInsensitiveDict(
+        self.state: MutableMapping[StringT, State] = EncodingInsensitiveDict(
             {stream: stream_parameters.get(nativestr(stream), {}) for stream in streams}
         )
-        self.buffer: dict[AnyStr, list[StreamEntry]] = EncodingInsensitiveDict({})
+        self.buffer: MutableMapping[AnyStr, list[StreamEntry]] = EncodingInsensitiveDict({})
         self.buffer_size = buffer_size
         self.timeout = timeout
         self._initialized = False