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

antfly/client_generated/models/pattern_step.py

@@ -0,0 +1,102 @@
+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.node_filter import NodeFilter
+    from ..models.pattern_edge_step import PatternEdgeStep
+
+
+T = TypeVar("T", bound="PatternStep")
+
+
+@_attrs_define
+class PatternStep:
+    """A step in a graph pattern query
+
+    Attributes:
+        alias (str | Unset): Name for this node (reuse alias for cycle detection)
+        node_filter (NodeFilter | Unset): Filter nodes during graph traversal using existing query primitives
+        edge (PatternEdgeStep | Unset): Edge constraints in a pattern step
+    """
+
+    alias: str | Unset = UNSET
+    node_filter: NodeFilter | Unset = UNSET
+    edge: PatternEdgeStep | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        alias = self.alias
+
+        node_filter: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.node_filter, Unset):
+            node_filter = self.node_filter.to_dict()
+
+        edge: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.edge, Unset):
+            edge = self.edge.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if alias is not UNSET:
+            field_dict["alias"] = alias
+        if node_filter is not UNSET:
+            field_dict["node_filter"] = node_filter
+        if edge is not UNSET:
+            field_dict["edge"] = edge
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.node_filter import NodeFilter
+        from ..models.pattern_edge_step import PatternEdgeStep
+
+        d = dict(src_dict)
+        alias = d.pop("alias", 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)
+
+        _edge = d.pop("edge", UNSET)
+        edge: PatternEdgeStep | Unset
+        if isinstance(_edge, Unset):
+            edge = UNSET
+        else:
+            edge = PatternEdgeStep.from_dict(_edge)
+
+        pattern_step = cls(
+            alias=alias,
+            node_filter=node_filter,
+            edge=edge,
+        )
+
+        pattern_step.additional_properties = d
+        return pattern_step
+
+    @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/permission.py

@@ -0,0 +1,80 @@
+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.permission_type import PermissionType
+from ..models.resource_type import ResourceType
+
+T = TypeVar("T", bound="Permission")
+
+
+@_attrs_define
+class Permission:
+    """
+    Attributes:
+        resource (str): Resource name (e.g., table name, target username, or '*' for global). Example: orders_table.
+        resource_type (ResourceType): Type of the resource, e.g., table, user, or global ('*'). Example: table.
+        type_ (PermissionType): Type of permission. Example: read.
+    """
+
+    resource: str
+    resource_type: ResourceType
+    type_: PermissionType
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        resource = self.resource
+
+        resource_type = self.resource_type.value
+
+        type_ = self.type_.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "resource": resource,
+                "resource_type": resource_type,
+                "type": type_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        resource = d.pop("resource")
+
+        resource_type = ResourceType(d.pop("resource_type"))
+
+        type_ = PermissionType(d.pop("type"))
+
+        permission = cls(
+            resource=resource,
+            resource_type=resource_type,
+            type_=type_,
+        )
+
+        permission.additional_properties = d
+        return permission
+
+    @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/permission_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class PermissionType(str, Enum):
+    ADMIN = "admin"
+    READ = "read"
+    WRITE = "write"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/phrase_query.py

@@ -0,0 +1,122 @@
+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 ..models.fuzziness_type_1 import FuzzinessType1
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PhraseQuery")
+
+
+@_attrs_define
+class PhraseQuery:
+    """
+    Attributes:
+        terms (list[str]):
+        field (str | Unset):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+        fuzziness (FuzzinessType1 | int | Unset): The fuzziness of the query. Can be an integer or "auto".
+    """
+
+    terms: list[str]
+    field: str | Unset = UNSET
+    boost: float | None | Unset = UNSET
+    fuzziness: FuzzinessType1 | int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        terms = self.terms
+
+        field = self.field
+
+        boost: float | None | Unset
+        if isinstance(self.boost, Unset):
+            boost = UNSET
+        else:
+            boost = self.boost
+
+        fuzziness: int | str | Unset
+        if isinstance(self.fuzziness, Unset):
+            fuzziness = UNSET
+        elif isinstance(self.fuzziness, FuzzinessType1):
+            fuzziness = self.fuzziness.value
+        else:
+            fuzziness = self.fuzziness
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "terms": terms,
+            }
+        )
+        if field is not UNSET:
+            field_dict["field"] = field
+        if boost is not UNSET:
+            field_dict["boost"] = boost
+        if fuzziness is not UNSET:
+            field_dict["fuzziness"] = fuzziness
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        terms = cast(list[str], d.pop("terms"))
+
+        field = d.pop("field", UNSET)
+
+        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))
+
+        def _parse_fuzziness(data: object) -> FuzzinessType1 | int | Unset:
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                componentsschemas_fuzziness_type_1 = FuzzinessType1(data)
+
+                return componentsschemas_fuzziness_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(FuzzinessType1 | int | Unset, data)
+
+        fuzziness = _parse_fuzziness(d.pop("fuzziness", UNSET))
+
+        phrase_query = cls(
+            terms=terms,
+            field=field,
+            boost=boost,
+            fuzziness=fuzziness,
+        )
+
+        phrase_query.additional_properties = d
+        return phrase_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

antfly/client_generated/models/prefix_query.py

@@ -0,0 +1,93 @@
+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="PrefixQuery")
+
+
+@_attrs_define
+class PrefixQuery:
+    """
+    Attributes:
+        prefix (str):
+        field (str | Unset):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    prefix: str
+    field: str | Unset = UNSET
+    boost: float | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        prefix = self.prefix
+
+        field = self.field
+
+        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(
+            {
+                "prefix": prefix,
+            }
+        )
+        if field is not UNSET:
+            field_dict["field"] = field
+        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)
+        prefix = d.pop("prefix")
+
+        field = d.pop("field", UNSET)
+
+        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))
+
+        prefix_query = cls(
+            prefix=prefix,
+            field=field,
+            boost=boost,
+        )
+
+        prefix_query.additional_properties = d
+        return prefix_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

antfly/client_generated/models/prune_stats.py

@@ -0,0 +1,89 @@
+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="PruneStats")
+
+
+@_attrs_define
+class PruneStats:
+    """Statistics from token-based document pruning
+
+    Attributes:
+        resources_kept (int | Unset): Number of resources kept after pruning
+        resources_pruned (int | Unset): Number of resources pruned to fit token budget
+        tokens_kept (int | Unset): Estimated tokens in kept resources
+        tokens_pruned (int | Unset): Estimated tokens in pruned resources
+    """
+
+    resources_kept: int | Unset = UNSET
+    resources_pruned: int | Unset = UNSET
+    tokens_kept: int | Unset = UNSET
+    tokens_pruned: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        resources_kept = self.resources_kept
+
+        resources_pruned = self.resources_pruned
+
+        tokens_kept = self.tokens_kept
+
+        tokens_pruned = self.tokens_pruned
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if resources_kept is not UNSET:
+            field_dict["resources_kept"] = resources_kept
+        if resources_pruned is not UNSET:
+            field_dict["resources_pruned"] = resources_pruned
+        if tokens_kept is not UNSET:
+            field_dict["tokens_kept"] = tokens_kept
+        if tokens_pruned is not UNSET:
+            field_dict["tokens_pruned"] = tokens_pruned
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        resources_kept = d.pop("resources_kept", UNSET)
+
+        resources_pruned = d.pop("resources_pruned", UNSET)
+
+        tokens_kept = d.pop("tokens_kept", UNSET)
+
+        tokens_pruned = d.pop("tokens_pruned", UNSET)
+
+        prune_stats = cls(
+            resources_kept=resources_kept,
+            resources_pruned=resources_pruned,
+            tokens_kept=tokens_kept,
+            tokens_pruned=tokens_pruned,
+        )
+
+        prune_stats.additional_properties = d
+        return prune_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/pruner.py

@@ -0,0 +1,115 @@
+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="Pruner")
+
+
+@_attrs_define
+class Pruner:
+    """Configuration for pruning search results based on score quality.
+    Helps filter out low-relevance results in RAG pipelines by detecting
+    score gaps or deviations from top results.
+
+        Attributes:
+            min_score_ratio (float | Unset): Keep only results with score >= max_score * min_score_ratio.
+                For example, 0.5 keeps results scoring at least half of the top result.
+                Applied after fusion scoring.
+                 Example: 0.5.
+            max_score_gap_percent (float | Unset): Stop returning results when the gap between consecutive scores
+                exceeds this percentage of the total score range (max - min).
+                Detects "elbows" in score distributions regardless of score scale.
+                For example, 30.0 stops when a gap spans 30% of the score range.
+                 Example: 30.0.
+            min_absolute_score (float | Unset): Hard minimum score threshold. Results with scores below this value
+                are excluded regardless of other pruning settings.
+                 Example: 0.01.
+            require_multi_index (bool | Unset): Only keep results that appear in multiple indexes (both full-text
+                and vector search). Useful for increasing precision by requiring
+                agreement between different retrieval methods.
+                 Default: False.
+            std_dev_threshold (float | Unset): Keep results within N standard deviations below the mean score.
+                For example, 1.0 keeps results with score >= mean - 1*stddev.
+                Useful for statistical outlier detection in result sets.
+                 Example: 1.5.
+    """
+
+    min_score_ratio: float | Unset = UNSET
+    max_score_gap_percent: float | Unset = UNSET
+    min_absolute_score: float | Unset = UNSET
+    require_multi_index: bool | Unset = False
+    std_dev_threshold: float | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        min_score_ratio = self.min_score_ratio
+
+        max_score_gap_percent = self.max_score_gap_percent
+
+        min_absolute_score = self.min_absolute_score
+
+        require_multi_index = self.require_multi_index
+
+        std_dev_threshold = self.std_dev_threshold
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if min_score_ratio is not UNSET:
+            field_dict["min_score_ratio"] = min_score_ratio
+        if max_score_gap_percent is not UNSET:
+            field_dict["max_score_gap_percent"] = max_score_gap_percent
+        if min_absolute_score is not UNSET:
+            field_dict["min_absolute_score"] = min_absolute_score
+        if require_multi_index is not UNSET:
+            field_dict["require_multi_index"] = require_multi_index
+        if std_dev_threshold is not UNSET:
+            field_dict["std_dev_threshold"] = std_dev_threshold
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        min_score_ratio = d.pop("min_score_ratio", UNSET)
+
+        max_score_gap_percent = d.pop("max_score_gap_percent", UNSET)
+
+        min_absolute_score = d.pop("min_absolute_score", UNSET)
+
+        require_multi_index = d.pop("require_multi_index", UNSET)
+
+        std_dev_threshold = d.pop("std_dev_threshold", UNSET)
+
+        pruner = cls(
+            min_score_ratio=min_score_ratio,
+            max_score_gap_percent=max_score_gap_percent,
+            min_absolute_score=min_absolute_score,
+            require_multi_index=require_multi_index,
+            std_dev_threshold=std_dev_threshold,
+        )
+
+        pruner.additional_properties = d
+        return pruner
+
+    @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