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

antfly/client_generated/models/query_profile.py

@@ -0,0 +1,130 @@
+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.join_profile import JoinProfile
+    from ..models.merge_profile import MergeProfile
+    from ..models.reranker_profile import RerankerProfile
+    from ..models.shards_profile import ShardsProfile
+
+
+T = TypeVar("T", bound="QueryProfile")
+
+
+@_attrs_define
+class QueryProfile:
+    """Detailed execution profiling for a query. Present in the response
+    when the request sets `profile: true`.
+
+        Attributes:
+            shards (ShardsProfile | Unset): Shard-level execution statistics.
+            join (JoinProfile | Unset): Join execution statistics.
+            reranker (RerankerProfile | Unset): Reranking execution statistics.
+            merge (MergeProfile | Unset): Result merge statistics for hybrid search.
+    """
+
+    shards: ShardsProfile | Unset = UNSET
+    join: JoinProfile | Unset = UNSET
+    reranker: RerankerProfile | Unset = UNSET
+    merge: MergeProfile | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        shards: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.shards, Unset):
+            shards = self.shards.to_dict()
+
+        join: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.join, Unset):
+            join = self.join.to_dict()
+
+        reranker: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.reranker, Unset):
+            reranker = self.reranker.to_dict()
+
+        merge: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.merge, Unset):
+            merge = self.merge.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if shards is not UNSET:
+            field_dict["shards"] = shards
+        if join is not UNSET:
+            field_dict["join"] = join
+        if reranker is not UNSET:
+            field_dict["reranker"] = reranker
+        if merge is not UNSET:
+            field_dict["merge"] = merge
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.join_profile import JoinProfile
+        from ..models.merge_profile import MergeProfile
+        from ..models.reranker_profile import RerankerProfile
+        from ..models.shards_profile import ShardsProfile
+
+        d = dict(src_dict)
+        _shards = d.pop("shards", UNSET)
+        shards: ShardsProfile | Unset
+        if isinstance(_shards, Unset):
+            shards = UNSET
+        else:
+            shards = ShardsProfile.from_dict(_shards)
+
+        _join = d.pop("join", UNSET)
+        join: JoinProfile | Unset
+        if isinstance(_join, Unset):
+            join = UNSET
+        else:
+            join = JoinProfile.from_dict(_join)
+
+        _reranker = d.pop("reranker", UNSET)
+        reranker: RerankerProfile | Unset
+        if isinstance(_reranker, Unset):
+            reranker = UNSET
+        else:
+            reranker = RerankerProfile.from_dict(_reranker)
+
+        _merge = d.pop("merge", UNSET)
+        merge: MergeProfile | Unset
+        if isinstance(_merge, Unset):
+            merge = UNSET
+        else:
+            merge = MergeProfile.from_dict(_merge)
+
+        query_profile = cls(
+            shards=shards,
+            join=join,
+            reranker=reranker,
+            merge=merge,
+        )
+
+        query_profile.additional_properties = d
+        return query_profile
+
+    @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_responses.py

@@ -0,0 +1,80 @@
+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_result import QueryResult
+
+
+T = TypeVar("T", bound="QueryResponses")
+
+
+@_attrs_define
+class QueryResponses:
+    """Responses from multiple query operations.
+
+    Attributes:
+        responses (list[QueryResult] | Unset):
+    """
+
+    responses: list[QueryResult] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        responses: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.responses, Unset):
+            responses = []
+            for responses_item_data in self.responses:
+                responses_item = responses_item_data.to_dict()
+                responses.append(responses_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if responses is not UNSET:
+            field_dict["responses"] = responses
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.query_result import QueryResult
+
+        d = dict(src_dict)
+        _responses = d.pop("responses", UNSET)
+        responses: list[QueryResult] | Unset = UNSET
+        if _responses is not UNSET:
+            responses = []
+            for responses_item_data in _responses:
+                responses_item = QueryResult.from_dict(responses_item_data)
+
+                responses.append(responses_item)
+
+        query_responses = cls(
+            responses=responses,
+        )
+
+        query_responses.additional_properties = d
+        return query_responses
+
+    @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_result.py

@@ -0,0 +1,187 @@
+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_hits import QueryHits
+    from ..models.query_profile import QueryProfile
+    from ..models.query_result_aggregations import QueryResultAggregations
+    from ..models.query_result_analyses import QueryResultAnalyses
+    from ..models.query_result_graph_results import QueryResultGraphResults
+
+
+T = TypeVar("T", bound="QueryResult")
+
+
+@_attrs_define
+class QueryResult:
+    """Result of a query operation as an array of results and a count.
+
+    Attributes:
+        took (int): Duration of the query in milliseconds.
+        status (int): HTTP status code of the query operation.
+        hits (QueryHits | Unset): A list of query hits.
+        aggregations (QueryResultAggregations | Unset): Aggregation results keyed by the user-defined aggregation names
+            from the request.
+            Contains computed metrics or buckets depending on the aggregation type.
+        analyses (QueryResultAnalyses | Unset): Analysis results like PCA and t-SNE per index embeddings.
+        graph_results (QueryResultGraphResults | Unset): Results from declarative graph queries.
+        profile (QueryProfile | Unset): Detailed execution profiling for a query. Present in the response
+            when the request sets `profile: true`.
+        error (str | Unset): Error message if the query failed.
+        table (str | Unset): Which table this result came from
+    """
+
+    took: int
+    status: int
+    hits: QueryHits | Unset = UNSET
+    aggregations: QueryResultAggregations | Unset = UNSET
+    analyses: QueryResultAnalyses | Unset = UNSET
+    graph_results: QueryResultGraphResults | Unset = UNSET
+    profile: QueryProfile | Unset = UNSET
+    error: str | Unset = UNSET
+    table: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        took = self.took
+
+        status = self.status
+
+        hits: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.hits, Unset):
+            hits = self.hits.to_dict()
+
+        aggregations: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.aggregations, Unset):
+            aggregations = self.aggregations.to_dict()
+
+        analyses: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.analyses, Unset):
+            analyses = self.analyses.to_dict()
+
+        graph_results: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.graph_results, Unset):
+            graph_results = self.graph_results.to_dict()
+
+        profile: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.profile, Unset):
+            profile = self.profile.to_dict()
+
+        error = self.error
+
+        table = self.table
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "took": took,
+                "status": status,
+            }
+        )
+        if hits is not UNSET:
+            field_dict["hits"] = hits
+        if aggregations is not UNSET:
+            field_dict["aggregations"] = aggregations
+        if analyses is not UNSET:
+            field_dict["analyses"] = analyses
+        if graph_results is not UNSET:
+            field_dict["graph_results"] = graph_results
+        if profile is not UNSET:
+            field_dict["profile"] = profile
+        if error is not UNSET:
+            field_dict["error"] = error
+        if table is not UNSET:
+            field_dict["table"] = table
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.query_hits import QueryHits
+        from ..models.query_profile import QueryProfile
+        from ..models.query_result_aggregations import QueryResultAggregations
+        from ..models.query_result_analyses import QueryResultAnalyses
+        from ..models.query_result_graph_results import QueryResultGraphResults
+
+        d = dict(src_dict)
+        took = d.pop("took")
+
+        status = d.pop("status")
+
+        _hits = d.pop("hits", UNSET)
+        hits: QueryHits | Unset
+        if isinstance(_hits, Unset):
+            hits = UNSET
+        else:
+            hits = QueryHits.from_dict(_hits)
+
+        _aggregations = d.pop("aggregations", UNSET)
+        aggregations: QueryResultAggregations | Unset
+        if isinstance(_aggregations, Unset):
+            aggregations = UNSET
+        else:
+            aggregations = QueryResultAggregations.from_dict(_aggregations)
+
+        _analyses = d.pop("analyses", UNSET)
+        analyses: QueryResultAnalyses | Unset
+        if isinstance(_analyses, Unset):
+            analyses = UNSET
+        else:
+            analyses = QueryResultAnalyses.from_dict(_analyses)
+
+        _graph_results = d.pop("graph_results", UNSET)
+        graph_results: QueryResultGraphResults | Unset
+        if isinstance(_graph_results, Unset):
+            graph_results = UNSET
+        else:
+            graph_results = QueryResultGraphResults.from_dict(_graph_results)
+
+        _profile = d.pop("profile", UNSET)
+        profile: QueryProfile | Unset
+        if isinstance(_profile, Unset):
+            profile = UNSET
+        else:
+            profile = QueryProfile.from_dict(_profile)
+
+        error = d.pop("error", UNSET)
+
+        table = d.pop("table", UNSET)
+
+        query_result = cls(
+            took=took,
+            status=status,
+            hits=hits,
+            aggregations=aggregations,
+            analyses=analyses,
+            graph_results=graph_results,
+            profile=profile,
+            error=error,
+            table=table,
+        )
+
+        query_result.additional_properties = d
+        return query_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/query_result_aggregations.py

@@ -0,0 +1,63 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.aggregation_result import AggregationResult
+
+
+T = TypeVar("T", bound="QueryResultAggregations")
+
+
+@_attrs_define
+class QueryResultAggregations:
+    """Aggregation results keyed by the user-defined aggregation names from the request.
+    Contains computed metrics or buckets depending on the aggregation type.
+
+    """
+
+    additional_properties: dict[str, AggregationResult] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.aggregation_result import AggregationResult
+
+        d = dict(src_dict)
+        query_result_aggregations = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = AggregationResult.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        query_result_aggregations.additional_properties = additional_properties
+        return query_result_aggregations
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> AggregationResult:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: AggregationResult) -> 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_result_analyses.py

@@ -0,0 +1,60 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.analyses_result import AnalysesResult
+
+
+T = TypeVar("T", bound="QueryResultAnalyses")
+
+
+@_attrs_define
+class QueryResultAnalyses:
+    """Analysis results like PCA and t-SNE per index embeddings."""
+
+    additional_properties: dict[str, AnalysesResult] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.analyses_result import AnalysesResult
+
+        d = dict(src_dict)
+        query_result_analyses = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = AnalysesResult.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        query_result_analyses.additional_properties = additional_properties
+        return query_result_analyses
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> AnalysesResult:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: AnalysesResult) -> 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_result_graph_results.py

@@ -0,0 +1,60 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.graph_query_result import GraphQueryResult
+
+
+T = TypeVar("T", bound="QueryResultGraphResults")
+
+
+@_attrs_define
+class QueryResultGraphResults:
+    """Results from declarative graph queries."""
+
+    additional_properties: dict[str, GraphQueryResult] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.graph_query_result import GraphQueryResult
+
+        d = dict(src_dict)
+        query_result_graph_results = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = GraphQueryResult.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        query_result_graph_results.additional_properties = additional_properties
+        return query_result_graph_results
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> GraphQueryResult:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: GraphQueryResult) -> 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_strategy.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class QueryStrategy(str, Enum):
+    DECOMPOSE = "decompose"
+    HYDE = "hyde"
+    SIMPLE = "simple"
+    STEP_BACK = "step_back"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/query_string_query.py

@@ -0,0 +1,84 @@
+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="QueryStringQuery")
+
+
+@_attrs_define
+class QueryStringQuery:
+    """
+    Attributes:
+        query (str):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    query: str
+    boost: float | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        query = self.query
+
+        boost: float | None | Unset
+        if isinstance(self.boost, Unset):
+            boost = UNSET
+        else:
+            boost = self.boost
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "query": query,
+            }
+        )
+        if boost is not UNSET:
+            field_dict["boost"] = boost
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        query = d.pop("query")
+
+        def _parse_boost(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        boost = _parse_boost(d.pop("boost", UNSET))
+
+        query_string_query = cls(
+            query=query,
+            boost=boost,
+        )
+
+        query_string_query.additional_properties = d
+        return query_string_query
+
+    @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