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

antfly/client_generated/models/graph_index_config.py

@@ -0,0 +1,121 @@
+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.edge_type_config import EdgeTypeConfig
+    from ..models.generator_config import GeneratorConfig
+
+
+T = TypeVar("T", bound="GraphIndexConfig")
+
+
+@_attrs_define
+class GraphIndexConfig:
+    """Configuration for graph index type
+
+    Attributes:
+        summarizer (GeneratorConfig | Unset): A unified configuration for a generative AI provider.
+             Example: {'provider': 'openai', 'model': 'gpt-4.1', 'temperature': 0.7, 'max_tokens': 2048}.
+        template (str | Unset): Handlebars template for generating summarizer input text.
+            Uses document fields as template variables.
+            Same pattern as EmbeddingsConfig template.
+             Example: {{title}}
+            {{content}}.
+        edge_types (list[EdgeTypeConfig] | Unset): List of edge types with their configurations
+        max_edges_per_document (int | Unset): Maximum number of edges per document (0 = unlimited)
+    """
+
+    summarizer: GeneratorConfig | Unset = UNSET
+    template: str | Unset = UNSET
+    edge_types: list[EdgeTypeConfig] | Unset = UNSET
+    max_edges_per_document: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        summarizer: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.summarizer, Unset):
+            summarizer = self.summarizer.to_dict()
+
+        template = self.template
+
+        edge_types: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.edge_types, Unset):
+            edge_types = []
+            for edge_types_item_data in self.edge_types:
+                edge_types_item = edge_types_item_data.to_dict()
+                edge_types.append(edge_types_item)
+
+        max_edges_per_document = self.max_edges_per_document
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if summarizer is not UNSET:
+            field_dict["summarizer"] = summarizer
+        if template is not UNSET:
+            field_dict["template"] = template
+        if edge_types is not UNSET:
+            field_dict["edge_types"] = edge_types
+        if max_edges_per_document is not UNSET:
+            field_dict["max_edges_per_document"] = max_edges_per_document
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.edge_type_config import EdgeTypeConfig
+        from ..models.generator_config import GeneratorConfig
+
+        d = dict(src_dict)
+        _summarizer = d.pop("summarizer", UNSET)
+        summarizer: GeneratorConfig | Unset
+        if isinstance(_summarizer, Unset):
+            summarizer = UNSET
+        else:
+            summarizer = GeneratorConfig.from_dict(_summarizer)
+
+        template = d.pop("template", UNSET)
+
+        _edge_types = d.pop("edge_types", UNSET)
+        edge_types: list[EdgeTypeConfig] | Unset = UNSET
+        if _edge_types is not UNSET:
+            edge_types = []
+            for edge_types_item_data in _edge_types:
+                edge_types_item = EdgeTypeConfig.from_dict(edge_types_item_data)
+
+                edge_types.append(edge_types_item)
+
+        max_edges_per_document = d.pop("max_edges_per_document", UNSET)
+
+        graph_index_config = cls(
+            summarizer=summarizer,
+            template=template,
+            edge_types=edge_types,
+            max_edges_per_document=max_edges_per_document,
+        )
+
+        graph_index_config.additional_properties = d
+        return graph_index_config
+
+    @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_index_stats.py

@@ -0,0 +1,151 @@
+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.graph_index_stats_index_type import GraphIndexStatsIndexType
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.graph_index_stats_algebraic_graph import GraphIndexStatsAlgebraicGraph
+    from ..models.graph_index_stats_edge_types import GraphIndexStatsEdgeTypes
+
+
+T = TypeVar("T", bound="GraphIndexStats")
+
+
+@_attrs_define
+class GraphIndexStats:
+    """Statistics for graph index
+
+    Attributes:
+        index_type (GraphIndexStatsIndexType): Discriminator for the index stats variant.
+        error (str | Unset): Error message if stats could not be retrieved
+        total_edges (int | Unset): Total number of edges in the graph
+        edge_types (GraphIndexStatsEdgeTypes | Unset): Count of edges per edge type
+        rebuilding (bool | Unset): Whether the index is currently rebuilding
+        backfill_progress (float | Unset): Rebuild progress as a ratio from 0.0 to 1.0
+        backfill_items_processed (int | Unset): Number of edges indexed during current rebuild
+        algebraic_graph (GraphIndexStatsAlgebraicGraph | Unset): Algebraic graph execution health for bounded semiring
+            traversal.
+    """
+
+    index_type: GraphIndexStatsIndexType
+    error: str | Unset = UNSET
+    total_edges: int | Unset = UNSET
+    edge_types: GraphIndexStatsEdgeTypes | Unset = UNSET
+    rebuilding: bool | Unset = UNSET
+    backfill_progress: float | Unset = UNSET
+    backfill_items_processed: int | Unset = UNSET
+    algebraic_graph: GraphIndexStatsAlgebraicGraph | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        index_type = self.index_type.value
+
+        error = self.error
+
+        total_edges = self.total_edges
+
+        edge_types: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.edge_types, Unset):
+            edge_types = self.edge_types.to_dict()
+
+        rebuilding = self.rebuilding
+
+        backfill_progress = self.backfill_progress
+
+        backfill_items_processed = self.backfill_items_processed
+
+        algebraic_graph: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.algebraic_graph, Unset):
+            algebraic_graph = self.algebraic_graph.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "index_type": index_type,
+            }
+        )
+        if error is not UNSET:
+            field_dict["error"] = error
+        if total_edges is not UNSET:
+            field_dict["total_edges"] = total_edges
+        if edge_types is not UNSET:
+            field_dict["edge_types"] = edge_types
+        if rebuilding is not UNSET:
+            field_dict["rebuilding"] = rebuilding
+        if backfill_progress is not UNSET:
+            field_dict["backfill_progress"] = backfill_progress
+        if backfill_items_processed is not UNSET:
+            field_dict["backfill_items_processed"] = backfill_items_processed
+        if algebraic_graph is not UNSET:
+            field_dict["algebraic_graph"] = algebraic_graph
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.graph_index_stats_algebraic_graph import GraphIndexStatsAlgebraicGraph
+        from ..models.graph_index_stats_edge_types import GraphIndexStatsEdgeTypes
+
+        d = dict(src_dict)
+        index_type = GraphIndexStatsIndexType(d.pop("index_type"))
+
+        error = d.pop("error", UNSET)
+
+        total_edges = d.pop("total_edges", UNSET)
+
+        _edge_types = d.pop("edge_types", UNSET)
+        edge_types: GraphIndexStatsEdgeTypes | Unset
+        if isinstance(_edge_types, Unset):
+            edge_types = UNSET
+        else:
+            edge_types = GraphIndexStatsEdgeTypes.from_dict(_edge_types)
+
+        rebuilding = d.pop("rebuilding", UNSET)
+
+        backfill_progress = d.pop("backfill_progress", UNSET)
+
+        backfill_items_processed = d.pop("backfill_items_processed", UNSET)
+
+        _algebraic_graph = d.pop("algebraic_graph", UNSET)
+        algebraic_graph: GraphIndexStatsAlgebraicGraph | Unset
+        if isinstance(_algebraic_graph, Unset):
+            algebraic_graph = UNSET
+        else:
+            algebraic_graph = GraphIndexStatsAlgebraicGraph.from_dict(_algebraic_graph)
+
+        graph_index_stats = cls(
+            index_type=index_type,
+            error=error,
+            total_edges=total_edges,
+            edge_types=edge_types,
+            rebuilding=rebuilding,
+            backfill_progress=backfill_progress,
+            backfill_items_processed=backfill_items_processed,
+            algebraic_graph=algebraic_graph,
+        )
+
+        graph_index_stats.additional_properties = d
+        return graph_index_stats
+
+    @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_index_stats_algebraic_graph.py

@@ -0,0 +1,75 @@
+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.graph_index_stats_algebraic_graph_traversal import GraphIndexStatsAlgebraicGraphTraversal
+
+
+T = TypeVar("T", bound="GraphIndexStatsAlgebraicGraph")
+
+
+@_attrs_define
+class GraphIndexStatsAlgebraicGraph:
+    """Algebraic graph execution health for bounded semiring traversal.
+
+    Attributes:
+        traversal (GraphIndexStatsAlgebraicGraphTraversal | Unset):
+    """
+
+    traversal: GraphIndexStatsAlgebraicGraphTraversal | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        traversal: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.traversal, Unset):
+            traversal = self.traversal.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if traversal is not UNSET:
+            field_dict["traversal"] = traversal
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.graph_index_stats_algebraic_graph_traversal import GraphIndexStatsAlgebraicGraphTraversal
+
+        d = dict(src_dict)
+        _traversal = d.pop("traversal", UNSET)
+        traversal: GraphIndexStatsAlgebraicGraphTraversal | Unset
+        if isinstance(_traversal, Unset):
+            traversal = UNSET
+        else:
+            traversal = GraphIndexStatsAlgebraicGraphTraversal.from_dict(_traversal)
+
+        graph_index_stats_algebraic_graph = cls(
+            traversal=traversal,
+        )
+
+        graph_index_stats_algebraic_graph.additional_properties = d
+        return graph_index_stats_algebraic_graph
+
+    @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_index_stats_algebraic_graph_traversal.py

@@ -0,0 +1,97 @@
+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="GraphIndexStatsAlgebraicGraphTraversal")
+
+
+@_attrs_define
+class GraphIndexStatsAlgebraicGraphTraversal:
+    """
+    Attributes:
+        attempted (int | Unset):
+        proven (int | Unset):
+        rejected (int | Unset):
+        fallback (int | Unset):
+        result_nodes (int | Unset):
+    """
+
+    attempted: int | Unset = UNSET
+    proven: int | Unset = UNSET
+    rejected: int | Unset = UNSET
+    fallback: int | Unset = UNSET
+    result_nodes: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        attempted = self.attempted
+
+        proven = self.proven
+
+        rejected = self.rejected
+
+        fallback = self.fallback
+
+        result_nodes = self.result_nodes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if attempted is not UNSET:
+            field_dict["attempted"] = attempted
+        if proven is not UNSET:
+            field_dict["proven"] = proven
+        if rejected is not UNSET:
+            field_dict["rejected"] = rejected
+        if fallback is not UNSET:
+            field_dict["fallback"] = fallback
+        if result_nodes is not UNSET:
+            field_dict["result_nodes"] = result_nodes
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        attempted = d.pop("attempted", UNSET)
+
+        proven = d.pop("proven", UNSET)
+
+        rejected = d.pop("rejected", UNSET)
+
+        fallback = d.pop("fallback", UNSET)
+
+        result_nodes = d.pop("result_nodes", UNSET)
+
+        graph_index_stats_algebraic_graph_traversal = cls(
+            attempted=attempted,
+            proven=proven,
+            rejected=rejected,
+            fallback=fallback,
+            result_nodes=result_nodes,
+        )
+
+        graph_index_stats_algebraic_graph_traversal.additional_properties = d
+        return graph_index_stats_algebraic_graph_traversal
+
+    @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_index_stats_edge_types.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="GraphIndexStatsEdgeTypes")
+
+
+@_attrs_define
+class GraphIndexStatsEdgeTypes:
+    """Count of edges per edge type"""
+
+    additional_properties: dict[str, int] = _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_index_stats_edge_types = cls()
+
+        graph_index_stats_edge_types.additional_properties = d
+        return graph_index_stats_edge_types
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> int:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: int) -> 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_index_stats_index_type.py

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

antfly/client_generated/models/graph_node_selector.py

@@ -0,0 +1,106 @@
+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.node_filter import NodeFilter
+
+
+T = TypeVar("T", bound="GraphNodeSelector")
+
+
+@_attrs_define
+class GraphNodeSelector:
+    """Defines how to select start/target nodes for graph queries
+
+    Attributes:
+        keys (list[str] | Unset): Explicit list of node keys
+        result_ref (str | Unset): Reference to search results to use as nodes:
+            - "$full_text_results" - use full-text search results
+            - "$embeddings_results.index_name" - use vector search results from specific index
+        limit (int | Unset): Maximum number of nodes to select from the referenced results
+        node_filter (NodeFilter | Unset): Filter nodes during graph traversal using existing query primitives
+    """
+
+    keys: list[str] | Unset = UNSET
+    result_ref: str | Unset = UNSET
+    limit: int | Unset = UNSET
+    node_filter: NodeFilter | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        keys: list[str] | Unset = UNSET
+        if not isinstance(self.keys, Unset):
+            keys = self.keys
+
+        result_ref = self.result_ref
+
+        limit = self.limit
+
+        node_filter: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.node_filter, Unset):
+            node_filter = self.node_filter.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if keys is not UNSET:
+            field_dict["keys"] = keys
+        if result_ref is not UNSET:
+            field_dict["result_ref"] = result_ref
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if node_filter is not UNSET:
+            field_dict["node_filter"] = node_filter
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.node_filter import NodeFilter
+
+        d = dict(src_dict)
+        keys = cast(list[str], d.pop("keys", UNSET))
+
+        result_ref = d.pop("result_ref", UNSET)
+
+        limit = d.pop("limit", UNSET)
+
+        _node_filter = d.pop("node_filter", UNSET)
+        node_filter: NodeFilter | Unset
+        if isinstance(_node_filter, Unset):
+            node_filter = UNSET
+        else:
+            node_filter = NodeFilter.from_dict(_node_filter)
+
+        graph_node_selector = cls(
+            keys=keys,
+            result_ref=result_ref,
+            limit=limit,
+            node_filter=node_filter,
+        )
+
+        graph_node_selector.additional_properties = d
+        return graph_node_selector
+
+    @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