coredis 5.2.0__cp314-cp314t-macosx_10_13_x86_64.whl

coredis/response/_callbacks/sentinel.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from typing import cast
+
+from coredis._utils import EncodingInsensitiveDict, nativestr
+from coredis.response._callbacks import ResponseCallback
+from coredis.response._callbacks.server import InfoCallback
+from coredis.typing import (
+    AnyStr,
+    ResponsePrimitive,
+    ResponseType,
+)
+
+SENTINEL_STATE_INT_FIELDS = {
+    "can-failover-its-master",
+    "config-epoch",
+    "down-after-milliseconds",
+    "failover-timeout",
+    "info-refresh",
+    "last-hello-message",
+    "last-ok-ping-reply",
+    "last-ping-reply",
+    "last-ping-sent",
+    "master-link-down-time",
+    "master-port",
+    "num-other-sentinels",
+    "num-slaves",
+    "o-down-time",
+    "pending-commands",
+    "parallel-syncs",
+    "port",
+    "quorum",
+    "role-reported-time",
+    "s-down-time",
+    "slave-priority",
+    "slave-repl-offset",
+    "voted-leader-epoch",
+}
+
+
+def sentinel_state_typed(
+    response: list[str],
+) -> EncodingInsensitiveDict[str, str | int | bool]:
+    it = iter(response)
+    result: EncodingInsensitiveDict[str, str | int | bool] = EncodingInsensitiveDict()
+
+    for key, value in zip(it, it):
+        if key in SENTINEL_STATE_INT_FIELDS:
+            value = int(value)
+        result[key] = value
+
+    return result
+
+
+def add_flags(
+    result: EncodingInsensitiveDict[str, int | str | bool],
+) -> EncodingInsensitiveDict[str, int | str | bool]:
+    flags = set(nativestr(result["flags"]).split(","))
+    for name, flag in (
+        ("is_master", "master"),
+        ("is_slave", "slave"),
+        ("is_sdown", "s_down"),
+        ("is_odown", "o_down"),
+        ("is_sentinel", "sentinel"),
+        ("is_disconnected", "disconnected"),
+        ("is_master_down", "master_down"),
+    ):
+        result[name] = flag in flags
+    return result
+
+
+def parse_sentinel_state(
+    item: list[ResponsePrimitive],
+) -> EncodingInsensitiveDict[str, int | str | bool]:
+    result = sentinel_state_typed([nativestr(k) for k in item])
+    result = add_flags(result)
+    return result
+
+
+class PrimaryCallback(
+    ResponseCallback[
+        ResponseType,
+        dict[ResponsePrimitive, ResponsePrimitive],
+        dict[str, ResponsePrimitive],
+    ]
+):
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> dict[str, ResponsePrimitive]:
+        return parse_sentinel_state(cast(list[ResponsePrimitive], response)).stringify_keys()
+
+    def transform_3(
+        self,
+        response: dict[ResponsePrimitive, ResponsePrimitive],
+    ) -> dict[str, ResponsePrimitive]:
+        return add_flags(EncodingInsensitiveDict(response)).stringify_keys()
+
+
+class PrimariesCallback(
+    ResponseCallback[
+        list[ResponseType],
+        list[ResponseType],
+        dict[str, dict[str, ResponsePrimitive]],
+    ]
+):
+    def transform(
+        self,
+        response: list[ResponseType] | dict[ResponsePrimitive, ResponsePrimitive],
+    ) -> dict[str, dict[str, ResponsePrimitive]]:
+        result: dict[str, dict[str, ResponseType]] = {}
+
+        for item in response:
+            state = PrimaryCallback()(item)
+            result[str(state["name"])] = state
+
+        return result
+
+    def transform_3(
+        self,
+        response: list[ResponseType],
+    ) -> dict[str, dict[str, ResponsePrimitive]]:
+        states: dict[str, dict[str, ResponsePrimitive]] = {}
+        for state in response:
+            state = add_flags(EncodingInsensitiveDict(state)).stringify_keys()
+            states[nativestr(state["name"])] = state
+        return states
+
+
+class SentinelsStateCallback(
+    ResponseCallback[
+        list[ResponseType],
+        list[ResponseType],
+        tuple[dict[str, ResponsePrimitive], ...],
+    ]
+):
+    def transform(
+        self,
+        response: list[ResponseType],
+    ) -> tuple[dict[str, ResponsePrimitive], ...]:
+        return tuple(
+            parse_sentinel_state([nativestr(i) for i in item]).stringify_keys() for item in response
+        )
+
+    def transform_3(
+        self,
+        response: list[ResponseType],
+    ) -> tuple[dict[str, ResponsePrimitive], ...]:
+        return tuple(
+            add_flags(EncodingInsensitiveDict(state)).stringify_keys() for state in response
+        )
+
+
+class GetPrimaryCallback(
+    ResponseCallback[
+        list[ResponsePrimitive],
+        list[ResponsePrimitive],
+        tuple[str, int] | None,
+    ]
+):
+    def transform(
+        self,
+        response: list[ResponsePrimitive],
+    ) -> tuple[str, int] | None:
+        return nativestr(response[0]), int(response[1]) if response else None
+
+
+class SentinelInfoCallback(
+    ResponseCallback[
+        list[ResponseType],
+        list[ResponseType],
+        dict[AnyStr, dict[int, dict[str, ResponsePrimitive]]],
+    ]
+):
+    def transform(
+        self,
+        response: list[ResponseType],
+    ) -> dict[AnyStr, dict[int, dict[str, ResponsePrimitive]]]:
+        return {response[0]: {r[0]: InfoCallback()(r[1]) for r in response[1]}}

coredis/response/_callbacks/server.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import datetime
+from typing import Any
+
+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 ClientInfo, RoleInfo, SlowLogInfo
+from coredis.typing import (
+    AnyStr,
+    ClassVar,
+    RedisValueT,
+    ResponsePrimitive,
+    ResponseType,
+    StringT,
+)
+
+
+class TimeCallback(ResponseCallback[list[AnyStr], list[AnyStr], 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
+        )
+
+
+class SlowlogCallback(ResponseCallback[ResponseType, ResponseType, tuple[SlowLogInfo, ...]]):
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> tuple[SlowLogInfo, ...]:
+        return tuple(
+            SlowLogInfo(
+                id=item[0],
+                start_time=int(item[1]),
+                duration=int(item[2]),
+                command=item[3],
+                client_addr=item[4],
+                client_name=item[5],
+            )
+            for item in response
+        )
+
+
+class ClientInfoCallback(ResponseCallback[ResponseType, ResponseType, ClientInfo]):
+    INT_FIELDS: ClassVar = {
+        "id",
+        "fd",
+        "age",
+        "idle",
+        "db",
+        "sub",
+        "psub",
+        "multi",
+        "qbuf-free",
+        "argv-mem",
+        "multi-mem",
+        "obl",
+        "oll",
+        "omem",
+        "tot-mem",
+        "redir",
+    }
+
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> ClientInfo:
+        decoded_response = nativestr(response)
+        pairs = [pair.split("=", 1) for pair in decoded_response.strip().split(" ")]
+
+        info: ClientInfo = {}  # type: ignore
+        for k, v in pairs:
+            if k in ClientInfoCallback.INT_FIELDS:
+                info[k] = int(v)  # type: ignore
+            else:
+                info[k] = v  # type: ignore
+        return info
+
+
+class ClientListCallback(ResponseCallback[ResponseType, ResponseType, 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,
+    ) -> dict[str, str | int]:
+        # The 'type' of the object is the first item in the response, but isn't
+        # prefixed with a name
+
+        response = nativestr(response)
+        response = "type:" + response
+        parsed: dict[str, str | int] = {}
+        parsed.update(dict([kv.split(":") for kv in response.split()]))
+
+        # parse some expected int values from the string response
+        # note: this cmd isn't spec'd so these may not appear in all redis versions
+
+        for field in DebugCallback.INT_FIELDS:
+            if field in parsed:
+                parsed[field] = int(parsed[field])
+
+        return parsed
+
+
+class InfoCallback(
+    ResponseCallback[
+        StringT,
+        StringT,
+        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] = {}
+        response = nativestr(response)
+
+        def get_value(value: str) -> ResponseType:
+            if "," not in value or "=" not in value:
+                try:
+                    if "." in value:
+                        return float(value)
+                    else:
+                        return int(value)
+                except ValueError:
+                    return value
+            else:
+                sub_dict: dict[ResponsePrimitive, ResponseType] = {}
+
+                for item in value.split(","):
+                    k, v = item.rsplit("=", 1)
+                    sub_dict[k] = get_value(v)
+
+                return sub_dict
+
+        cur_info = {}
+        header = None
+        for line in response.splitlines():
+            if line and not line.startswith("#"):
+                if line.find(":") != -1:
+                    key, value = line.split(":", 1)
+                    if key in cur_info:
+                        if not isinstance(cur_info[key], list):
+                            cur_info[key] = [cur_info[key]]
+                        cur_info[key].append(get_value(value))
+                    else:
+                        cur_info[key] = get_value(value)
+                else:
+                    # if the line isn't splittable, append it to the "__raw__" key
+                    cur_info.setdefault("__raw__", []).append(line)
+            elif line:
+                if cur_info and header:
+                    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 self.options.get("nested"):
+                info[header] = cur_info
+            else:
+                info.update(cur_info)
+        return info
+
+
+class RoleCallback(ResponseCallback[ResponseType, ResponseType, RoleInfo]):
+    def transform(
+        self,
+        response: ResponseType,
+    ) -> RoleInfo:
+        role = nativestr(response[0])
+
+        def _parse_master(response: Any) -> Any:
+            offset, replicas = response[1:]
+            res: dict[str, Any] = {"role": role, "offset": offset, "slaves": []}
+
+            for replica in replicas:
+                host, port, offset = replica
+                res["slaves"].append({"host": host, "port": int(port), "offset": int(offset)})
+
+            return res
+
+        def _parse_replica(response: Any) -> Any:
+            host, port, status, offset = response[1:]
+
+            return dict(
+                role=role,
+                status=status,
+                offset=offset,
+            )
+
+        def _parse_sentinel(response: Any) -> Any:
+            return {"role": role, "masters": response[1]}
+
+        parser = {
+            "master": _parse_master,
+            "slave": _parse_replica,
+            "sentinel": _parse_sentinel,
+        }[role]
+        return RoleInfo(**parser(response))  # type: ignore
+
+
+class LatencyHistogramCallback(
+    ResponseCallback[ResponseType, ResponseType, dict[AnyStr, dict[AnyStr, RedisValueT]]]
+):
+    def transform(
+        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
+
+
+class LatencyCallback(
+    ResponseCallback[ResponseType, ResponseType, dict[AnyStr, tuple[int, int, int]]]
+):
+    def transform(
+        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

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import cast
+
+from coredis.response._callbacks import ResponseCallback
+from coredis.typing import (
+    AnyStr,
+    Iterable,
+    ResponsePrimitive,
+    ResponseType,
+)
+
+
+class SScanCallback(
+    ResponseCallback[list[ResponseType], list[ResponseType], tuple[int, set[AnyStr]]]
+):
+    def transform(
+        self,
+        response: list[ResponseType],
+    ) -> tuple[int, set[AnyStr]]:
+        cursor, r = response
+        assert isinstance(cursor, (bytes, str)) and isinstance(r, Iterable)
+        return int(cursor), set(cast(Iterable[AnyStr], r))
+
+
+class ItemOrSetCallback(
+    ResponseCallback[
+        AnyStr | list[ResponsePrimitive] | set[ResponsePrimitive],
+        AnyStr | set[ResponsePrimitive],
+        AnyStr | set[AnyStr],
+    ]
+):
+    def transform(
+        self,
+        response: AnyStr | list[ResponsePrimitive] | set[ResponsePrimitive],
+    ) -> AnyStr | set[AnyStr]:
+        if self.options.get("count"):
+            if isinstance(response, set):
+                return cast(set[AnyStr], response)
+            if isinstance(response, list):
+                return cast(set[AnyStr], set(response) if response else set())
+            raise ValueError(f"Unable to map {response!r} to set")
+        else:
+            return cast(AnyStr, response)

coredis/response/_callbacks/sorted_set.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+from typing import SupportsFloat, cast
+
+from coredis.response._callbacks import ResponseCallback
+from coredis.response.types import ScoredMember, ScoredMembers
+from coredis.typing import (
+    AnyStr,
+    Generic,
+    ResponsePrimitive,
+    ResponseType,
+)
+
+
+class ZRankCallback(
+    ResponseCallback[
+        int | list[ResponsePrimitive] | None,
+        int | list[ResponsePrimitive] | None,
+        int | tuple[int, float] | None,
+    ],
+):
+    def transform(
+        self,
+        response: int | list[ResponsePrimitive] | None,
+    ) -> int | tuple[int, float] | None:
+        if self.options.get("withscore"):
+            return (response[0], float(response[1])) if response else None
+        else:
+            return cast(int | None, response)
+
+    def transform_3(
+        self,
+        response: int | list[ResponsePrimitive] | None,
+    ) -> int | tuple[int, float] | None:
+        if self.options.get("withscore"):
+            return (response[0], response[1]) if response else None
+        else:
+            return cast(int | None, response)
+
+
+class ZMembersOrScoredMembers(
+    ResponseCallback[
+        list[AnyStr | list[ResponsePrimitive]],
+        list[AnyStr | list[ResponsePrimitive]],
+        tuple[AnyStr | ScoredMember, ...],
+    ],
+):
+    def transform(
+        self,
+        response: list[AnyStr | list[ResponsePrimitive]],
+    ) -> tuple[AnyStr | ScoredMember, ...]:
+        if not response:
+            return ()
+        elif self.options.get("withscores"):
+            it = iter(cast(list[AnyStr], response))
+            return tuple(ScoredMember(*v) for v in zip(it, map(float, it)))
+        else:
+            return cast(tuple[AnyStr, ...], tuple(response))
+
+    def transform_3(
+        self,
+        response: list[AnyStr | list[ResponsePrimitive]],
+    ) -> tuple[AnyStr | ScoredMember, ...]:
+        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))
+
+
+class ZSetScorePairCallback(
+    ResponseCallback[
+        list[ResponsePrimitive] | None,
+        list[ResponsePrimitive | list[ResponsePrimitive]] | None,
+        ScoredMember | ScoredMembers | None,
+    ],
+    Generic[AnyStr],
+):
+    def transform(
+        self,
+        response: list[ResponsePrimitive] | None,
+    ) -> ScoredMember | ScoredMembers | None:
+        if not response:
+            return None
+
+        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)
+        return tuple(ScoredMember(*v) for v in zip(it, map(float, it)))
+
+    def transform_3(
+        self,
+        response: list[ResponsePrimitive | list[ResponsePrimitive]] | None,
+    ) -> ScoredMember | ScoredMembers | None:
+        if not response:
+            return None
+
+        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))
+
+
+class ZMPopCallback(
+    ResponseCallback[
+        list[ResponseType] | None,
+        list[ResponseType] | None,
+        tuple[AnyStr, ScoredMembers] | None,
+    ],
+    Generic[AnyStr],
+):
+    def transform(
+        self,
+        response: list[ResponseType] | None,
+    ) -> tuple[AnyStr, ScoredMembers] | None:
+        r = cast(tuple[AnyStr, list[tuple[AnyStr, int]]], response)
+        if r:
+            return r[0], tuple(ScoredMember(v[0], float(v[1])) for v in r[1])
+
+        return None
+
+
+class ZMScoreCallback(
+    ResponseCallback[list[ResponsePrimitive], list[ResponsePrimitive], tuple[float | None, ...]]
+):
+    def transform(
+        self,
+        response: list[ResponsePrimitive],
+    ) -> tuple[float | None, ...]:
+        return tuple(score if score is None else float(score) for score in response)
+
+
+class ZScanCallback(
+    ResponseCallback[list[ResponseType], list[ResponseType], tuple[int, ScoredMembers]],
+    Generic[AnyStr],
+):
+    def transform(
+        self,
+        response: list[ResponseType],
+    ) -> tuple[int, ScoredMembers]:
+        cursor, r = cast(tuple[int, list[AnyStr]], response)
+        it = iter(r)
+        return int(cursor), tuple(
+            ScoredMember(*cast(tuple[AnyStr, float], v)) for v in zip(it, map(float, it))
+        )
+
+
+class ZRandMemberCallback(
+    ResponseCallback[
+        AnyStr | list[ResponsePrimitive] | None,
+        AnyStr | list[list[ResponsePrimitive]] | list[ResponsePrimitive] | None,
+        AnyStr | tuple[AnyStr, ...] | ScoredMembers | None,
+    ]
+):
+    def transform(
+        self,
+        response: AnyStr | list[ResponsePrimitive] | None,
+    ) -> AnyStr | tuple[AnyStr, ...] | ScoredMembers | None:
+        if not (response and self.options.get("withscores")):
+            return tuple(response) if isinstance(response, list) else response
+
+        it = iter(response)
+        return tuple(ScoredMember(*v) for v in zip(it, map(float, it)))
+
+    def transform_3(
+        self,
+        response: AnyStr | list[list[ResponsePrimitive]] | list[ResponsePrimitive] | None,
+    ) -> AnyStr | tuple[AnyStr, ...] | ScoredMembers | None:
+        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)
+
+
+class BZPopCallback(
+    ResponseCallback[
+        list[ResponsePrimitive] | None,
+        list[ResponsePrimitive] | None,
+        tuple[AnyStr, AnyStr, float] | None,
+    ]
+):
+    def transform(
+        self,
+        response: list[ResponsePrimitive] | None,
+    ) -> tuple[AnyStr, AnyStr, float] | None:
+        if response:
+            return response[0], response[1], float(response[2])
+        return None
+
+
+class ZAddCallback(ResponseCallback[ResponsePrimitive, int | float, int | float]):
+    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,
+    ) -> int | float:
+        return response