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

antfly/client_generated/models/query_builder_request.py

@@ -0,0 +1,250 @@
+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.agent_decision import AgentDecision
+    from ..models.generator_config import GeneratorConfig
+    from ..models.query_builder_request_constraints import QueryBuilderRequestConstraints
+    from ..models.query_builder_request_example_documents_item import QueryBuilderRequestExampleDocumentsItem
+
+
+T = TypeVar("T", bound="QueryBuilderRequest")
+
+
+@_attrs_define
+class QueryBuilderRequest:
+    """
+    Attributes:
+        intent (str): Natural language description of the search intent Example: Find all published articles about
+            machine learning from the last year.
+        session_id (str | Unset): Correlation identifier for a bounded agent interaction. In Phase 1 this is echoed back
+            to the client but does not imply server-side session persistence.
+        decisions (list[AgentDecision] | Unset): Structured answers provided by the user as part of client-carried
+            continuation.
+        interactive (bool | Unset): If true, the agent may return clarification questions when needed. Default: True.
+        max_internal_iterations (int | Unset): Additive bounded-agent field for the query builder. Phase 1 remains a
+            single-pass generation flow, but this field is echoed in result accounting.
+        max_user_clarifications (int | Unset): Maximum number of clarification turns the agent may request from the
+            user.
+        require_decision_after (int | Unset): Force a user-facing decision after this many unresolved internal passes.
+        example_documents (list[QueryBuilderRequestExampleDocumentsItem] | Unset): Optional example documents to help
+            the query builder infer field shapes and representative values. When omitted and the table has data but no
+            schema, the server samples up to one document automatically.
+        table (str | Unset): Name of the table to build query for. If provided, uses table schema for field context.
+            Example: articles.
+        schema_fields (list[str] | Unset): List of searchable field names to consider. Overrides table schema if
+            provided. Example: ['title', 'content', 'status', 'published_at'].
+        mode (str | Unset): Optional strategy hint for the coordinator. Suggested values are `auto`, `full_text`,
+            `semantic`, `hybrid`, `filter`, `tree`, and `graph`. Unknown values are accepted for
+            forward compatibility and may fall back to `auto`.
+             Example: auto.
+        output (str | Unset): Preferred output artifact. Suggested values are `query_request`, `bleve`, and
+            `filter_query`. The compatibility `query` field is still returned for existing clients.
+             Example: query_request.
+        constraints (QueryBuilderRequestConstraints | Unset): Optional execution constraints for the coordinator, such
+            as `limit`, `allowed_fields`,
+            `prefer_indexes`, and `require_executable`.
+             Example: {'limit': 10, 'require_executable': True, 'prefer_indexes': ['body_embedding']}.
+        generator (GeneratorConfig | Unset): A unified configuration for a generative AI provider.
+             Example: {'provider': 'openai', 'model': 'gpt-4.1', 'temperature': 0.7, 'max_tokens': 2048}.
+    """
+
+    intent: str
+    session_id: str | Unset = UNSET
+    decisions: list[AgentDecision] | Unset = UNSET
+    interactive: bool | Unset = True
+    max_internal_iterations: int | Unset = UNSET
+    max_user_clarifications: int | Unset = UNSET
+    require_decision_after: int | Unset = UNSET
+    example_documents: list[QueryBuilderRequestExampleDocumentsItem] | Unset = UNSET
+    table: str | Unset = UNSET
+    schema_fields: list[str] | Unset = UNSET
+    mode: str | Unset = UNSET
+    output: str | Unset = UNSET
+    constraints: QueryBuilderRequestConstraints | Unset = UNSET
+    generator: GeneratorConfig | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        intent = self.intent
+
+        session_id = self.session_id
+
+        decisions: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.decisions, Unset):
+            decisions = []
+            for decisions_item_data in self.decisions:
+                decisions_item = decisions_item_data.to_dict()
+                decisions.append(decisions_item)
+
+        interactive = self.interactive
+
+        max_internal_iterations = self.max_internal_iterations
+
+        max_user_clarifications = self.max_user_clarifications
+
+        require_decision_after = self.require_decision_after
+
+        example_documents: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.example_documents, Unset):
+            example_documents = []
+            for example_documents_item_data in self.example_documents:
+                example_documents_item = example_documents_item_data.to_dict()
+                example_documents.append(example_documents_item)
+
+        table = self.table
+
+        schema_fields: list[str] | Unset = UNSET
+        if not isinstance(self.schema_fields, Unset):
+            schema_fields = self.schema_fields
+
+        mode = self.mode
+
+        output = self.output
+
+        constraints: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.constraints, Unset):
+            constraints = self.constraints.to_dict()
+
+        generator: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.generator, Unset):
+            generator = self.generator.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "intent": intent,
+            }
+        )
+        if session_id is not UNSET:
+            field_dict["session_id"] = session_id
+        if decisions is not UNSET:
+            field_dict["decisions"] = decisions
+        if interactive is not UNSET:
+            field_dict["interactive"] = interactive
+        if max_internal_iterations is not UNSET:
+            field_dict["max_internal_iterations"] = max_internal_iterations
+        if max_user_clarifications is not UNSET:
+            field_dict["max_user_clarifications"] = max_user_clarifications
+        if require_decision_after is not UNSET:
+            field_dict["require_decision_after"] = require_decision_after
+        if example_documents is not UNSET:
+            field_dict["example_documents"] = example_documents
+        if table is not UNSET:
+            field_dict["table"] = table
+        if schema_fields is not UNSET:
+            field_dict["schema_fields"] = schema_fields
+        if mode is not UNSET:
+            field_dict["mode"] = mode
+        if output is not UNSET:
+            field_dict["output"] = output
+        if constraints is not UNSET:
+            field_dict["constraints"] = constraints
+        if generator is not UNSET:
+            field_dict["generator"] = generator
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.agent_decision import AgentDecision
+        from ..models.generator_config import GeneratorConfig
+        from ..models.query_builder_request_constraints import QueryBuilderRequestConstraints
+        from ..models.query_builder_request_example_documents_item import QueryBuilderRequestExampleDocumentsItem
+
+        d = dict(src_dict)
+        intent = d.pop("intent")
+
+        session_id = d.pop("session_id", UNSET)
+
+        _decisions = d.pop("decisions", UNSET)
+        decisions: list[AgentDecision] | Unset = UNSET
+        if _decisions is not UNSET:
+            decisions = []
+            for decisions_item_data in _decisions:
+                decisions_item = AgentDecision.from_dict(decisions_item_data)
+
+                decisions.append(decisions_item)
+
+        interactive = d.pop("interactive", UNSET)
+
+        max_internal_iterations = d.pop("max_internal_iterations", UNSET)
+
+        max_user_clarifications = d.pop("max_user_clarifications", UNSET)
+
+        require_decision_after = d.pop("require_decision_after", UNSET)
+
+        _example_documents = d.pop("example_documents", UNSET)
+        example_documents: list[QueryBuilderRequestExampleDocumentsItem] | Unset = UNSET
+        if _example_documents is not UNSET:
+            example_documents = []
+            for example_documents_item_data in _example_documents:
+                example_documents_item = QueryBuilderRequestExampleDocumentsItem.from_dict(example_documents_item_data)
+
+                example_documents.append(example_documents_item)
+
+        table = d.pop("table", UNSET)
+
+        schema_fields = cast(list[str], d.pop("schema_fields", UNSET))
+
+        mode = d.pop("mode", UNSET)
+
+        output = d.pop("output", UNSET)
+
+        _constraints = d.pop("constraints", UNSET)
+        constraints: QueryBuilderRequestConstraints | Unset
+        if isinstance(_constraints, Unset):
+            constraints = UNSET
+        else:
+            constraints = QueryBuilderRequestConstraints.from_dict(_constraints)
+
+        _generator = d.pop("generator", UNSET)
+        generator: GeneratorConfig | Unset
+        if isinstance(_generator, Unset):
+            generator = UNSET
+        else:
+            generator = GeneratorConfig.from_dict(_generator)
+
+        query_builder_request = cls(
+            intent=intent,
+            session_id=session_id,
+            decisions=decisions,
+            interactive=interactive,
+            max_internal_iterations=max_internal_iterations,
+            max_user_clarifications=max_user_clarifications,
+            require_decision_after=require_decision_after,
+            example_documents=example_documents,
+            table=table,
+            schema_fields=schema_fields,
+            mode=mode,
+            output=output,
+            constraints=constraints,
+            generator=generator,
+        )
+
+        query_builder_request.additional_properties = d
+        return query_builder_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/query_builder_request_constraints.py

@@ -0,0 +1,53 @@
+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="QueryBuilderRequestConstraints")
+
+
+@_attrs_define
+class QueryBuilderRequestConstraints:
+    """Optional execution constraints for the coordinator, such as `limit`, `allowed_fields`,
+    `prefer_indexes`, and `require_executable`.
+
+        Example:
+            {'limit': 10, 'require_executable': True, 'prefer_indexes': ['body_embedding']}
+
+    """
+
+    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)
+        query_builder_request_constraints = cls()
+
+        query_builder_request_constraints.additional_properties = d
+        return query_builder_request_constraints
+
+    @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/query_builder_request_example_documents_item.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="QueryBuilderRequestExampleDocumentsItem")
+
+
+@_attrs_define
+class QueryBuilderRequestExampleDocumentsItem:
+    """ """
+
+    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)
+        query_builder_request_example_documents_item = cls()
+
+        query_builder_request_example_documents_item.additional_properties = d
+        return query_builder_request_example_documents_item
+
+    @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/query_hit.py

@@ -0,0 +1,124 @@
+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.query_hit_index_scores import QueryHitIndexScores
+    from ..models.query_hit_source import QueryHitSource
+
+
+T = TypeVar("T", bound="QueryHit")
+
+
+@_attrs_define
+class QueryHit:
+    """A single query result hit
+
+    Attributes:
+        field_id (str): ID of the record.
+        field_score (float): Relevance score of the hit.
+        field_index_scores (QueryHitIndexScores | Unset): Scores partitioned by index when using RRF search.
+        field_source (QueryHitSource | Unset):
+        field_sort (list[str] | Unset): Sort key values for this hit. Pass as search_after or search_before
+            to paginate to the next/previous page. Only present when order_by is specified.
+    """
+
+    field_id: str
+    field_score: float
+    field_index_scores: QueryHitIndexScores | Unset = UNSET
+    field_source: QueryHitSource | Unset = UNSET
+    field_sort: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_id = self.field_id
+
+        field_score = self.field_score
+
+        field_index_scores: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.field_index_scores, Unset):
+            field_index_scores = self.field_index_scores.to_dict()
+
+        field_source: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.field_source, Unset):
+            field_source = self.field_source.to_dict()
+
+        field_sort: list[str] | Unset = UNSET
+        if not isinstance(self.field_sort, Unset):
+            field_sort = self.field_sort
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "_id": field_id,
+                "_score": field_score,
+            }
+        )
+        if field_index_scores is not UNSET:
+            field_dict["_index_scores"] = field_index_scores
+        if field_source is not UNSET:
+            field_dict["_source"] = field_source
+        if field_sort is not UNSET:
+            field_dict["_sort"] = field_sort
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.query_hit_index_scores import QueryHitIndexScores
+        from ..models.query_hit_source import QueryHitSource
+
+        d = dict(src_dict)
+        field_id = d.pop("_id")
+
+        field_score = d.pop("_score")
+
+        _field_index_scores = d.pop("_index_scores", UNSET)
+        field_index_scores: QueryHitIndexScores | Unset
+        if isinstance(_field_index_scores, Unset):
+            field_index_scores = UNSET
+        else:
+            field_index_scores = QueryHitIndexScores.from_dict(_field_index_scores)
+
+        _field_source = d.pop("_source", UNSET)
+        field_source: QueryHitSource | Unset
+        if isinstance(_field_source, Unset):
+            field_source = UNSET
+        else:
+            field_source = QueryHitSource.from_dict(_field_source)
+
+        field_sort = cast(list[str], d.pop("_sort", UNSET))
+
+        query_hit = cls(
+            field_id=field_id,
+            field_score=field_score,
+            field_index_scores=field_index_scores,
+            field_source=field_source,
+            field_sort=field_sort,
+        )
+
+        query_hit.additional_properties = d
+        return query_hit
+
+    @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/query_hit_index_scores.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="QueryHitIndexScores")
+
+
+@_attrs_define
+class QueryHitIndexScores:
+    """Scores partitioned by index when using RRF search."""
+
+    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)
+        query_hit_index_scores = cls()
+
+        query_hit_index_scores.additional_properties = d
+        return query_hit_index_scores
+
+    @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/query_hit_source.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="QueryHitSource")
+
+
+@_attrs_define
+class QueryHitSource:
+    """ """
+
+    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)
+        query_hit_source = cls()
+
+        query_hit_source.additional_properties = d
+        return query_hit_source
+
+    @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/query_hits.py

@@ -0,0 +1,98 @@
+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.query_hit import QueryHit
+
+
+T = TypeVar("T", bound="QueryHits")
+
+
+@_attrs_define
+class QueryHits:
+    """A list of query hits.
+
+    Attributes:
+        total (int | Unset): Total number of hits available.
+        hits (list[QueryHit] | Unset):
+        max_score (float | Unset): Maximum score of the results.
+    """
+
+    total: int | Unset = UNSET
+    hits: list[QueryHit] | Unset = UNSET
+    max_score: float | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        total = self.total
+
+        hits: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.hits, Unset):
+            hits = []
+            for hits_item_data in self.hits:
+                hits_item = hits_item_data.to_dict()
+                hits.append(hits_item)
+
+        max_score = self.max_score
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if total is not UNSET:
+            field_dict["total"] = total
+        if hits is not UNSET:
+            field_dict["hits"] = hits
+        if max_score is not UNSET:
+            field_dict["max_score"] = max_score
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.query_hit import QueryHit
+
+        d = dict(src_dict)
+        total = d.pop("total", UNSET)
+
+        _hits = d.pop("hits", UNSET)
+        hits: list[QueryHit] | Unset = UNSET
+        if _hits is not UNSET:
+            hits = []
+            for hits_item_data in _hits:
+                hits_item = QueryHit.from_dict(hits_item_data)
+
+                hits.append(hits_item)
+
+        max_score = d.pop("max_score", UNSET)
+
+        query_hits = cls(
+            total=total,
+            hits=hits,
+            max_score=max_score,
+        )
+
+        query_hits.additional_properties = d
+        return query_hits
+
+    @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