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

antfly/client_generated/models/sse_step_completed.py

@@ -0,0 +1,155 @@
+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.agent_step_kind import AgentStepKind
+from ..models.agent_step_status import AgentStepStatus
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.sse_step_completed_details import SSEStepCompletedDetails
+
+
+T = TypeVar("T", bound="SSEStepCompleted")
+
+
+@_attrs_define
+class SSEStepCompleted:
+    """A step in the shared bounded-agent execution trace
+
+    Attributes:
+        name (str): Stable step name used for correlation across JSON and SSE surfaces
+        action (str): What action was taken
+        id (str | Unset): Unique step ID for correlation and tracing
+        kind (AgentStepKind | Unset): Shared bounded-agent step category
+        status (AgentStepStatus | Unset): Outcome of a shared agent step
+        error_message (str | Unset): Error details when status is "error"
+        duration_ms (int | Unset): Server-side execution time in milliseconds
+        details (SSEStepCompletedDetails | Unset): Additional details about the step
+    """
+
+    name: str
+    action: str
+    id: str | Unset = UNSET
+    kind: AgentStepKind | Unset = UNSET
+    status: AgentStepStatus | Unset = UNSET
+    error_message: str | Unset = UNSET
+    duration_ms: int | Unset = UNSET
+    details: SSEStepCompletedDetails | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        action = self.action
+
+        id = self.id
+
+        kind: str | Unset = UNSET
+        if not isinstance(self.kind, Unset):
+            kind = self.kind.value
+
+        status: str | Unset = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.value
+
+        error_message = self.error_message
+
+        duration_ms = self.duration_ms
+
+        details: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.details, Unset):
+            details = self.details.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "action": action,
+            }
+        )
+        if id is not UNSET:
+            field_dict["id"] = id
+        if kind is not UNSET:
+            field_dict["kind"] = kind
+        if status is not UNSET:
+            field_dict["status"] = status
+        if error_message is not UNSET:
+            field_dict["error_message"] = error_message
+        if duration_ms is not UNSET:
+            field_dict["duration_ms"] = duration_ms
+        if details is not UNSET:
+            field_dict["details"] = details
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.sse_step_completed_details import SSEStepCompletedDetails
+
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        action = d.pop("action")
+
+        id = d.pop("id", UNSET)
+
+        _kind = d.pop("kind", UNSET)
+        kind: AgentStepKind | Unset
+        if isinstance(_kind, Unset):
+            kind = UNSET
+        else:
+            kind = AgentStepKind(_kind)
+
+        _status = d.pop("status", UNSET)
+        status: AgentStepStatus | Unset
+        if isinstance(_status, Unset):
+            status = UNSET
+        else:
+            status = AgentStepStatus(_status)
+
+        error_message = d.pop("error_message", UNSET)
+
+        duration_ms = d.pop("duration_ms", UNSET)
+
+        _details = d.pop("details", UNSET)
+        details: SSEStepCompletedDetails | Unset
+        if isinstance(_details, Unset):
+            details = UNSET
+        else:
+            details = SSEStepCompletedDetails.from_dict(_details)
+
+        sse_step_completed = cls(
+            name=name,
+            action=action,
+            id=id,
+            kind=kind,
+            status=status,
+            error_message=error_message,
+            duration_ms=duration_ms,
+            details=details,
+        )
+
+        sse_step_completed.additional_properties = d
+        return sse_step_completed
+
+    @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/sse_step_completed_details.py

@@ -0,0 +1,47 @@
+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
+
+T = TypeVar("T", bound="SSEStepCompletedDetails")
+
+
+@_attrs_define
+class SSEStepCompletedDetails:
+    """Additional details about the step"""
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        sse_step_completed_details = cls()
+
+        sse_step_completed_details.additional_properties = d
+        return sse_step_completed_details
+
+    @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/sse_step_progress.py

@@ -0,0 +1,64 @@
+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
+
+T = TypeVar("T", bound="SSEStepProgress")
+
+
+@_attrs_define
+class SSEStepProgress:
+    """Emitted to report progress within a running step. The `name` field
+    identifies which step this progress belongs to. Additional properties
+    vary by step type (e.g., tree_search includes depth, num_nodes, sufficient, etc.).
+
+        Attributes:
+            name (str): Name of the step this progress belongs to Example: tree_search.
+    """
+
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        sse_step_progress = cls(
+            name=name,
+        )
+
+        sse_step_progress.additional_properties = d
+        return sse_step_progress
+
+    @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/sse_step_started.py

@@ -0,0 +1,98 @@
+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 ..models.agent_step_kind import AgentStepKind
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SSEStepStarted")
+
+
+@_attrs_define
+class SSEStepStarted:
+    """Emitted when a pipeline step begins execution
+
+    Attributes:
+        id (str): Unique step ID for correlating with step_completed Example: step_cr3ig20h5tbs73e3ahrg.
+        name (str): Stable step name used for correlation across JSON and SSE surfaces
+        action (str): Human-readable description of the action being taken Example: Searching for OAuth configuration in
+            doc_embeddings index.
+        kind (AgentStepKind | Unset): Shared bounded-agent step category
+    """
+
+    id: str
+    name: str
+    action: str
+    kind: AgentStepKind | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        name = self.name
+
+        action = self.action
+
+        kind: str | Unset = UNSET
+        if not isinstance(self.kind, Unset):
+            kind = self.kind.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+                "action": action,
+            }
+        )
+        if kind is not UNSET:
+            field_dict["kind"] = kind
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        name = d.pop("name")
+
+        action = d.pop("action")
+
+        _kind = d.pop("kind", UNSET)
+        kind: AgentStepKind | Unset
+        if isinstance(_kind, Unset):
+            kind = UNSET
+        else:
+            kind = AgentStepKind(_kind)
+
+        sse_step_started = cls(
+            id=id,
+            name=name,
+            action=action,
+            kind=kind,
+        )
+
+        sse_step_started.additional_properties = d
+        return sse_step_started
+
+    @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/sse_tool_mode.py

@@ -0,0 +1,74 @@
+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 ..models.sse_tool_mode_mode import SSEToolModeMode
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="SSEToolMode")
+
+
+@_attrs_define
+class SSEToolMode:
+    """Emitted when the agent selects a tool-calling mode
+
+    Attributes:
+        mode (SSEToolModeMode): Tool calling mode selected
+        tools_count (int | Unset): Number of tools available (present for native mode)
+    """
+
+    mode: SSEToolModeMode
+    tools_count: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        mode = self.mode.value
+
+        tools_count = self.tools_count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "mode": mode,
+            }
+        )
+        if tools_count is not UNSET:
+            field_dict["tools_count"] = tools_count
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        mode = SSEToolModeMode(d.pop("mode"))
+
+        tools_count = d.pop("tools_count", UNSET)
+
+        sse_tool_mode = cls(
+            mode=mode,
+            tools_count=tools_count,
+        )
+
+        sse_tool_mode.additional_properties = d
+        return sse_tool_mode
+
+    @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/sse_tool_mode_mode.py

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

antfly/client_generated/models/storage_status.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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.lsm_storage_status import LsmStorageStatus
+
+
+T = TypeVar("T", bound="StorageStatus")
+
+
+@_attrs_define
+class StorageStatus:
+    """
+    Attributes:
+        disk_usage (int | Unset): Disk usage in bytes.
+        empty (bool | Unset): Whether the table has received data.
+        lsm (LsmStorageStatus | Unset): Compact LSM backend operational status. Detailed low-level counters are
+            available through metrics.
+    """
+
+    disk_usage: int | Unset = UNSET
+    empty: bool | Unset = UNSET
+    lsm: LsmStorageStatus | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        disk_usage = self.disk_usage
+
+        empty = self.empty
+
+        lsm: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.lsm, Unset):
+            lsm = self.lsm.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if disk_usage is not UNSET:
+            field_dict["disk_usage"] = disk_usage
+        if empty is not UNSET:
+            field_dict["empty"] = empty
+        if lsm is not UNSET:
+            field_dict["lsm"] = lsm
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.lsm_storage_status import LsmStorageStatus
+
+        d = dict(src_dict)
+        disk_usage = d.pop("disk_usage", UNSET)
+
+        empty = d.pop("empty", UNSET)
+
+        _lsm = d.pop("lsm", UNSET)
+        lsm: LsmStorageStatus | Unset
+        if isinstance(_lsm, Unset):
+            lsm = UNSET
+        else:
+            lsm = LsmStorageStatus.from_dict(_lsm)
+
+        storage_status = cls(
+            disk_usage=disk_usage,
+            empty=empty,
+            lsm=lsm,
+        )
+
+        storage_status.additional_properties = d
+        return storage_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/success_message.py

@@ -0,0 +1,61 @@
+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="SuccessMessage")
+
+
+@_attrs_define
+class SuccessMessage:
+    """
+    Attributes:
+        message (str | Unset):  Example: Operation completed successfully.
+    """
+
+    message: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        message = self.message
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if message is not UNSET:
+            field_dict["message"] = message
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        message = d.pop("message", UNSET)
+
+        success_message = cls(
+            message=message,
+        )
+
+        success_message.additional_properties = d
+        return success_message
+
+    @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/sync_level.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class SyncLevel(str, Enum):
+    AKNN = "aknn"
+    ENRICHMENTS = "enrichments"
+    FULL_INDEX = "full_index"
+    FULL_TEXT = "full_text"
+    PROPOSE = "propose"
+    WRITE = "write"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/table_backup_status.py

@@ -0,0 +1,81 @@
+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 ..models.table_backup_status_status import TableBackupStatusStatus
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TableBackupStatus")
+
+
+@_attrs_define
+class TableBackupStatus:
+    """
+    Attributes:
+        name (str): Table name Example: users.
+        status (TableBackupStatusStatus): Backup status for this table Example: completed.
+        error (str | Unset): Error message if backup failed
+    """
+
+    name: str
+    status: TableBackupStatusStatus
+    error: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        status = self.status.value
+
+        error = self.error
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "status": status,
+            }
+        )
+        if error is not UNSET:
+            field_dict["error"] = error
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        status = TableBackupStatusStatus(d.pop("status"))
+
+        error = d.pop("error", UNSET)
+
+        table_backup_status = cls(
+            name=name,
+            status=status,
+            error=error,
+        )
+
+        table_backup_status.additional_properties = d
+        return table_backup_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