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

coredis/modules/response/_callbacks/autocomplete.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from coredis.modules.response.types import AutocompleteSuggestion
 from coredis.response._callbacks import ResponseCallback
-from coredis.typing import AnyStr, ResponseType, ValueT
+from coredis.typing import AnyStr, ResponseType
 
 
 class AutocompleteCallback(
@@ -13,17 +13,18 @@ class AutocompleteCallback(
     ]
 ):
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> tuple[AutocompleteSuggestion[AnyStr], ...] | tuple[()]:
         if not response:
             return ()
         step = 1
         results = []
         score_idx = payload_idx = 0
-        if options.get("withscores"):
+        if self.options.get("withscores"):
             score_idx = 1
             step += 1
-        if options.get("withpayloads"):
+        if self.options.get("withpayloads"):
             payload_idx = score_idx + 1
             step += 1
 

coredis/modules/response/_callbacks/graph.py

@@ -20,14 +20,13 @@ from coredis.typing import (
     ResponsePrimitive,
     ResponseType,
     StringT,
-    ValueT,
 )
 
 if TYPE_CHECKING:
     from coredis.client import Client
 
 
-class ValueTypes(enum.IntEnum):
+class RedisValueTypes(enum.IntEnum):
     VALUE_UNKNOWN = 0
     VALUE_NULL = 1
     VALUE_STRING = 2
@@ -49,11 +48,11 @@ PROCEDURE_CALLS = {
 }
 
 SCALAR_MAPPING = {
-    ValueTypes.VALUE_INTEGER: int,
-    ValueTypes.VALUE_BOOLEAN: lambda v: b(v) == b"true",
-    ValueTypes.VALUE_DOUBLE: float,
-    ValueTypes.VALUE_STRING: lambda v: v,
-    ValueTypes.VALUE_NULL: lambda _: None,
+    RedisValueTypes.VALUE_INTEGER: int,
+    RedisValueTypes.VALUE_BOOLEAN: lambda v: b(v) == b"true",
+    RedisValueTypes.VALUE_DOUBLE: float,
+    RedisValueTypes.VALUE_STRING: lambda v: v,
+    RedisValueTypes.VALUE_NULL: lambda _: None,
 }
 
 
@@ -65,14 +64,17 @@ class QueryCallback(
     relationships: dict[int, StringT]
     labels: dict[int, StringT]
 
-    def __init__(self, graph: StringT):
+    def __init__(self, graph: StringT, **options: Any):
         self.graph = graph
         self.properties = {}
         self.relationships = {}
         self.labels = {}
+        super().__init__(**options)
 
     async def pre_process(
-        self, client: Client[Any], response: ResponseType, **options: ValueT | None
+        self,
+        client: Client[Any],
+        response: ResponseType,
     ) -> None:
         if not len(response) == 3:
             return
@@ -99,21 +101,21 @@ class QueryCallback(
         self, entity: Any, max_label_id: int, max_relation_id: int, max_property_id: int
     ) -> tuple[int, int, int]:
         result_type = entity[0]
-        if result_type == ValueTypes.VALUE_NODE:
+        if result_type == RedisValueTypes.VALUE_NODE:
             for label_id in entity[1][1]:
                 max_label_id = max(max_label_id, label_id)
             for property_id in [k[0] for k in entity[1][2]]:
                 max_property_id = max(max_property_id, property_id)
-        elif result_type == ValueTypes.VALUE_EDGE:
+        elif result_type == RedisValueTypes.VALUE_EDGE:
             max_relation_id = max(max_relation_id, entity[1][1])
             for property_id in [k[0] for k in entity[1][4]]:
                 max_property_id = max(max_property_id, property_id)
-        elif result_type == ValueTypes.VALUE_PATH:
+        elif result_type == RedisValueTypes.VALUE_PATH:
             for segment in entity[1]:
                 max_label_id, max_relation_id, max_property_id = self.fetch_max_ids(
                     segment, max_label_id, max_relation_id, max_property_id
                 )
-        elif result_type == ValueTypes.VALUE_ARRAY:
+        elif result_type == RedisValueTypes.VALUE_ARRAY:
             for segment in entity[1]:
                 max_label_id, max_relation_id, max_property_id = self.fetch_max_ids(
                     segment, max_label_id, max_relation_id, max_property_id
@@ -141,7 +143,8 @@ class QueryCallback(
         return cache[f"{self.graph}:{type}"]
 
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> GraphQueryResult[AnyStr]:
         result_set = []
         headers = []
@@ -167,21 +170,21 @@ class QueryCallback(
     def parse_entity(self, entity):
         result_type = entity[0]
         if result_type in [
-            ValueTypes.VALUE_NULL,
-            ValueTypes.VALUE_STRING,
-            ValueTypes.VALUE_INTEGER,
-            ValueTypes.VALUE_BOOLEAN,
-            ValueTypes.VALUE_DOUBLE,
+            RedisValueTypes.VALUE_NULL,
+            RedisValueTypes.VALUE_STRING,
+            RedisValueTypes.VALUE_INTEGER,
+            RedisValueTypes.VALUE_BOOLEAN,
+            RedisValueTypes.VALUE_DOUBLE,
         ]:
             return SCALAR_MAPPING[result_type](entity[1])
-        elif result_type == ValueTypes.VALUE_MAP:
+        elif result_type == RedisValueTypes.VALUE_MAP:
             it = iter(entity[1])
             return dict(zip(it, map(self.parse_entity, it)))
-        elif result_type == ValueTypes.VALUE_ARRAY:
+        elif result_type == RedisValueTypes.VALUE_ARRAY:
             return [self.parse_entity(k) for k in entity[1]]
-        elif result_type == ValueTypes.VALUE_POINT:
+        elif result_type == RedisValueTypes.VALUE_POINT:
             return tuple(map(float, entity[1]))
-        elif result_type == ValueTypes.VALUE_EDGE:
+        elif result_type == RedisValueTypes.VALUE_EDGE:
             return GraphRelation(
                 id=entity[1][0],
                 type=self.relationships[entity[1][1]],
@@ -191,7 +194,7 @@ class QueryCallback(
                     self.properties[k[0]]: self.parse_entity((k[1], k[2])) for k in entity[1][4]
                 },
             )
-        elif result_type == ValueTypes.VALUE_NODE:
+        elif result_type == RedisValueTypes.VALUE_NODE:
             return GraphNode(
                 id=entity[1][0],
                 labels={self.labels[k] for k in entity[1][1]},
@@ -199,7 +202,7 @@ class QueryCallback(
                     self.properties[k[0]]: self.parse_entity((k[1], k[2])) for k in entity[1][2]
                 },
             )
-        elif result_type == ValueTypes.VALUE_PATH:
+        elif result_type == RedisValueTypes.VALUE_PATH:
             nodes, relations = entity[1]
             nodes = self.parse_entity(nodes)
             relations = self.parse_entity(relations)
@@ -207,11 +210,12 @@ class QueryCallback(
 
 
 class GraphSlowLogCallback(
-    ResponseCallback[ResponseType, ResponseType, tuple[GraphSlowLogInfo, ...] | bool]
+    ResponseCallback[ResponseType, ResponseType, tuple[GraphSlowLogInfo, ...]]
 ):
     def transform(
-        self, response: ResponseType, **kwargs: ValueT | None
-    ) -> tuple[GraphSlowLogInfo, ...] | bool:
+        self,
+        response: ResponseType,
+    ) -> tuple[GraphSlowLogInfo, ...]:
         return tuple(GraphSlowLogInfo(int(k[0]), k[1], k[2], float(k[3])) for k in response)
 
 
@@ -223,7 +227,8 @@ class ConfigGetCallback(
     ]
 ):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> ResponsePrimitive | dict[AnyStr, ResponsePrimitive]:
         if isinstance(response, list):
             if isinstance(response[0], list):

coredis/modules/response/_callbacks/json.py

@@ -3,13 +3,15 @@ from __future__ import annotations
 from typing import cast
 
 from coredis._json import json
-from coredis.modules.response.types import JsonType
 from coredis.response._callbacks import ResponseCallback
-from coredis.typing import ResponseType, ValueT
+from coredis.typing import JsonType, ResponseType
 
 
 class JsonCallback(ResponseCallback[ResponseType, ResponseType, JsonType]):
-    def transform(self, response: ResponseType, **kwargs: ValueT | None) -> JsonType:
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> JsonType:
         if isinstance(response, (bytes, str)):
             deser = json.loads(response)
         elif isinstance(response, list):

coredis/modules/response/_callbacks/search.py

@@ -16,9 +16,6 @@ from coredis.typing import (
     AnyStr,
     ResponsePrimitive,
     ResponseType,
-    StringT,
-    TypedDict,
-    ValueT,
 )
 
 
@@ -30,24 +27,24 @@ class SearchConfigCallback(
     ]
 ):
     def transform(
-        self, response: list[list[ResponsePrimitive]], **options: ValueT | None
+        self,
+        response: list[list[ResponsePrimitive]],
     ) -> dict[AnyStr, ResponsePrimitive]:
-        pieces = []
+        command_arguments = []
         for item in response:
             try:
                 v = (item[0], json.loads(item[1]))
             except (ValueError, TypeError):
                 v = item
-            pieces.append(v)
-        return dict(pieces)
+            command_arguments.append(v)
+        return dict(command_arguments)
 
     def transform_3(
         self,
         response: dict[AnyStr, ResponseType] | list[list[ResponsePrimitive]],
-        **options: ValueT | None,
     ) -> dict[AnyStr, ResponsePrimitive]:
         if isinstance(response, list):
-            return self.transform(response, **options)
+            return self.transform(response)
         else:
             config = {}
             for item, value in response.items():
@@ -66,9 +63,10 @@ class SearchResultCallback(
     ]
 ):
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> SearchResult[AnyStr]:
-        if options.get("nocontent"):
+        if self.options.get("nocontent"):
             return SearchResult[AnyStr](
                 response[0],
                 tuple(SearchDocument(i, None, None, None, None, {}) for i in response[1:]),
@@ -76,20 +74,20 @@ class SearchResultCallback(
         step = 2
         results = []
         score_idx = payload_idx = sort_key_idx = 0
-        if options.get("withscores"):
+        if self.options.get("withscores"):
             score_idx = 1
             step += 1
-        if options.get("withpayloads"):
+        if self.options.get("withpayloads"):
             payload_idx = score_idx + 1
             step += 1
-        if options.get("withsortkeys"):
+        if self.options.get("withsortkeys"):
             sort_key_idx = payload_idx + 1
             step += 1
 
         for k in range(1, len(response) - 1, step):
             section = response[k : k + step]
             score_explain = None
-            if options.get("explainscore"):
+            if self.options.get("explainscore"):
                 score = section[score_idx][0]
                 score_explain = section[score_idx][1]
             else:
@@ -112,22 +110,20 @@ class SearchResultCallback(
     def transform_3(
         self,
         response: list[ResponseType] | dict[AnyStr, ResponseType],
-        **options: ValueT | None,
     ) -> SearchResult[AnyStr]:
         results = []
         if isinstance(response, list):
-            return self.transform(response, **options)
+            return self.transform(response)
         else:
             response = EncodingInsensitiveDict(response)
             for result in response["results"]:
                 result = EncodingInsensitiveDict(result)
                 score_explain = None
-                if options.get("explainscore"):
-                    score = result["score"][0]
-                    score_explain = result["score"][1]
+                if self.options.get("explainscore"):
+                    score, score_explain = result.get("score")
                 else:
-                    score = result["score"]
-                fields = EncodingInsensitiveDict(result["extra_attributes"])
+                    score = result.get("score", None)
+                fields = EncodingInsensitiveDict(result.get("extra_attributes", {}))
                 if "$" in fields:
                     fields = json.loads(fields.pop("$"))
                 results.append(
@@ -135,8 +131,8 @@ class SearchResultCallback(
                         result["id"],
                         float(score) if score else None,
                         score_explain,
-                        result["payload"] if options.get("withpayloads") else None,
-                        result["sortkey"] if options.get("withsortkeys") else None,
+                        result["payload"] if self.options.get("withpayloads") else None,
+                        result["sortkey"] if self.options.get("withsortkeys") else None,
                         fields,
                     )
                 )
@@ -151,37 +147,40 @@ class AggregationResultCallback(
     ]
 ):
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> SearchAggregationResult:
         return SearchAggregationResult[AnyStr](
             [
-                flat_pairs_to_dict(k, partial(self.try_json, options))
-                for k in (response[1:] if not options.get("with_cursor") else response[0][1:])
+                flat_pairs_to_dict(k, partial(self.try_json, self.options))
+                for k in (response[1:] if not self.options.get("with_cursor") else response[0][1:])
             ],
-            response[1] if options.get("with_cursor") else None,
+            response[1] if self.options.get("with_cursor") else None,
         )
 
     def transform_3(
         self,
         response: dict[AnyStr, ResponseType] | list[ResponseType],
-        **options: ValueT | None,
     ) -> SearchAggregationResult:
         if (
-            options.get("with_cursor")
+            self.options.get("with_cursor")
             and isinstance(response[0], dict)
             or isinstance(response, dict)
         ):
-            response, cursor = response if options.get("with_cursor") else (response, None)
+            response, cursor = response if self.options.get("with_cursor") else (response, None)
             response = EncodingInsensitiveDict(response)
             return SearchAggregationResult[AnyStr](
                 [
-                    {k: self.try_json(options, v) for k, v in k["extra_attributes"].items()}
-                    for k in (response["results"])
+                    {
+                        r: self.try_json(self.options, v)
+                        for r, v in EncodingInsensitiveDict(k)["extra_attributes"].items()
+                    }
+                    for k in response["results"]
                 ],
                 cursor,
             )
         else:
-            return self.transform(response, **options)
+            return self.transform(response)
 
     @staticmethod
     def try_json(options, value):
@@ -193,33 +192,30 @@ class AggregationResultCallback(
             return value
 
 
-class SpellCheckResult(TypedDict):
-    term: StringT
-    suggestions: OrderedDict[StringT, int]
-
-
 class SpellCheckCallback(
     ResponseCallback[
         list[ResponseType],
         dict[AnyStr, ResponseType] | list[ResponseType],
-        SpellCheckResult,
+        dict[AnyStr, OrderedDict[AnyStr, float]],
     ]
 ):
-    def transform(self, response: list[ResponseType], **options: ValueT | None) -> SpellCheckResult:
-        suggestions = {}
-        for result in response:
-            suggestions[result[1]] = OrderedDict((k[1], float(k[0])) for k in result[2])
-
-        return suggestions
+    def transform(
+        self,
+        response: list[ResponseType],
+    ) -> dict[AnyStr, OrderedDict[AnyStr, float]]:
+        return {
+            result[1]: OrderedDict(
+                (suggestion[1], float(suggestion[0])) for suggestion in result[2]
+            )
+            for result in response
+        }
 
     def transform_3(
         self,
         response: dict[AnyStr, ResponseType] | list[ResponseType],
-        **options: ValueT | None,
-    ) -> SpellCheckResult:
+    ) -> dict[AnyStr, OrderedDict[AnyStr, float]]:
+        # For older versions of redis search that didn't support RESP3
         if isinstance(response, list):
-            return self.transform(response, **options)
-        else:
-            return {
-                key: OrderedDict(ChainMap(*result)) for key, result in response["results"].items()
-            }
+            return self.transform(response)
+        response = EncodingInsensitiveDict(response)
+        return {key: OrderedDict(ChainMap(*result)) for key, result in response["results"].items()}

coredis/modules/response/_callbacks/timeseries.py

@@ -11,40 +11,37 @@ from coredis.response._callbacks import (
 from coredis.response._utils import flat_pairs_to_dict
 from coredis.typing import (
     AnyStr,
-    Mapping,
+    RedisValueT,
     ResponsePrimitive,
     ResponseType,
     Sequence,
-    ValueT,
 )
 
 
 class SampleCallback(
     ResponseCallback[
-        list[ValueT],
-        list[ValueT],
+        list[RedisValueT],
+        list[RedisValueT],
         tuple[int, float] | tuple[()],
     ]
 ):
     def transform(
         self,
-        response: list[ValueT],
-        **options: ValueT | None,
+        response: list[RedisValueT],
     ) -> tuple[int, float] | tuple[()]:
         return (int(response[0]), float(response[1])) if response else ()
 
 
 class SamplesCallback(
     ResponseCallback[
-        list[list[ValueT]] | None,
-        list[list[ValueT]] | None,
+        list[list[RedisValueT]] | None,
+        list[list[RedisValueT]] | None,
         tuple[tuple[int, float], ...] | tuple[()],
     ],
 ):
     def transform(
         self,
-        response: list[list[ValueT]] | None,
-        **options: ValueT | None,
+        response: list[list[RedisValueT]] | None,
     ) -> tuple[tuple[int, float], ...] | tuple[()]:
         if response:
             return tuple(cast(tuple[int, float], SampleCallback().transform(r)) for r in response)
@@ -55,9 +52,8 @@ class TimeSeriesInfoCallback(DictCallback[AnyStr, ResponseType]):
     def transform(
         self,
         response: Sequence[ResponseType] | dict[ResponsePrimitive, ResponseType],
-        **options: ValueT | None,
     ) -> dict[AnyStr, ResponseType]:
-        dct = EncodingInsensitiveDict(super().transform(response, **options))
+        dct = EncodingInsensitiveDict(super().transform(response))
         if "labels" in dct:
             dct["labels"] = dict(dct["labels"])
         if "Chunks" in dct:
@@ -76,7 +72,8 @@ class TimeSeriesCallback(
     ]
 ):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> dict[AnyStr, tuple[dict[AnyStr, AnyStr], tuple[int, float] | tuple[()]]]:
         if isinstance(response, dict):
             return {k: (v[0], tuple(v[1])) for k, v in response.items()}
@@ -97,12 +94,13 @@ class TimeSeriesMultiCallback(
     ]
 ):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> dict[
         AnyStr,
         tuple[dict[AnyStr, AnyStr], tuple[tuple[int, float], ...] | tuple[()]],
     ]:
-        if options.get("grouped"):
+        if self.options.get("grouped"):
             return {
                 r[0]: (
                     flat_pairs_to_dict(r[1][0]) if r[1] else {},
@@ -120,13 +118,14 @@ class TimeSeriesMultiCallback(
             }
 
     def transform_3(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> dict[
         AnyStr,
         tuple[dict[AnyStr, AnyStr], tuple[tuple[int, float], ...] | tuple[()]],
     ]:
         if isinstance(response, dict):
-            if options.get("grouped"):
+            if self.options.get("grouped"):
                 return {
                     k: (
                         r[0],
@@ -143,23 +142,12 @@ class TimeSeriesMultiCallback(
                     for k, r in response.items()
                 }
         else:
-            return self.transform(response, **options)
+            return self.transform(response)
 
 
 class ClusterMergeTimeSeries(ClusterMergeMapping[AnyStr, tuple[Any, ...]]):
     def __init__(self) -> None:
-        self.value_combine = self.merge
-
-    def combine(
-        self,
-        responses: Mapping[str, dict[AnyStr, tuple[Any, ...]]],
-        **kwargs: ValueT | None,
-    ) -> dict[AnyStr, tuple[Any, ...]]:
-        if not kwargs.get("grouped"):
-            return super().combine(responses, **kwargs)
-        raise NotImplementedError(
-            "Unable to merge response from multiple cluster nodes when used with grouping"
-        )
+        super().__init__(value_combine=self.merge)
 
     def merge(self, values: Any) -> tuple[dict[AnyStr, AnyStr], tuple[tuple[int, float], ...]]:
         merged_labels: dict[AnyStr, AnyStr] = {}

coredis/modules/response/types.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Any, NamedTuple
+from typing import NamedTuple
 
 from coredis._json import json
 from coredis.typing import (
@@ -81,10 +81,6 @@ class AutocompleteSuggestion(Generic[AnyStr]):
     payload: AnyStr | None
 
 
-#: Type alias for valid python types that can be represented as json
-JsonType = str | int | float | bool | dict[str, Any] | list[Any] | None
-
-
 @dataclasses.dataclass
 class GraphNode(Generic[AnyStr]):
     """