antfly-sdk 0.0.2.dev2__py3-none-any.whl

antfly/client_generated/models/cluster_data_node_status.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ClusterDataNodeStatus")
+
+
+@_attrs_define
+class ClusterDataNodeStatus:
+    """
+    Attributes:
+        data_id (int):
+        node_id (int):
+        api_url (str | Unset):
+        raft_url (str | Unset):
+        role (str | Unset):
+        state (str | Unset):
+        health_class (str | Unset):
+        failure_domain (str | Unset):
+        live (bool | Unset):
+        drain_requested (bool | Unset):
+        capacity_bytes (int | Unset):
+        available_bytes (int | Unset):
+        lease_pressure (int | Unset):
+        read_load (int | Unset):
+        write_load (int | Unset):
+        active_backfills (int | Unset):
+    """
+
+    data_id: int
+    node_id: int
+    api_url: str | Unset = UNSET
+    raft_url: str | Unset = UNSET
+    role: str | Unset = UNSET
+    state: str | Unset = UNSET
+    health_class: str | Unset = UNSET
+    failure_domain: str | Unset = UNSET
+    live: bool | Unset = UNSET
+    drain_requested: bool | Unset = UNSET
+    capacity_bytes: int | Unset = UNSET
+    available_bytes: int | Unset = UNSET
+    lease_pressure: int | Unset = UNSET
+    read_load: int | Unset = UNSET
+    write_load: int | Unset = UNSET
+    active_backfills: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        data_id = self.data_id
+
+        node_id = self.node_id
+
+        api_url = self.api_url
+
+        raft_url = self.raft_url
+
+        role = self.role
+
+        state = self.state
+
+        health_class = self.health_class
+
+        failure_domain = self.failure_domain
+
+        live = self.live
+
+        drain_requested = self.drain_requested
+
+        capacity_bytes = self.capacity_bytes
+
+        available_bytes = self.available_bytes
+
+        lease_pressure = self.lease_pressure
+
+        read_load = self.read_load
+
+        write_load = self.write_load
+
+        active_backfills = self.active_backfills
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "data_id": data_id,
+                "node_id": node_id,
+            }
+        )
+        if api_url is not UNSET:
+            field_dict["api_url"] = api_url
+        if raft_url is not UNSET:
+            field_dict["raft_url"] = raft_url
+        if role is not UNSET:
+            field_dict["role"] = role
+        if state is not UNSET:
+            field_dict["state"] = state
+        if health_class is not UNSET:
+            field_dict["health_class"] = health_class
+        if failure_domain is not UNSET:
+            field_dict["failure_domain"] = failure_domain
+        if live is not UNSET:
+            field_dict["live"] = live
+        if drain_requested is not UNSET:
+            field_dict["drain_requested"] = drain_requested
+        if capacity_bytes is not UNSET:
+            field_dict["capacity_bytes"] = capacity_bytes
+        if available_bytes is not UNSET:
+            field_dict["available_bytes"] = available_bytes
+        if lease_pressure is not UNSET:
+            field_dict["lease_pressure"] = lease_pressure
+        if read_load is not UNSET:
+            field_dict["read_load"] = read_load
+        if write_load is not UNSET:
+            field_dict["write_load"] = write_load
+        if active_backfills is not UNSET:
+            field_dict["active_backfills"] = active_backfills
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        data_id = d.pop("data_id")
+
+        node_id = d.pop("node_id")
+
+        api_url = d.pop("api_url", UNSET)
+
+        raft_url = d.pop("raft_url", UNSET)
+
+        role = d.pop("role", UNSET)
+
+        state = d.pop("state", UNSET)
+
+        health_class = d.pop("health_class", UNSET)
+
+        failure_domain = d.pop("failure_domain", UNSET)
+
+        live = d.pop("live", UNSET)
+
+        drain_requested = d.pop("drain_requested", UNSET)
+
+        capacity_bytes = d.pop("capacity_bytes", UNSET)
+
+        available_bytes = d.pop("available_bytes", UNSET)
+
+        lease_pressure = d.pop("lease_pressure", UNSET)
+
+        read_load = d.pop("read_load", UNSET)
+
+        write_load = d.pop("write_load", UNSET)
+
+        active_backfills = d.pop("active_backfills", UNSET)
+
+        cluster_data_node_status = cls(
+            data_id=data_id,
+            node_id=node_id,
+            api_url=api_url,
+            raft_url=raft_url,
+            role=role,
+            state=state,
+            health_class=health_class,
+            failure_domain=failure_domain,
+            live=live,
+            drain_requested=drain_requested,
+            capacity_bytes=capacity_bytes,
+            available_bytes=available_bytes,
+            lease_pressure=lease_pressure,
+            read_load=read_load,
+            write_load=write_load,
+            active_backfills=active_backfills,
+        )
+
+        cluster_data_node_status.additional_properties = d
+        return cluster_data_node_status
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/cluster_data_range_status.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ClusterDataRangeStatus")
+
+
+@_attrs_define
+class ClusterDataRangeStatus:
+    """
+    Attributes:
+        group_id (int):
+        range_id (int):
+        table_id (int):
+        table_name (str | Unset):
+        start_key (str | Unset):
+        end_key (None | str | Unset):
+        doc_identity_shard_id (int | Unset):
+        doc_identity_range_id (int | Unset):
+        state (str | Unset):
+        leader_data_id (int | None | Unset):
+        voter_count (int | Unset):
+        doc_count (int | Unset):
+        disk_bytes (int | Unset):
+        empty (bool | Unset):
+    """
+
+    group_id: int
+    range_id: int
+    table_id: int
+    table_name: str | Unset = UNSET
+    start_key: str | Unset = UNSET
+    end_key: None | str | Unset = UNSET
+    doc_identity_shard_id: int | Unset = UNSET
+    doc_identity_range_id: int | Unset = UNSET
+    state: str | Unset = UNSET
+    leader_data_id: int | None | Unset = UNSET
+    voter_count: int | Unset = UNSET
+    doc_count: int | Unset = UNSET
+    disk_bytes: int | Unset = UNSET
+    empty: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        group_id = self.group_id
+
+        range_id = self.range_id
+
+        table_id = self.table_id
+
+        table_name = self.table_name
+
+        start_key = self.start_key
+
+        end_key: None | str | Unset
+        if isinstance(self.end_key, Unset):
+            end_key = UNSET
+        else:
+            end_key = self.end_key
+
+        doc_identity_shard_id = self.doc_identity_shard_id
+
+        doc_identity_range_id = self.doc_identity_range_id
+
+        state = self.state
+
+        leader_data_id: int | None | Unset
+        if isinstance(self.leader_data_id, Unset):
+            leader_data_id = UNSET
+        else:
+            leader_data_id = self.leader_data_id
+
+        voter_count = self.voter_count
+
+        doc_count = self.doc_count
+
+        disk_bytes = self.disk_bytes
+
+        empty = self.empty
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "group_id": group_id,
+                "range_id": range_id,
+                "table_id": table_id,
+            }
+        )
+        if table_name is not UNSET:
+            field_dict["table_name"] = table_name
+        if start_key is not UNSET:
+            field_dict["start_key"] = start_key
+        if end_key is not UNSET:
+            field_dict["end_key"] = end_key
+        if doc_identity_shard_id is not UNSET:
+            field_dict["doc_identity_shard_id"] = doc_identity_shard_id
+        if doc_identity_range_id is not UNSET:
+            field_dict["doc_identity_range_id"] = doc_identity_range_id
+        if state is not UNSET:
+            field_dict["state"] = state
+        if leader_data_id is not UNSET:
+            field_dict["leader_data_id"] = leader_data_id
+        if voter_count is not UNSET:
+            field_dict["voter_count"] = voter_count
+        if doc_count is not UNSET:
+            field_dict["doc_count"] = doc_count
+        if disk_bytes is not UNSET:
+            field_dict["disk_bytes"] = disk_bytes
+        if empty is not UNSET:
+            field_dict["empty"] = empty
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        group_id = d.pop("group_id")
+
+        range_id = d.pop("range_id")
+
+        table_id = d.pop("table_id")
+
+        table_name = d.pop("table_name", UNSET)
+
+        start_key = d.pop("start_key", UNSET)
+
+        def _parse_end_key(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        end_key = _parse_end_key(d.pop("end_key", UNSET))
+
+        doc_identity_shard_id = d.pop("doc_identity_shard_id", UNSET)
+
+        doc_identity_range_id = d.pop("doc_identity_range_id", UNSET)
+
+        state = d.pop("state", UNSET)
+
+        def _parse_leader_data_id(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        leader_data_id = _parse_leader_data_id(d.pop("leader_data_id", UNSET))
+
+        voter_count = d.pop("voter_count", UNSET)
+
+        doc_count = d.pop("doc_count", UNSET)
+
+        disk_bytes = d.pop("disk_bytes", UNSET)
+
+        empty = d.pop("empty", UNSET)
+
+        cluster_data_range_status = cls(
+            group_id=group_id,
+            range_id=range_id,
+            table_id=table_id,
+            table_name=table_name,
+            start_key=start_key,
+            end_key=end_key,
+            doc_identity_shard_id=doc_identity_shard_id,
+            doc_identity_range_id=doc_identity_range_id,
+            state=state,
+            leader_data_id=leader_data_id,
+            voter_count=voter_count,
+            doc_count=doc_count,
+            disk_bytes=disk_bytes,
+            empty=empty,
+        )
+
+        cluster_data_range_status.additional_properties = d
+        return cluster_data_range_status
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/cluster_data_replica_status.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ClusterDataReplicaStatus")
+
+
+@_attrs_define
+class ClusterDataReplicaStatus:
+    """
+    Attributes:
+        group_id (int):
+        data_id (int):
+        node_id (int):
+        replica_id (int):
+        peer_node_ids (list[int] | Unset):
+    """
+
+    group_id: int
+    data_id: int
+    node_id: int
+    replica_id: int
+    peer_node_ids: list[int] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        group_id = self.group_id
+
+        data_id = self.data_id
+
+        node_id = self.node_id
+
+        replica_id = self.replica_id
+
+        peer_node_ids: list[int] | Unset = UNSET
+        if not isinstance(self.peer_node_ids, Unset):
+            peer_node_ids = self.peer_node_ids
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "group_id": group_id,
+                "data_id": data_id,
+                "node_id": node_id,
+                "replica_id": replica_id,
+            }
+        )
+        if peer_node_ids is not UNSET:
+            field_dict["peer_node_ids"] = peer_node_ids
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        group_id = d.pop("group_id")
+
+        data_id = d.pop("data_id")
+
+        node_id = d.pop("node_id")
+
+        replica_id = d.pop("replica_id")
+
+        peer_node_ids = cast(list[int], d.pop("peer_node_ids", UNSET))
+
+        cluster_data_replica_status = cls(
+            group_id=group_id,
+            data_id=data_id,
+            node_id=node_id,
+            replica_id=replica_id,
+            peer_node_ids=peer_node_ids,
+        )
+
+        cluster_data_replica_status.additional_properties = d
+        return cluster_data_replica_status
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/cluster_data_status.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.cluster_data_group_status import ClusterDataGroupStatus
+    from ..models.cluster_data_node_status import ClusterDataNodeStatus
+    from ..models.cluster_data_range_status import ClusterDataRangeStatus
+    from ..models.cluster_data_replica_status import ClusterDataReplicaStatus
+
+
+T = TypeVar("T", bound="ClusterDataStatus")
+
+
+@_attrs_define
+class ClusterDataStatus:
+    """Typed Zig status view for table data topology and range placement.
+
+    Attributes:
+        nodes (list[ClusterDataNodeStatus] | Unset):
+        ranges (list[ClusterDataRangeStatus] | Unset):
+        replicas (list[ClusterDataReplicaStatus] | Unset):
+        groups (list[ClusterDataGroupStatus] | Unset):
+    """
+
+    nodes: list[ClusterDataNodeStatus] | Unset = UNSET
+    ranges: list[ClusterDataRangeStatus] | Unset = UNSET
+    replicas: list[ClusterDataReplicaStatus] | Unset = UNSET
+    groups: list[ClusterDataGroupStatus] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        nodes: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.nodes, Unset):
+            nodes = []
+            for nodes_item_data in self.nodes:
+                nodes_item = nodes_item_data.to_dict()
+                nodes.append(nodes_item)
+
+        ranges: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.ranges, Unset):
+            ranges = []
+            for ranges_item_data in self.ranges:
+                ranges_item = ranges_item_data.to_dict()
+                ranges.append(ranges_item)
+
+        replicas: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.replicas, Unset):
+            replicas = []
+            for replicas_item_data in self.replicas:
+                replicas_item = replicas_item_data.to_dict()
+                replicas.append(replicas_item)
+
+        groups: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.groups, Unset):
+            groups = []
+            for groups_item_data in self.groups:
+                groups_item = groups_item_data.to_dict()
+                groups.append(groups_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if nodes is not UNSET:
+            field_dict["nodes"] = nodes
+        if ranges is not UNSET:
+            field_dict["ranges"] = ranges
+        if replicas is not UNSET:
+            field_dict["replicas"] = replicas
+        if groups is not UNSET:
+            field_dict["groups"] = groups
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.cluster_data_group_status import ClusterDataGroupStatus
+        from ..models.cluster_data_node_status import ClusterDataNodeStatus
+        from ..models.cluster_data_range_status import ClusterDataRangeStatus
+        from ..models.cluster_data_replica_status import ClusterDataReplicaStatus
+
+        d = dict(src_dict)
+        _nodes = d.pop("nodes", UNSET)
+        nodes: list[ClusterDataNodeStatus] | Unset = UNSET
+        if _nodes is not UNSET:
+            nodes = []
+            for nodes_item_data in _nodes:
+                nodes_item = ClusterDataNodeStatus.from_dict(nodes_item_data)
+
+                nodes.append(nodes_item)
+
+        _ranges = d.pop("ranges", UNSET)
+        ranges: list[ClusterDataRangeStatus] | Unset = UNSET
+        if _ranges is not UNSET:
+            ranges = []
+            for ranges_item_data in _ranges:
+                ranges_item = ClusterDataRangeStatus.from_dict(ranges_item_data)
+
+                ranges.append(ranges_item)
+
+        _replicas = d.pop("replicas", UNSET)
+        replicas: list[ClusterDataReplicaStatus] | Unset = UNSET
+        if _replicas is not UNSET:
+            replicas = []
+            for replicas_item_data in _replicas:
+                replicas_item = ClusterDataReplicaStatus.from_dict(replicas_item_data)
+
+                replicas.append(replicas_item)
+
+        _groups = d.pop("groups", UNSET)
+        groups: list[ClusterDataGroupStatus] | Unset = UNSET
+        if _groups is not UNSET:
+            groups = []
+            for groups_item_data in _groups:
+                groups_item = ClusterDataGroupStatus.from_dict(groups_item_data)
+
+                groups.append(groups_item)
+
+        cluster_data_status = cls(
+            nodes=nodes,
+            ranges=ranges,
+            replicas=replicas,
+            groups=groups,
+        )
+
+        cluster_data_status.additional_properties = d
+        return cluster_data_status
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/cluster_health.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class ClusterHealth(str, Enum):
+    DEGRADED = "degraded"
+    ERROR = "error"
+    HEALTHY = "healthy"
+    UNHEALTHY = "unhealthy"
+    UNKNOWN = "unknown"
+
+    def __str__(self) -> str:
+        return str(self.value)