coredis 4.24.0__py3-none-any.whl → 5.0.0rc1__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,126 @@
+from __future__ import annotations
+
+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
+
+
+class VSimCallback(
+    ResponseCallback[
+        list[AnyStr],
+        list[AnyStr] | dict[AnyStr, float],
+        tuple[AnyStr, ...] | dict[AnyStr, float],
+    ],
+):
+    def transform(
+        self,
+        response: list[AnyStr],
+    ) -> tuple[AnyStr, ...] | dict[AnyStr, float]:
+        if self.options.get("withscores"):
+            it = iter(response)
+            return dict(list(zip(it, map(float, it))))
+        else:
+            return tuple(response)
+
+    def transform_3(
+        self,
+        response: list[AnyStr] | dict[AnyStr, float],
+    ) -> tuple[AnyStr, ...] | dict[AnyStr, float]:
+        if self.options.get("withscores"):
+            assert isinstance(response, dict)
+            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/sentinel.py

@@ -46,7 +46,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__(

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