coredis 5.5.0__cp313-cp313-macosx_11_0_arm64.whl

coredis/response/_callbacks/cluster.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from coredis._utils import EncodingInsensitiveDict, nativestr
+from coredis.response._callbacks import ResponseCallback
+from coredis.response._utils import flat_pairs_to_dict
+from coredis.response.types import ClusterNode, ClusterNodeDetail
+from coredis.typing import (
+    AnyStr,
+    Mapping,
+    RedisValueT,
+    ResponsePrimitive,
+    ResponseType,
+)
+
+
+class ClusterLinksCallback(
+    ResponseCallback[ResponseType, ResponseType, list[dict[AnyStr, ResponsePrimitive]]]
+):
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> list[dict[AnyStr, ResponsePrimitive]]:
+        transformed: list[dict[AnyStr, ResponsePrimitive]] = []
+
+        for item in response:
+            transformed.append(flat_pairs_to_dict(item))
+        return transformed
+
+    def transform_3(
+        self,
+        response: ResponseType,
+    ) -> list[dict[AnyStr, ResponsePrimitive]]:
+        return response
+
+
+class ClusterInfoCallback(ResponseCallback[ResponseType, ResponseType, dict[str, str]]):
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> dict[str, str]:
+        response_str = nativestr(response)
+        return dict([line.split(":") for line in response_str.splitlines() if line])
+
+
+class ClusterSlotsCallback(
+    ResponseCallback[ResponseType, ResponseType, dict[tuple[int, int], tuple[ClusterNode, ...]]]
+):
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> dict[tuple[int, int], tuple[ClusterNode, ...]]:
+        res: dict[tuple[int, int], tuple[ClusterNode, ...]] = {}
+
+        for slot_info in response:
+            min_slot, max_slot = map(int, slot_info[:2])
+            nodes = slot_info[2:]
+            res[(min_slot, max_slot)] = tuple(self.parse_node(node) for node in nodes)
+            res[(min_slot, max_slot)][0]["server_type"] = "master"
+
+        return res
+
+    def parse_node(self, node: list[int | str]) -> ClusterNode:
+        return ClusterNode(
+            host=nativestr(node[0]),
+            port=int(node[1]),
+            node_id=nativestr(node[2]) if len(node) > 2 else "",
+            server_type="slave",
+        )
+
+
+class ClusterNodesCallback(ResponseCallback[ResponseType, ResponseType, list[ClusterNodeDetail]]):
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> list[ClusterNodeDetail]:
+        resp: list[str] | str
+
+        if isinstance(response, list):
+            resp = [nativestr(row) for row in response]
+        else:
+            resp = nativestr(response)
+        current_host = nativestr(self.options.get("current_host", ""))
+
+        def parse_slots(s: str) -> tuple[list[int], list[dict[str, RedisValueT]]]:
+            slots: list[int] = []
+            migrations: list[dict[str, RedisValueT]] = []
+
+            for r in s.split(" "):
+                if "->-" in r:
+                    slot_id, dst_node_id = r[1:-1].split("->-", 1)
+                    migrations.append(
+                        {
+                            "slot": int(slot_id),
+                            "node_id": dst_node_id,
+                            "state": "migrating",
+                        }
+                    )
+                elif "-<-" in r:
+                    slot_id, src_node_id = r[1:-1].split("-<-", 1)
+                    migrations.append(
+                        {
+                            "slot": int(slot_id),
+                            "node_id": src_node_id,
+                            "state": "importing",
+                        }
+                    )
+                elif "-" in r:
+                    start, end = r.split("-")
+                    slots.extend(list(range(int(start), int(end) + 1)))
+                else:
+                    slots.append(int(r))
+
+            return slots, migrations
+
+        if isinstance(resp, str):
+            resp = resp.splitlines()
+
+        nodes: list[ClusterNodeDetail] = []
+
+        for line in resp:
+            parts = line.split(" ", 8)
+            (
+                self_id,
+                addr,
+                flags,
+                master_id,
+                ping_sent,
+                pong_recv,
+                _,
+                link_state,
+            ) = parts[:8]
+
+            host, port = addr.rsplit(":", 1)
+
+            node: ClusterNodeDetail = {
+                "id": self_id,
+                "host": host or current_host,
+                "port": int(port.split("@")[0]),
+                "flags": tuple(flags.split(",")),
+                "master": master_id if master_id != "-" else None,
+                "ping_sent": int(ping_sent),
+                "pong_recv": int(pong_recv),
+                "link_state": link_state,
+                "slots": [],
+                "migrations": [],
+            }
+            if len(parts) >= 9:
+                slots, migrations = parse_slots(parts[8])
+                node["slots"], node["migrations"] = slots, migrations
+
+            nodes.append(node)
+
+        return nodes
+
+
+class ClusterShardsCallback(
+    ResponseCallback[
+        ResponseType,
+        ResponseType,
+        list[dict[AnyStr, list[RedisValueT] | Mapping[AnyStr, RedisValueT]]],
+    ]
+):
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> list[dict[AnyStr, list[RedisValueT] | Mapping[AnyStr, RedisValueT]]]:
+        shard_mapping: list[dict[AnyStr, list[RedisValueT] | Mapping[AnyStr, RedisValueT]]] = []
+
+        for shard in response:
+            transformed = EncodingInsensitiveDict(flat_pairs_to_dict(shard))
+            node_mapping: list[dict[AnyStr, RedisValueT]] = []
+            for node in transformed["nodes"]:
+                node_mapping.append(flat_pairs_to_dict(node))
+
+            transformed["nodes"] = node_mapping
+            shard_mapping.append(transformed.__wrapped__)  # type: ignore
+        return shard_mapping
+
+    def transform_3(
+        self,
+        response: ResponseType,
+    ) -> list[dict[AnyStr, list[RedisValueT] | Mapping[AnyStr, RedisValueT]]]:
+        return response

coredis/response/_callbacks/command.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from coredis._utils import EncodingInsensitiveDict, nativestr
+from coredis.response._callbacks import ResponseCallback
+from coredis.response._utils import flat_pairs_to_dict
+from coredis.response.types import Command
+from coredis.typing import (
+    AnyStr,
+    ResponsePrimitive,
+    ResponseType,
+)
+
+
+class CommandCallback(ResponseCallback[list[ResponseType], list[ResponseType], dict[str, Command]]):
+    def transform(
+        self,
+        response: list[ResponseType],
+    ) -> dict[str, Command]:
+        commands: dict[str, Command] = {}
+
+        for command in response:
+            assert isinstance(command, list)
+
+            if command:
+                name = nativestr(command[0])
+
+                if len(command) >= 6:
+                    commands[name] = {
+                        "name": command[0],
+                        "arity": command[1],
+                        "flags": command[2],
+                        "first-key": command[3],
+                        "last-key": command[4],
+                        "step": command[5],
+                        "acl-categories": None,
+                        "tips": None,
+                        "key-specifications": None,
+                        "sub-commands": None,
+                    }
+
+                if len(command) >= 7:
+                    commands[name]["acl-categories"] = command[6]
+
+                if len(command) >= 8:
+                    commands[name]["tips"] = command[7]
+                    commands[name]["key-specifications"] = command[8]
+                    commands[name]["sub-commands"] = command[9]
+
+        return commands
+
+
+class CommandKeyFlagCallback(
+    ResponseCallback[list[ResponseType], list[ResponseType], dict[AnyStr, set[AnyStr]]]
+):
+    def transform(
+        self,
+        response: list[ResponseType],
+    ) -> dict[AnyStr, set[AnyStr]]:
+        return {k[0]: set(k[1]) for k in response}
+
+
+class CommandDocCallback(
+    ResponseCallback[
+        list[ResponseType],
+        dict[ResponsePrimitive, ResponseType],
+        dict[AnyStr, dict[AnyStr, ResponseType]],
+    ]
+):
+    def transform(
+        self,
+        response: list[ResponseType],
+    ) -> dict[AnyStr, dict[AnyStr, ResponseType]]:
+        cmd_mapping = flat_pairs_to_dict(response)
+        for cmd, doc in cmd_mapping.items():
+            cmd_mapping[cmd] = EncodingInsensitiveDict(flat_pairs_to_dict(doc))
+            cmd_mapping[cmd]["arguments"] = [
+                flat_pairs_to_dict(arg) for arg in cmd_mapping[cmd].get("arguments", [])
+            ]
+            cmd_mapping[cmd] = dict(cmd_mapping[cmd])
+        return dict(cmd_mapping)
+
+    def transform_3(
+        self,
+        response: dict[ResponsePrimitive, ResponseType],
+    ) -> dict[AnyStr, dict[AnyStr, ResponseType]]:
+        return response  # noqa

coredis/response/_callbacks/connection.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from coredis._utils import EncodingInsensitiveDict
+from coredis.response._callbacks import ResponseCallback
+from coredis.response._utils import flat_pairs_to_dict
+from coredis.typing import (
+    AnyStr,
+    ResponseType,
+)
+
+
+class ClientTrackingInfoCallback(
+    ResponseCallback[
+        ResponseType,
+        ResponseType,
+        dict[AnyStr, AnyStr | set[AnyStr] | list[AnyStr]],
+    ]
+):
+    def transform(
+        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,
+    ) -> dict[AnyStr, AnyStr | set[AnyStr] | list[AnyStr]]:
+        return response

coredis/response/_callbacks/geo.py

@@ -0,0 +1,58 @@
+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, Generic, ResponseType
+
+
+class GeoSearchCallback(
+    Generic[AnyStr],
+    ResponseCallback[
+        ResponseType,
+        ResponseType,
+        tuple[AnyStr | GeoSearchResult, ...],
+    ],
+):
+    def transform(
+        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] = []
+
+        for result in response:
+            results.append(
+                GeoSearchResult(
+                    result.pop(0),
+                    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 self.options.get("withcoord")
+                        else None
+                    ),
+                )
+            )
+
+        return tuple(results)
+
+
+class GeoCoordinatessCallback(
+    ResponseCallback[ResponseType, ResponseType, tuple[GeoCoordinates | None, ...]]
+):
+    def transform(
+        self, response: ResponseType, **options: Any
+    ) -> tuple[GeoCoordinates | None, ...]:
+        return tuple(
+            map(
+                lambda ll: (GeoCoordinates(float(ll[0]), float(ll[1])) if ll is not None else None),
+                response,
+            )
+        )

coredis/response/_callbacks/hash.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import cast
+
+from coredis.response._callbacks import ResponseCallback
+from coredis.response._utils import flat_pairs_to_dict
+from coredis.typing import (
+    AnyStr,
+    ResponseType,
+    StringT,
+    TypeGuard,
+)
+
+
+class HScanCallback(
+    ResponseCallback[
+        list[ResponseType],
+        list[ResponseType],
+        tuple[int, dict[AnyStr, AnyStr] | tuple[AnyStr, ...]],
+    ]
+):
+    def guard(self, response: list[ResponseType]) -> TypeGuard[tuple[StringT, list[AnyStr]]]:
+        return isinstance(response[0], (str, bytes)) and isinstance(response[1], list)
+
+    def transform(
+        self,
+        response: list[ResponseType],
+    ) -> tuple[int, dict[AnyStr, AnyStr] | tuple[AnyStr, ...]]:
+        assert self.guard(response)
+        cursor, r = response
+        if self.options.get("novalues"):
+            return int(cursor), tuple(r)
+        else:
+            return int(cursor), flat_pairs_to_dict(r)
+
+
+class HRandFieldCallback(
+    ResponseCallback[
+        AnyStr | list[AnyStr] | None,
+        AnyStr | list[AnyStr] | list[list[AnyStr]] | None,
+        AnyStr | tuple[AnyStr, ...] | dict[AnyStr, AnyStr] | None,
+    ]
+):
+    def transform(
+        self,
+        response: AnyStr | list[AnyStr] | None,
+    ) -> AnyStr | tuple[AnyStr, ...] | dict[AnyStr, AnyStr] | None:
+        if not response:
+            return None
+        if self.options.get("count"):
+            assert isinstance(response, list)
+            if self.options.get("withvalues"):
+                return flat_pairs_to_dict(response)
+            else:
+                return tuple(response)
+        assert isinstance(response, (str, bytes))
+        return response
+
+    def transform_3(
+        self,
+        response: AnyStr | list[AnyStr] | list[list[AnyStr]] | None,
+    ) -> AnyStr | tuple[AnyStr, ...] | dict[AnyStr, AnyStr] | None:
+        if not response:
+            return None
+        if self.options.get("count"):
+            assert isinstance(response, list)
+            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))
+        return response
+
+
+class HGetAllCallback(ResponseCallback[list[AnyStr], dict[AnyStr, AnyStr], 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],
+    ) -> dict[AnyStr, AnyStr]:
+        return response

coredis/response/_callbacks/keys.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from coredis.exceptions import DataError, NoKeyError, RedisError
+from coredis.response._callbacks import DateTimeCallback, ResponseCallback
+from coredis.typing import (
+    AnyStr,
+    ResponseType,
+    StringT,
+    TypeGuard,
+)
+
+
+class SortCallback(
+    ResponseCallback[
+        int | list[AnyStr],
+        int | list[AnyStr],
+        int | tuple[AnyStr, ...],
+    ]
+):
+    def transform(
+        self,
+        response: int | list[AnyStr],
+    ) -> int | tuple[AnyStr, ...]:
+        if isinstance(response, list):
+            return tuple(response)
+        return response
+
+
+class ScanCallback(
+    ResponseCallback[list[ResponseType], list[ResponseType], tuple[int, tuple[AnyStr, ...]]]
+):
+    def guard(self, response: list[ResponseType]) -> TypeGuard[tuple[StringT, list[AnyStr]]]:
+        return isinstance(response[0], (str, bytes)) and isinstance(response[1], list)
+
+    def transform(
+        self,
+        response: list[ResponseType],
+    ) -> tuple[int, tuple[AnyStr, ...]]:
+        assert self.guard(response)
+        cursor, r = response
+        return int(cursor), tuple(r)
+
+
+class ExpiryCallback(DateTimeCallback):
+    def transform(
+        self,
+        response: int,
+    ) -> datetime:
+        if response > 0:
+            return super().transform(response)
+        else:
+            if response == -2:
+                raise NoKeyError()
+            elif response == -1:
+                raise DataError()
+            else:
+                raise RedisError()

coredis/response/_callbacks/module.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import cast
+
+from coredis.response._callbacks import ResponseCallback
+from coredis.response._utils import flat_pairs_to_dict
+from coredis.typing import (
+    AnyStr,
+    ResponsePrimitive,
+    ResponseType,
+)
+
+
+class ModuleInfoCallback(
+    ResponseCallback[
+        list[list[ResponseType]],
+        list[dict[AnyStr, ResponsePrimitive]],
+        tuple[dict[AnyStr, ResponsePrimitive], ...],
+    ]
+):
+    def transform(
+        self,
+        response: list[list[ResponseType]],
+    ) -> tuple[dict[AnyStr, ResponsePrimitive], ...]:
+        return tuple(
+            cast(dict[AnyStr, ResponsePrimitive], flat_pairs_to_dict(mod)) for mod in response
+        )
+
+    def transform_3(
+        self,
+        response: list[dict[AnyStr, ResponsePrimitive]],
+    ) -> tuple[dict[AnyStr, ResponsePrimitive], ...]:
+        return tuple(response)

coredis/response/_callbacks/script.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import cast
+
+from coredis._utils import EncodingInsensitiveDict
+from coredis.response._callbacks import ResponseCallback
+from coredis.response._utils import flat_pairs_to_dict
+from coredis.response.types import LibraryDefinition
+from coredis.typing import (
+    AnyStr,
+    Mapping,
+    RedisValueT,
+    ResponsePrimitive,
+    ResponseType,
+)
+
+
+class FunctionListCallback(
+    ResponseCallback[list[ResponseType], list[ResponseType], Mapping[AnyStr, LibraryDefinition]]
+):
+    def transform(
+        self,
+        response: list[ResponseType],
+    ) -> Mapping[AnyStr, LibraryDefinition]:
+        libraries = [
+            EncodingInsensitiveDict(flat_pairs_to_dict(cast(list[RedisValueT], library)))
+            for library in response
+        ]
+        transformed = EncodingInsensitiveDict()
+        for library in libraries:
+            lib_name = library["library_name"]
+            functions = EncodingInsensitiveDict({})
+            for function in library.get("functions", []):
+                function_definition = EncodingInsensitiveDict(flat_pairs_to_dict(function))
+                functions[function_definition["name"]] = function_definition
+                functions[function_definition["name"]]["flags"] = set(function_definition["flags"])
+            library["functions"] = functions
+            transformed[lib_name] = EncodingInsensitiveDict(
+                LibraryDefinition(
+                    name=library["library_name"],
+                    engine=library["engine"],
+                    functions=library["functions"],
+                    library_code=library.get("library_code", None),
+                )
+            )
+        return transformed
+
+
+class FunctionStatsCallback(
+    ResponseCallback[
+        list[ResponseType],
+        dict[
+            AnyStr,
+            AnyStr | dict[AnyStr, dict[AnyStr, ResponsePrimitive]] | None,
+        ],
+        dict[
+            AnyStr,
+            AnyStr | dict[AnyStr, dict[AnyStr, ResponsePrimitive]] | None,
+        ],
+    ]
+):
+    def transform(
+        self,
+        response: list[ResponseType],
+    ) -> 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")
+        engines = flat_pairs_to_dict(cast(list[AnyStr], transformed.pop(key)))
+        engines_transformed = {}
+        for engine, stats in engines.items():
+            engines_transformed[engine] = flat_pairs_to_dict(cast(list[AnyStr], stats))
+        transformed[key] = engines_transformed  # type: ignore
+        return cast(
+            dict[AnyStr, AnyStr | dict[AnyStr, dict[AnyStr, ResponsePrimitive]]],
+            transformed,
+        )
+
+    def transform_3(
+        self,
+        response: dict[
+            AnyStr,
+            AnyStr | dict[AnyStr, dict[AnyStr, ResponsePrimitive]] | None,
+        ],
+    ) -> dict[AnyStr, AnyStr | dict[AnyStr, dict[AnyStr, ResponsePrimitive]] | None]:
+        return response