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

antfly/client_generated/models/classification_transformation_result.py

@@ -0,0 +1,158 @@
+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 ..models.query_strategy import QueryStrategy
+from ..models.route_type import RouteType
+from ..models.semantic_query_mode import SemanticQueryMode
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ClassificationTransformationResult")
+
+
+@_attrs_define
+class ClassificationTransformationResult:
+    """Query classification and transformation result combining all query enhancements including strategy selection and
+    semantic optimization
+
+        Attributes:
+            route_type (RouteType): Classification of query type: question (specific factual query) or search (exploratory
+                query)
+            strategy (QueryStrategy): Strategy for query transformation and retrieval:
+                - simple: Direct query with multi-phrase expansion. Best for straightforward factual queries.
+                - decompose: Break complex queries into sub-questions, retrieve for each. Best for multi-part questions.
+                - step_back: Generate broader background query first, then specific query. Best for questions needing context.
+                - hyde: Generate hypothetical answer document, embed that for retrieval. Best for abstract/conceptual questions.
+            semantic_mode (SemanticQueryMode): Mode for semantic query generation:
+                - rewrite: Transform query into expanded keywords/concepts optimized for vector search (Level 2 optimization)
+                - hypothetical: Generate a hypothetical answer that would appear in relevant documents (HyDE - Level 3
+                optimization)
+            improved_query (str): Clarified query with added context for answer generation (human-readable)
+            semantic_query (str): Optimized query for vector/semantic search. Content style depends on semantic_mode:
+                keywords for 'rewrite', hypothetical answer for 'hypothetical'
+            confidence (float): Classification confidence (0.0 to 1.0)
+            step_back_query (str | Unset): Broader background query for context (only present when strategy is 'step_back')
+            sub_questions (list[str] | Unset): Decomposed sub-questions (only present when strategy is 'decompose')
+            multi_phrases (list[str] | Unset): Alternative phrasings of the query for expanded retrieval coverage
+            reasoning (str | Unset): Pre-retrieval reasoning explaining query analysis and strategy selection (only present
+                when with_classification_reasoning is enabled)
+    """
+
+    route_type: RouteType
+    strategy: QueryStrategy
+    semantic_mode: SemanticQueryMode
+    improved_query: str
+    semantic_query: str
+    confidence: float
+    step_back_query: str | Unset = UNSET
+    sub_questions: list[str] | Unset = UNSET
+    multi_phrases: list[str] | Unset = UNSET
+    reasoning: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        route_type = self.route_type.value
+
+        strategy = self.strategy.value
+
+        semantic_mode = self.semantic_mode.value
+
+        improved_query = self.improved_query
+
+        semantic_query = self.semantic_query
+
+        confidence = self.confidence
+
+        step_back_query = self.step_back_query
+
+        sub_questions: list[str] | Unset = UNSET
+        if not isinstance(self.sub_questions, Unset):
+            sub_questions = self.sub_questions
+
+        multi_phrases: list[str] | Unset = UNSET
+        if not isinstance(self.multi_phrases, Unset):
+            multi_phrases = self.multi_phrases
+
+        reasoning = self.reasoning
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "route_type": route_type,
+                "strategy": strategy,
+                "semantic_mode": semantic_mode,
+                "improved_query": improved_query,
+                "semantic_query": semantic_query,
+                "confidence": confidence,
+            }
+        )
+        if step_back_query is not UNSET:
+            field_dict["step_back_query"] = step_back_query
+        if sub_questions is not UNSET:
+            field_dict["sub_questions"] = sub_questions
+        if multi_phrases is not UNSET:
+            field_dict["multi_phrases"] = multi_phrases
+        if reasoning is not UNSET:
+            field_dict["reasoning"] = reasoning
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        route_type = RouteType(d.pop("route_type"))
+
+        strategy = QueryStrategy(d.pop("strategy"))
+
+        semantic_mode = SemanticQueryMode(d.pop("semantic_mode"))
+
+        improved_query = d.pop("improved_query")
+
+        semantic_query = d.pop("semantic_query")
+
+        confidence = d.pop("confidence")
+
+        step_back_query = d.pop("step_back_query", UNSET)
+
+        sub_questions = cast(list[str], d.pop("sub_questions", UNSET))
+
+        multi_phrases = cast(list[str], d.pop("multi_phrases", UNSET))
+
+        reasoning = d.pop("reasoning", UNSET)
+
+        classification_transformation_result = cls(
+            route_type=route_type,
+            strategy=strategy,
+            semantic_mode=semantic_mode,
+            improved_query=improved_query,
+            semantic_query=semantic_query,
+            confidence=confidence,
+            step_back_query=step_back_query,
+            sub_questions=sub_questions,
+            multi_phrases=multi_phrases,
+            reasoning=reasoning,
+        )
+
+        classification_transformation_result.additional_properties = d
+        return classification_transformation_result
+
+    @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_backup_request.py

@@ -0,0 +1,113 @@
+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 ..models.cluster_backup_request_format import ClusterBackupRequestFormat
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ClusterBackupRequest")
+
+
+@_attrs_define
+class ClusterBackupRequest:
+    """
+    Attributes:
+        backup_id (str): Unique identifier for this backup. Used to reference the backup for restore operations.
+            Choose a meaningful name that includes date/version information.
+             Example: cluster-backup-2025-01-15.
+        location (str): Storage location for the backup. Supports multiple backends:
+            - Local filesystem: `file:///path/to/backup`
+            - Amazon S3: `s3://bucket-name/path/to/backup`
+
+            The backup includes all table data, indexes, and metadata.
+             Example: s3://mybucket/antfly-backups/cluster/2025-01-15.
+        format_ (ClusterBackupRequestFormat | Unset): Backup format to use:
+            - `native`: Engine-specific physical snapshot (fast backup and restore, same-backend only)
+            - `portable`: Cross-backend logical backup in AFB format (slower restore due to index rebuild, but can be
+            restored by any Antfly backend)
+
+            On restore, the format is auto-detected from file magic bytes.
+             Default: ClusterBackupRequestFormat.PORTABLE. Example: portable.
+        table_names (list[str] | Unset): Optional list of tables to backup. If omitted, all tables are backed up.
+             Example: ['users', 'products'].
+    """
+
+    backup_id: str
+    location: str
+    format_: ClusterBackupRequestFormat | Unset = ClusterBackupRequestFormat.PORTABLE
+    table_names: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        backup_id = self.backup_id
+
+        location = self.location
+
+        format_: str | Unset = UNSET
+        if not isinstance(self.format_, Unset):
+            format_ = self.format_.value
+
+        table_names: list[str] | Unset = UNSET
+        if not isinstance(self.table_names, Unset):
+            table_names = self.table_names
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "backup_id": backup_id,
+                "location": location,
+            }
+        )
+        if format_ is not UNSET:
+            field_dict["format"] = format_
+        if table_names is not UNSET:
+            field_dict["table_names"] = table_names
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        backup_id = d.pop("backup_id")
+
+        location = d.pop("location")
+
+        _format_ = d.pop("format", UNSET)
+        format_: ClusterBackupRequestFormat | Unset
+        if isinstance(_format_, Unset):
+            format_ = UNSET
+        else:
+            format_ = ClusterBackupRequestFormat(_format_)
+
+        table_names = cast(list[str], d.pop("table_names", UNSET))
+
+        cluster_backup_request = cls(
+            backup_id=backup_id,
+            location=location,
+            format_=format_,
+            table_names=table_names,
+        )
+
+        cluster_backup_request.additional_properties = d
+        return cluster_backup_request
+
+    @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_backup_request_format.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ClusterBackupRequestFormat(str, Enum):
+    NATIVE = "native"
+    PORTABLE = "portable"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/cluster_backup_response.py

@@ -0,0 +1,93 @@
+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 ..models.cluster_backup_response_status import ClusterBackupResponseStatus
+
+if TYPE_CHECKING:
+    from ..models.table_backup_status import TableBackupStatus
+
+
+T = TypeVar("T", bound="ClusterBackupResponse")
+
+
+@_attrs_define
+class ClusterBackupResponse:
+    """
+    Attributes:
+        backup_id (str): The backup identifier Example: cluster-backup-2025-01-15.
+        tables (list[TableBackupStatus]): Status of each table backup
+        status (ClusterBackupResponseStatus): Overall backup status Example: completed.
+    """
+
+    backup_id: str
+    tables: list[TableBackupStatus]
+    status: ClusterBackupResponseStatus
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        backup_id = self.backup_id
+
+        tables = []
+        for tables_item_data in self.tables:
+            tables_item = tables_item_data.to_dict()
+            tables.append(tables_item)
+
+        status = self.status.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "backup_id": backup_id,
+                "tables": tables,
+                "status": status,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.table_backup_status import TableBackupStatus
+
+        d = dict(src_dict)
+        backup_id = d.pop("backup_id")
+
+        tables = []
+        _tables = d.pop("tables")
+        for tables_item_data in _tables:
+            tables_item = TableBackupStatus.from_dict(tables_item_data)
+
+            tables.append(tables_item)
+
+        status = ClusterBackupResponseStatus(d.pop("status"))
+
+        cluster_backup_response = cls(
+            backup_id=backup_id,
+            tables=tables,
+            status=status,
+        )
+
+        cluster_backup_response.additional_properties = d
+        return cluster_backup_response
+
+    @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_backup_response_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ClusterBackupResponseStatus(str, Enum):
+    COMPLETED = "completed"
+    FAILED = "failed"
+    PARTIAL = "partial"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/cluster_data_group_status.py

@@ -0,0 +1,209 @@
+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="ClusterDataGroupStatus")
+
+
+@_attrs_define
+class ClusterDataGroupStatus:
+    """
+    Attributes:
+        group_id (int):
+        leader_known (bool | Unset):
+        leader_data_id (int | None | Unset):
+        voter_count_known (bool | Unset):
+        voter_count (int | Unset):
+        healthy_voter_reports (int | Unset):
+        joint_consensus (bool | Unset):
+        transition_pending (bool | Unset):
+        replay_required (bool | Unset):
+        replay_caught_up (bool | Unset):
+        cutover_ready (bool | Unset):
+        reads_ready_after_cutover (bool | Unset):
+        doc_identity_lifecycle (str | Unset):
+        doc_count (int | Unset):
+        disk_bytes (int | Unset):
+        empty (bool | Unset):
+    """
+
+    group_id: int
+    leader_known: bool | Unset = UNSET
+    leader_data_id: int | None | Unset = UNSET
+    voter_count_known: bool | Unset = UNSET
+    voter_count: int | Unset = UNSET
+    healthy_voter_reports: int | Unset = UNSET
+    joint_consensus: bool | Unset = UNSET
+    transition_pending: bool | Unset = UNSET
+    replay_required: bool | Unset = UNSET
+    replay_caught_up: bool | Unset = UNSET
+    cutover_ready: bool | Unset = UNSET
+    reads_ready_after_cutover: bool | Unset = UNSET
+    doc_identity_lifecycle: str | 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
+
+        leader_known = self.leader_known
+
+        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_known = self.voter_count_known
+
+        voter_count = self.voter_count
+
+        healthy_voter_reports = self.healthy_voter_reports
+
+        joint_consensus = self.joint_consensus
+
+        transition_pending = self.transition_pending
+
+        replay_required = self.replay_required
+
+        replay_caught_up = self.replay_caught_up
+
+        cutover_ready = self.cutover_ready
+
+        reads_ready_after_cutover = self.reads_ready_after_cutover
+
+        doc_identity_lifecycle = self.doc_identity_lifecycle
+
+        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,
+            }
+        )
+        if leader_known is not UNSET:
+            field_dict["leader_known"] = leader_known
+        if leader_data_id is not UNSET:
+            field_dict["leader_data_id"] = leader_data_id
+        if voter_count_known is not UNSET:
+            field_dict["voter_count_known"] = voter_count_known
+        if voter_count is not UNSET:
+            field_dict["voter_count"] = voter_count
+        if healthy_voter_reports is not UNSET:
+            field_dict["healthy_voter_reports"] = healthy_voter_reports
+        if joint_consensus is not UNSET:
+            field_dict["joint_consensus"] = joint_consensus
+        if transition_pending is not UNSET:
+            field_dict["transition_pending"] = transition_pending
+        if replay_required is not UNSET:
+            field_dict["replay_required"] = replay_required
+        if replay_caught_up is not UNSET:
+            field_dict["replay_caught_up"] = replay_caught_up
+        if cutover_ready is not UNSET:
+            field_dict["cutover_ready"] = cutover_ready
+        if reads_ready_after_cutover is not UNSET:
+            field_dict["reads_ready_after_cutover"] = reads_ready_after_cutover
+        if doc_identity_lifecycle is not UNSET:
+            field_dict["doc_identity_lifecycle"] = doc_identity_lifecycle
+        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")
+
+        leader_known = d.pop("leader_known", 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_known = d.pop("voter_count_known", UNSET)
+
+        voter_count = d.pop("voter_count", UNSET)
+
+        healthy_voter_reports = d.pop("healthy_voter_reports", UNSET)
+
+        joint_consensus = d.pop("joint_consensus", UNSET)
+
+        transition_pending = d.pop("transition_pending", UNSET)
+
+        replay_required = d.pop("replay_required", UNSET)
+
+        replay_caught_up = d.pop("replay_caught_up", UNSET)
+
+        cutover_ready = d.pop("cutover_ready", UNSET)
+
+        reads_ready_after_cutover = d.pop("reads_ready_after_cutover", UNSET)
+
+        doc_identity_lifecycle = d.pop("doc_identity_lifecycle", UNSET)
+
+        doc_count = d.pop("doc_count", UNSET)
+
+        disk_bytes = d.pop("disk_bytes", UNSET)
+
+        empty = d.pop("empty", UNSET)
+
+        cluster_data_group_status = cls(
+            group_id=group_id,
+            leader_known=leader_known,
+            leader_data_id=leader_data_id,
+            voter_count_known=voter_count_known,
+            voter_count=voter_count,
+            healthy_voter_reports=healthy_voter_reports,
+            joint_consensus=joint_consensus,
+            transition_pending=transition_pending,
+            replay_required=replay_required,
+            replay_caught_up=replay_caught_up,
+            cutover_ready=cutover_ready,
+            reads_ready_after_cutover=reads_ready_after_cutover,
+            doc_identity_lifecycle=doc_identity_lifecycle,
+            doc_count=doc_count,
+            disk_bytes=disk_bytes,
+            empty=empty,
+        )
+
+        cluster_data_group_status.additional_properties = d
+        return cluster_data_group_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