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

antfly/client_generated/models/graph_result_node.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.edge import Edge
+    from ..models.graph_result_node_document import GraphResultNodeDocument
+    from ..models.path_edge import PathEdge
+
+
+T = TypeVar("T", bound="GraphResultNode")
+
+
+@_attrs_define
+class GraphResultNode:
+    """A node in graph query results
+
+    Attributes:
+        key (str): Document key
+        depth (int | Unset): Distance from start node
+        distance (float | Unset): Weighted distance
+        document (GraphResultNodeDocument | Unset): Full document (if include_documents=true)
+        path (list[str] | Unset): Keys in path from start to this node
+        path_edges (list[PathEdge] | Unset): Edges in path from start to this node
+        provenance (list[str] | Unset): Algebraic provenance labels folded into this result, when requested by an
+            algebraic graph executor
+        edges (list[Edge] | Unset): Connected edges (when include_edges=true)
+    """
+
+    key: str
+    depth: int | Unset = UNSET
+    distance: float | Unset = UNSET
+    document: GraphResultNodeDocument | Unset = UNSET
+    path: list[str] | Unset = UNSET
+    path_edges: list[PathEdge] | Unset = UNSET
+    provenance: list[str] | Unset = UNSET
+    edges: list[Edge] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        key = self.key
+
+        depth = self.depth
+
+        distance = self.distance
+
+        document: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.document, Unset):
+            document = self.document.to_dict()
+
+        path: list[str] | Unset = UNSET
+        if not isinstance(self.path, Unset):
+            path = self.path
+
+        path_edges: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.path_edges, Unset):
+            path_edges = []
+            for path_edges_item_data in self.path_edges:
+                path_edges_item = path_edges_item_data.to_dict()
+                path_edges.append(path_edges_item)
+
+        provenance: list[str] | Unset = UNSET
+        if not isinstance(self.provenance, Unset):
+            provenance = self.provenance
+
+        edges: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.edges, Unset):
+            edges = []
+            for edges_item_data in self.edges:
+                edges_item = edges_item_data.to_dict()
+                edges.append(edges_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "key": key,
+            }
+        )
+        if depth is not UNSET:
+            field_dict["depth"] = depth
+        if distance is not UNSET:
+            field_dict["distance"] = distance
+        if document is not UNSET:
+            field_dict["document"] = document
+        if path is not UNSET:
+            field_dict["path"] = path
+        if path_edges is not UNSET:
+            field_dict["path_edges"] = path_edges
+        if provenance is not UNSET:
+            field_dict["provenance"] = provenance
+        if edges is not UNSET:
+            field_dict["edges"] = edges
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.edge import Edge
+        from ..models.graph_result_node_document import GraphResultNodeDocument
+        from ..models.path_edge import PathEdge
+
+        d = dict(src_dict)
+        key = d.pop("key")
+
+        depth = d.pop("depth", UNSET)
+
+        distance = d.pop("distance", UNSET)
+
+        _document = d.pop("document", UNSET)
+        document: GraphResultNodeDocument | Unset
+        if isinstance(_document, Unset):
+            document = UNSET
+        else:
+            document = GraphResultNodeDocument.from_dict(_document)
+
+        path = cast(list[str], d.pop("path", UNSET))
+
+        _path_edges = d.pop("path_edges", UNSET)
+        path_edges: list[PathEdge] | Unset = UNSET
+        if _path_edges is not UNSET:
+            path_edges = []
+            for path_edges_item_data in _path_edges:
+                path_edges_item = PathEdge.from_dict(path_edges_item_data)
+
+                path_edges.append(path_edges_item)
+
+        provenance = cast(list[str], d.pop("provenance", UNSET))
+
+        _edges = d.pop("edges", UNSET)
+        edges: list[Edge] | Unset = UNSET
+        if _edges is not UNSET:
+            edges = []
+            for edges_item_data in _edges:
+                edges_item = Edge.from_dict(edges_item_data)
+
+                edges.append(edges_item)
+
+        graph_result_node = cls(
+            key=key,
+            depth=depth,
+            distance=distance,
+            document=document,
+            path=path,
+            path_edges=path_edges,
+            provenance=provenance,
+            edges=edges,
+        )
+
+        graph_result_node.additional_properties = d
+        return graph_result_node
+
+    @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/graph_result_node_document.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="GraphResultNodeDocument")
+
+
+@_attrs_define
+class GraphResultNodeDocument:
+    """Full document (if include_documents=true)"""
+
+    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)
+        graph_result_node_document = cls()
+
+        graph_result_node_document.additional_properties = d
+        return graph_result_node_document
+
+    @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/ground_truth.py

@@ -0,0 +1,74 @@
+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="GroundTruth")
+
+
+@_attrs_define
+class GroundTruth:
+    """Ground truth data for evaluation
+
+    Attributes:
+        relevant_ids (list[str] | Unset): Document IDs known to be relevant (for retrieval metrics)
+        expectations (str | Unset): Context for evaluators about what to expect in the response.
+            Provides guidance for LLM judges (e.g., "Should mention pricing tiers").
+    """
+
+    relevant_ids: list[str] | Unset = UNSET
+    expectations: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        relevant_ids: list[str] | Unset = UNSET
+        if not isinstance(self.relevant_ids, Unset):
+            relevant_ids = self.relevant_ids
+
+        expectations = self.expectations
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if relevant_ids is not UNSET:
+            field_dict["relevant_ids"] = relevant_ids
+        if expectations is not UNSET:
+            field_dict["expectations"] = expectations
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        relevant_ids = cast(list[str], d.pop("relevant_ids", UNSET))
+
+        expectations = d.pop("expectations", UNSET)
+
+        ground_truth = cls(
+            relevant_ids=relevant_ids,
+            expectations=expectations,
+        )
+
+        ground_truth.additional_properties = d
+        return ground_truth
+
+    @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/image_url.py

@@ -0,0 +1,62 @@
+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="ImageURL")
+
+
+@_attrs_define
+class ImageURL:
+    """Image URL or data URI.
+
+    Attributes:
+        url (str): URL or data URI (data:image/png;base64,...). Example: data:image/png;base64,iVBORw0KGgo....
+    """
+
+    url: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "url": url,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        image_url = cls(
+            url=url,
+        )
+
+        image_url.additional_properties = d
+        return image_url
+
+    @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/image_url_content_part.py

@@ -0,0 +1,78 @@
+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.image_url_content_part_type import ImageURLContentPartType
+
+if TYPE_CHECKING:
+    from ..models.image_url import ImageURL
+
+
+T = TypeVar("T", bound="ImageURLContentPart")
+
+
+@_attrs_define
+class ImageURLContentPart:
+    """Image content in OpenAI-compatible format.
+
+    Attributes:
+        type_ (ImageURLContentPartType):
+        image_url (ImageURL): Image URL or data URI.
+    """
+
+    type_: ImageURLContentPartType
+    image_url: ImageURL
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_.value
+
+        image_url = self.image_url.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "image_url": image_url,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.image_url import ImageURL
+
+        d = dict(src_dict)
+        type_ = ImageURLContentPartType(d.pop("type"))
+
+        image_url = ImageURL.from_dict(d.pop("image_url"))
+
+        image_url_content_part = cls(
+            type_=type_,
+            image_url=image_url,
+        )
+
+        image_url_content_part.additional_properties = d
+        return image_url_content_part
+
+    @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/image_url_content_part_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ImageURLContentPartType(str, Enum):
+    IMAGE_URL = "image_url"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/incomplete_details.py

@@ -0,0 +1,68 @@
+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.incomplete_details_reason import IncompleteDetailsReason
+
+T = TypeVar("T", bound="IncompleteDetails")
+
+
+@_attrs_define
+class IncompleteDetails:
+    """Explains why the agent stopped before completion. Present when status is "incomplete".
+
+    Attributes:
+        reason (IncompleteDetailsReason): Why the agent stopped:
+            - max_internal_iterations: Hit the configured max_internal_iterations limit
+            - max_tokens: LLM output was truncated
+            - no_tools: No tools were available for agentic mode
+            - clarification_required: The agent needs a user decision before it can continue
+    """
+
+    reason: IncompleteDetailsReason
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        reason = self.reason.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "reason": reason,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        reason = IncompleteDetailsReason(d.pop("reason"))
+
+        incomplete_details = cls(
+            reason=reason,
+        )
+
+        incomplete_details.additional_properties = d
+        return incomplete_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/incomplete_details_reason.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class IncompleteDetailsReason(str, Enum):
+    CLARIFICATION_REQUIRED = "clarification_required"
+    MAX_INTERNAL_ITERATIONS = "max_internal_iterations"
+    MAX_TOKENS = "max_tokens"
+    NO_TOOLS = "no_tools"
+
+    def __str__(self) -> str:
+        return str(self.value)