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

coredis/response/_callbacks/command.py

@@ -8,13 +8,13 @@ from coredis.typing import (
     AnyStr,
     ResponsePrimitive,
     ResponseType,
-    ValueT,
 )
 
 
 class CommandCallback(ResponseCallback[list[ResponseType], list[ResponseType], dict[str, Command]]):
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> dict[str, Command]:
         commands: dict[str, Command] = {}
 
@@ -53,7 +53,8 @@ class CommandKeyFlagCallback(
     ResponseCallback[list[ResponseType], list[ResponseType], dict[AnyStr, set[AnyStr]]]
 ):
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> dict[AnyStr, set[AnyStr]]:
         return {k[0]: set(k[1]) for k in response}
 
@@ -66,7 +67,8 @@ class CommandDocCallback(
     ]
 ):
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> dict[AnyStr, dict[AnyStr, ResponseType]]:
         cmd_mapping = flat_pairs_to_dict(response)
         for cmd, doc in cmd_mapping.items():
@@ -74,11 +76,11 @@ class CommandDocCallback(
             cmd_mapping[cmd]["arguments"] = [
                 flat_pairs_to_dict(arg) for arg in cmd_mapping[cmd].get("arguments", [])
             ]
-        return cmd_mapping
+            cmd_mapping[cmd] = dict(cmd_mapping[cmd])
+        return dict(cmd_mapping)
 
     def transform_3(
         self,
         response: dict[ResponsePrimitive, ResponseType],
-        **options: ValueT | None,
     ) -> dict[AnyStr, dict[AnyStr, ResponseType]]:
         return response  # noqa

coredis/response/_callbacks/connection.py

@@ -6,7 +6,6 @@ from coredis.response._utils import flat_pairs_to_dict
 from coredis.typing import (
     AnyStr,
     ResponseType,
-    ValueT,
 )
 
 
@@ -18,13 +17,15 @@ class ClientTrackingInfoCallback(
     ]
 ):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> dict[AnyStr, AnyStr | set[AnyStr] | list[AnyStr]]:
         response = EncodingInsensitiveDict(flat_pairs_to_dict(response))
         response["flags"] = set(response["flags"])
         return dict(response)
 
     def transform_3(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> dict[AnyStr, AnyStr | set[AnyStr] | list[AnyStr]]:
         return response

coredis/response/_callbacks/geo.py

@@ -1,24 +1,28 @@
 from __future__ import annotations
 
+from typing import Any
+
 from coredis.response._callbacks import ResponseCallback
 from coredis.response.types import GeoCoordinates, GeoSearchResult
-from coredis.typing import AnyStr, ResponseType, ValueT
+from coredis.typing import AnyStr, Generic, ResponseType
 
 
 class GeoSearchCallback(
+    Generic[AnyStr],
     ResponseCallback[
         ResponseType,
         ResponseType,
-        int | tuple[AnyStr | GeoSearchResult, ...],
-    ]
+        tuple[AnyStr | GeoSearchResult, ...],
+    ],
 ):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
-    ) -> int | tuple[AnyStr | GeoSearchResult, ...]:
-        if options.get("store") or options.get("storedist"):
-            return response
-
-        if not (options.get("withdist") or options.get("withcoord") or options.get("withhash")):
+        self, response: ResponseType, **options: Any
+    ) -> tuple[AnyStr | GeoSearchResult, ...]:
+        if not (
+            self.options.get("withdist")
+            or self.options.get("withcoord")
+            or self.options.get("withhash")
+        ):
             return tuple(list(response))
 
         results: list[GeoSearchResult] = []
@@ -27,11 +31,11 @@ class GeoSearchCallback(
             results.append(
                 GeoSearchResult(
                     result.pop(0),
-                    float(result.pop(0)) if options.get("withdist") else None,
-                    result.pop(0) if options.get("withhash") else None,
+                    float(result.pop(0)) if self.options.get("withdist") else None,
+                    result.pop(0) if self.options.get("withhash") else None,
                     (
                         GeoCoordinates(*map(float, result.pop(0)))
-                        if options.get("withcoord")
+                        if self.options.get("withcoord")
                         else None
                     ),
                 )
@@ -44,7 +48,7 @@ class GeoCoordinatessCallback(
     ResponseCallback[ResponseType, ResponseType, tuple[GeoCoordinates | None, ...]]
 ):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self, response: ResponseType, **options: Any
     ) -> tuple[GeoCoordinates | None, ...]:
         return tuple(
             map(

coredis/response/_callbacks/hash.py

@@ -9,7 +9,6 @@ from coredis.typing import (
     ResponseType,
     StringT,
     TypeGuard,
-    ValueT,
 )
 
 
@@ -24,11 +23,12 @@ class HScanCallback(
         return isinstance(response[0], (str, bytes)) and isinstance(response[1], list)
 
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> tuple[int, dict[AnyStr, AnyStr] | tuple[AnyStr, ...]]:
         assert self.guard(response)
         cursor, r = response
-        if options.get("novalues"):
+        if self.options.get("novalues"):
             return int(cursor), tuple(r)
         else:
             return int(cursor), flat_pairs_to_dict(r)
@@ -44,13 +44,12 @@ class HRandFieldCallback(
     def transform(
         self,
         response: AnyStr | list[AnyStr] | None,
-        **options: ValueT | None,
     ) -> AnyStr | tuple[AnyStr, ...] | dict[AnyStr, AnyStr] | None:
         if not response:
             return None
-        if options.get("count"):
+        if self.options.get("count"):
             assert isinstance(response, list)
-            if options.get("withvalues"):
+            if self.options.get("withvalues"):
                 return flat_pairs_to_dict(response)
             else:
                 return tuple(response)
@@ -60,13 +59,12 @@ class HRandFieldCallback(
     def transform_3(
         self,
         response: AnyStr | list[AnyStr] | list[list[AnyStr]] | None,
-        **options: ValueT | None,
     ) -> AnyStr | tuple[AnyStr, ...] | dict[AnyStr, AnyStr] | None:
         if not response:
             return None
-        if options.get("count"):
+        if self.options.get("count"):
             assert isinstance(response, list)
-            if options.get("withvalues"):
+            if self.options.get("withvalues"):
                 return dict(cast(list[tuple[AnyStr, AnyStr]], response))
             return tuple(cast(tuple[AnyStr, AnyStr], response))
         assert isinstance(response, (str, bytes))
@@ -74,10 +72,14 @@ class HRandFieldCallback(
 
 
 class HGetAllCallback(ResponseCallback[list[AnyStr], dict[AnyStr, AnyStr], dict[AnyStr, AnyStr]]):
-    def transform(self, response: list[AnyStr], **options: ValueT | None) -> dict[AnyStr, AnyStr]:
+    def transform(
+        self,
+        response: list[AnyStr],
+    ) -> dict[AnyStr, AnyStr]:
         return flat_pairs_to_dict(response) if response else {}
 
     def transform_3(
-        self, response: dict[AnyStr, AnyStr], **options: ValueT | None
+        self,
+        response: dict[AnyStr, AnyStr],
     ) -> dict[AnyStr, AnyStr]:
         return response

coredis/response/_callbacks/keys.py

@@ -9,7 +9,6 @@ from coredis.typing import (
     ResponseType,
     StringT,
     TypeGuard,
-    ValueT,
 )
 
 
@@ -21,7 +20,8 @@ class SortCallback(
     ]
 ):
     def transform(
-        self, response: int | list[AnyStr], **options: ValueT | None
+        self,
+        response: int | list[AnyStr],
     ) -> int | tuple[AnyStr, ...]:
         if isinstance(response, list):
             return tuple(response)
@@ -35,7 +35,8 @@ class ScanCallback(
         return isinstance(response[0], (str, bytes)) and isinstance(response[1], list)
 
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> tuple[int, tuple[AnyStr, ...]]:
         assert self.guard(response)
         cursor, r = response
@@ -43,9 +44,12 @@ class ScanCallback(
 
 
 class ExpiryCallback(DateTimeCallback):
-    def transform(self, response: int, **options: ValueT | None) -> datetime:
+    def transform(
+        self,
+        response: int,
+    ) -> datetime:
         if response > 0:
-            return super().transform(response, **options)
+            return super().transform(response)
         else:
             if response == -2:
                 raise NoKeyError()

coredis/response/_callbacks/module.py

@@ -8,7 +8,6 @@ from coredis.typing import (
     AnyStr,
     ResponsePrimitive,
     ResponseType,
-    ValueT,
 )
 
 
@@ -20,7 +19,8 @@ class ModuleInfoCallback(
     ]
 ):
     def transform(
-        self, response: list[list[ResponseType]], **options: ValueT | None
+        self,
+        response: list[list[ResponseType]],
     ) -> tuple[dict[AnyStr, ResponsePrimitive], ...]:
         return tuple(
             cast(dict[AnyStr, ResponsePrimitive], flat_pairs_to_dict(mod)) for mod in response
@@ -29,6 +29,5 @@ class ModuleInfoCallback(
     def transform_3(
         self,
         response: list[dict[AnyStr, ResponsePrimitive]],
-        **options: ValueT | None,
     ) -> tuple[dict[AnyStr, ResponsePrimitive], ...]:
         return tuple(response)

coredis/response/_callbacks/script.py

@@ -9,9 +9,9 @@ from coredis.response.types import LibraryDefinition
 from coredis.typing import (
     AnyStr,
     Mapping,
+    RedisValueT,
     ResponsePrimitive,
     ResponseType,
-    ValueT,
 )
 
 
@@ -19,10 +19,11 @@ class FunctionListCallback(
     ResponseCallback[list[ResponseType], list[ResponseType], Mapping[AnyStr, LibraryDefinition]]
 ):
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> Mapping[AnyStr, LibraryDefinition]:
         libraries = [
-            EncodingInsensitiveDict(flat_pairs_to_dict(cast(list[ValueT], library)))
+            EncodingInsensitiveDict(flat_pairs_to_dict(cast(list[RedisValueT], library)))
             for library in response
         ]
         transformed = EncodingInsensitiveDict()
@@ -36,11 +37,10 @@ class FunctionListCallback(
             library["functions"] = functions
             transformed[lib_name] = EncodingInsensitiveDict(
                 LibraryDefinition(
-                    name=library["name"],
+                    name=library["library_name"],
                     engine=library["engine"],
-                    description=library["description"],
                     functions=library["functions"],
-                    library_code=library["library_code"],
+                    library_code=library.get("library_code", None),
                 )
             )
         return transformed
@@ -62,7 +62,6 @@ class FunctionStatsCallback(
     def transform(
         self,
         response: list[ResponseType],
-        **options: ValueT | None,
     ) -> dict[AnyStr, AnyStr | dict[AnyStr, dict[AnyStr, ResponsePrimitive]] | None]:
         transformed = flat_pairs_to_dict(response)
         key = cast(AnyStr, b"engines" if b"engines" in transformed else "engines")
@@ -82,6 +81,5 @@ class FunctionStatsCallback(
             AnyStr,
             AnyStr | dict[AnyStr, dict[AnyStr, ResponsePrimitive]] | None,
         ],
-        **options: ValueT | None,
     ) -> dict[AnyStr, AnyStr | dict[AnyStr, dict[AnyStr, ResponsePrimitive]] | None]:
         return response

coredis/response/_callbacks/sentinel.py

@@ -7,9 +7,9 @@ from coredis.response._callbacks import ResponseCallback
 from coredis.response._callbacks.server import InfoCallback
 from coredis.typing import (
     AnyStr,
+    MutableMapping,
     ResponsePrimitive,
     ResponseType,
-    ValueT,
 )
 
 SENTINEL_STATE_INT_FIELDS = {
@@ -54,8 +54,8 @@ def sentinel_state_typed(
 
 
 def add_flags(
-    result: dict[str, int | str | bool],
-) -> dict[str, int | str | bool]:
+    result: MutableMapping[str, int | str | bool],
+) -> MutableMapping[str, int | str | bool]:
     flags = set(nativestr(result["flags"]).split(","))
     for name, flag in (
         ("is_master", "master"),
@@ -72,7 +72,7 @@ def add_flags(
 
 def parse_sentinel_state(
     item: list[ResponsePrimitive],
-) -> dict[str, int | str | bool]:
+) -> MutableMapping[str, int | str | bool]:
     result = sentinel_state_typed([nativestr(k) for k in item])
     result = add_flags(result)
     return result
@@ -86,16 +86,16 @@ class PrimaryCallback(
     ]
 ):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> dict[str, str | int | bool]:
-        return parse_sentinel_state(cast(list[ResponsePrimitive], response))
+        return dict(parse_sentinel_state(cast(list[ResponsePrimitive], response)))
 
     def transform_3(
         self,
         response: dict[ResponsePrimitive, ResponsePrimitive],
-        **options: ValueT | None,
     ) -> dict[str, str | int | bool]:
-        return add_flags(EncodingInsensitiveDict(response))
+        return dict(add_flags(EncodingInsensitiveDict(response)))
 
 
 class PrimariesCallback(
@@ -108,7 +108,6 @@ class PrimariesCallback(
     def transform(
         self,
         response: list[ResponseType] | dict[ResponsePrimitive, ResponsePrimitive],
-        **options: ValueT | None,
     ) -> dict[str, dict[str, str | int | bool]]:
         result: dict[str, dict[str, str | int | bool]] = {}
 
@@ -119,12 +118,13 @@ class PrimariesCallback(
         return result
 
     def transform_3(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> dict[str, dict[str, str | int | bool]]:
         states: dict[str, dict[str, str | int | bool]] = {}
         for state in response:
             proxy = add_flags(EncodingInsensitiveDict(state))
-            states[nativestr(proxy["name"])] = proxy
+            states[nativestr(proxy["name"])] = dict(proxy)
         return states
 
 
@@ -136,14 +136,16 @@ class SentinelsStateCallback(
     ]
 ):
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> tuple[dict[str, str | bool | int], ...]:
-        return tuple(parse_sentinel_state([nativestr(i) for i in item]) for item in response)
+        return tuple(dict(parse_sentinel_state([nativestr(i) for i in item])) for item in response)
 
     def transform_3(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> tuple[dict[str, str | bool | int], ...]:
-        return tuple(add_flags(EncodingInsensitiveDict(state)) for state in response)
+        return tuple(dict(add_flags(EncodingInsensitiveDict(state))) for state in response)
 
 
 class GetPrimaryCallback(
@@ -154,7 +156,8 @@ class GetPrimaryCallback(
     ]
 ):
     def transform(
-        self, response: list[ResponsePrimitive], **options: ValueT | None
+        self,
+        response: list[ResponsePrimitive],
     ) -> tuple[str, int] | None:
         return nativestr(response[0]), int(response[1]) if response else None
 
@@ -167,6 +170,7 @@ class SentinelInfoCallback(
     ]
 ):
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> dict[AnyStr, dict[int, dict[str, ResponseType]]]:
         return {response[0]: {r[0]: InfoCallback()(r[1]) for r in response[1]}}

coredis/response/_callbacks/server.py

@@ -10,15 +10,18 @@ from coredis.response.types import ClientInfo, RoleInfo, SlowLogInfo
 from coredis.typing import (
     AnyStr,
     ClassVar,
+    RedisValueT,
     ResponsePrimitive,
     ResponseType,
     StringT,
-    ValueT,
 )
 
 
 class TimeCallback(ResponseCallback[list[AnyStr], list[AnyStr], datetime.datetime]):
-    def transform(self, response: list[AnyStr], **options: ValueT | None) -> datetime.datetime:
+    def transform(
+        self,
+        response: list[AnyStr],
+    ) -> datetime.datetime:
         return datetime.datetime.fromtimestamp(int(response[0])) + datetime.timedelta(
             microseconds=int(response[1]) / 1000.0
         )
@@ -26,7 +29,8 @@ class TimeCallback(ResponseCallback[list[AnyStr], list[AnyStr], datetime.datetim
 
 class SlowlogCallback(ResponseCallback[ResponseType, ResponseType, tuple[SlowLogInfo, ...]]):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> tuple[SlowLogInfo, ...]:
         return tuple(
             SlowLogInfo(
@@ -61,7 +65,10 @@ class ClientInfoCallback(ResponseCallback[ResponseType, ResponseType, ClientInfo
         "redir",
     }
 
-    def transform(self, response: ResponseType, **options: ValueT | None) -> ClientInfo:
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> ClientInfo:
         decoded_response = nativestr(response)
         pairs = [pair.split("=", 1) for pair in decoded_response.strip().split(" ")]
 
@@ -75,14 +82,20 @@ class ClientInfoCallback(ResponseCallback[ResponseType, ResponseType, ClientInfo
 
 
 class ClientListCallback(ResponseCallback[ResponseType, ResponseType, tuple[ClientInfo, ...]]):
-    def transform(self, response: ResponseType, **options: ValueT | None) -> tuple[ClientInfo, ...]:
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> tuple[ClientInfo, ...]:
         return tuple(ClientInfoCallback()(c) for c in response.splitlines())
 
 
 class DebugCallback(ResponseCallback[ResponseType, ResponseType, dict[str, str | int]]):
     INT_FIELDS: ClassVar = {"refcount", "serializedlength", "lru", "lru_seconds_idle"}
 
-    def transform(self, response: ResponseType, **options: ValueT | None) -> dict[str, str | int]:
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> dict[str, str | int]:
         # The 'type' of the object is the first item in the response, but isn't
         # prefixed with a name
 
@@ -108,7 +121,10 @@ class InfoCallback(
         dict[str, ResponseType],
     ]
 ):
-    def transform(self, response: StringT, **options: ValueT | None) -> dict[str, ResponseType]:
+    def transform(
+        self,
+        response: StringT,
+    ) -> dict[str, ResponseType]:
         """Parses the result of Redis's INFO command into a Python dict"""
 
         info: dict[str, Any] = {}
@@ -149,14 +165,14 @@ class InfoCallback(
                     cur_info.setdefault("__raw__", []).append(line)
             elif line:
                 if cur_info and header:
-                    if options.get("nested"):
+                    if self.options.get("nested"):
                         info[header] = cur_info
                     else:
                         info.update(cur_info)
                     cur_info = {}
                 header = line.lstrip("#").strip().lower()
         if header and header not in info:
-            if options.get("nested"):
+            if self.options.get("nested"):
                 info[header] = cur_info
             else:
                 info.update(cur_info)
@@ -164,7 +180,10 @@ class InfoCallback(
 
 
 class RoleCallback(ResponseCallback[ResponseType, ResponseType, RoleInfo]):
-    def transform(self, response: ResponseType, **options: ValueT | None) -> RoleInfo:
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> RoleInfo:
         role = nativestr(response[0])
 
         def _parse_master(response: Any) -> Any:
@@ -198,15 +217,17 @@ class RoleCallback(ResponseCallback[ResponseType, ResponseType, RoleInfo]):
 
 
 class LatencyHistogramCallback(
-    ResponseCallback[ResponseType, ResponseType, dict[AnyStr, dict[AnyStr, ValueT]]]
+    ResponseCallback[ResponseType, ResponseType, dict[AnyStr, dict[AnyStr, RedisValueT]]]
 ):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
-    ) -> dict[AnyStr, dict[AnyStr, ValueT]]:
+        self,
+        response: ResponseType,
+    ) -> dict[AnyStr, dict[AnyStr, RedisValueT]]:
         histogram = flat_pairs_to_dict(response)
         for key, value in histogram.items():
             histogram[key] = EncodingInsensitiveDict(flat_pairs_to_dict(value))
             histogram[key]["histogram_usec"] = flat_pairs_to_dict(histogram[key]["histogram_usec"])
+            histogram[key] = dict(histogram[key])
         return histogram
 
 
@@ -214,6 +235,7 @@ class LatencyCallback(
     ResponseCallback[ResponseType, ResponseType, dict[AnyStr, tuple[int, int, int]]]
 ):
     def transform(
-        self, response: ResponseType, **options: ValueT | None
+        self,
+        response: ResponseType,
     ) -> dict[AnyStr, tuple[int, int, int]]:
         return {k[0]: (k[1], k[2], k[3]) for k in response}

coredis/response/_callbacks/sets.py

@@ -8,7 +8,6 @@ from coredis.typing import (
     Iterable,
     ResponsePrimitive,
     ResponseType,
-    ValueT,
 )
 
 
@@ -16,7 +15,8 @@ class SScanCallback(
     ResponseCallback[list[ResponseType], list[ResponseType], tuple[int, set[AnyStr]]]
 ):
     def transform(
-        self, response: list[ResponseType], **options: ValueT | None
+        self,
+        response: list[ResponseType],
     ) -> tuple[int, set[AnyStr]]:
         cursor, r = response
         assert isinstance(cursor, (bytes, str)) and isinstance(r, Iterable)
@@ -33,9 +33,8 @@ class ItemOrSetCallback(
     def transform(
         self,
         response: AnyStr | list[ResponsePrimitive] | set[ResponsePrimitive],
-        **options: ValueT | None,
     ) -> AnyStr | set[AnyStr]:
-        if options.get("count"):
+        if self.options.get("count"):
             if isinstance(response, set):
                 return cast(set[AnyStr], response)
             if isinstance(response, list):