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

antfly/client_generated/models/fuzzy_query.py

@@ -0,0 +1,131 @@
+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="FuzzyQuery")
+
+
+@_attrs_define
+class FuzzyQuery:
+    """
+    Attributes:
+        term (str):
+        prefix_length (int | Unset):
+        fuzziness (FuzzinessType1 | int | Unset): The fuzziness of the query. Can be an integer or "auto".
+        field (str | Unset):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    term: str
+    prefix_length: int | Unset = UNSET
+    fuzziness: FuzzinessType1 | int | Unset = UNSET
+    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]:
+        term = self.term
+
+        prefix_length = self.prefix_length
+
+        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 = 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(
+            {
+                "term": term,
+            }
+        )
+        if prefix_length is not UNSET:
+            field_dict["prefix_length"] = prefix_length
+        if fuzziness is not UNSET:
+            field_dict["fuzziness"] = fuzziness
+        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)
+        term = d.pop("term")
+
+        prefix_length = d.pop("prefix_length", 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))
+
+        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))
+
+        fuzzy_query = cls(
+            term=term,
+            prefix_length=prefix_length,
+            fuzziness=fuzziness,
+            field=field,
+            boost=boost,
+        )
+
+        fuzzy_query.additional_properties = d
+        return fuzzy_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/generation_step_config.py

@@ -0,0 +1,128 @@
+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.chain_link import ChainLink
+    from ..models.generator_config import GeneratorConfig
+
+
+T = TypeVar("T", bound="GenerationStepConfig")
+
+
+@_attrs_define
+class GenerationStepConfig:
+    """Configuration for the generation step. This step generates the final
+    response from retrieved documents using the reasoning as context.
+
+        Attributes:
+            enabled (bool | Unset): Enable generation from retrieved documents Default: False.
+            generator (GeneratorConfig | Unset): A unified configuration for a generative AI provider.
+                 Example: {'provider': 'openai', 'model': 'gpt-4.1', 'temperature': 0.7, 'max_tokens': 2048}.
+            chain (list[ChainLink] | Unset): Chain of generators to try in order. Mutually exclusive with 'generator'.
+            system_prompt (str | Unset): Custom system prompt for answer generation
+            generation_context (str | Unset): Custom guidance for generation tone, detail level, and style Example: Be
+                concise and technical. Include code examples where relevant..
+    """
+
+    enabled: bool | Unset = False
+    generator: GeneratorConfig | Unset = UNSET
+    chain: list[ChainLink] | Unset = UNSET
+    system_prompt: str | Unset = UNSET
+    generation_context: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        enabled = self.enabled
+
+        generator: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.generator, Unset):
+            generator = self.generator.to_dict()
+
+        chain: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.chain, Unset):
+            chain = []
+            for chain_item_data in self.chain:
+                chain_item = chain_item_data.to_dict()
+                chain.append(chain_item)
+
+        system_prompt = self.system_prompt
+
+        generation_context = self.generation_context
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if enabled is not UNSET:
+            field_dict["enabled"] = enabled
+        if generator is not UNSET:
+            field_dict["generator"] = generator
+        if chain is not UNSET:
+            field_dict["chain"] = chain
+        if system_prompt is not UNSET:
+            field_dict["system_prompt"] = system_prompt
+        if generation_context is not UNSET:
+            field_dict["generation_context"] = generation_context
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.chain_link import ChainLink
+        from ..models.generator_config import GeneratorConfig
+
+        d = dict(src_dict)
+        enabled = d.pop("enabled", UNSET)
+
+        _generator = d.pop("generator", UNSET)
+        generator: GeneratorConfig | Unset
+        if isinstance(_generator, Unset):
+            generator = UNSET
+        else:
+            generator = GeneratorConfig.from_dict(_generator)
+
+        _chain = d.pop("chain", UNSET)
+        chain: list[ChainLink] | Unset = UNSET
+        if _chain is not UNSET:
+            chain = []
+            for chain_item_data in _chain:
+                chain_item = ChainLink.from_dict(chain_item_data)
+
+                chain.append(chain_item)
+
+        system_prompt = d.pop("system_prompt", UNSET)
+
+        generation_context = d.pop("generation_context", UNSET)
+
+        generation_step_config = cls(
+            enabled=enabled,
+            generator=generator,
+            chain=chain,
+            system_prompt=system_prompt,
+            generation_context=generation_context,
+        )
+
+        generation_step_config.additional_properties = d
+        return generation_step_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/generator_config.py

@@ -0,0 +1,67 @@
+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.generator_provider import GeneratorProvider
+
+T = TypeVar("T", bound="GeneratorConfig")
+
+
+@_attrs_define
+class GeneratorConfig:
+    """A unified configuration for a generative AI provider.
+
+    Example:
+        {'provider': 'openai', 'model': 'gpt-4.1', 'temperature': 0.7, 'max_tokens': 2048}
+
+    Attributes:
+        provider (GeneratorProvider): The generative AI provider to use.
+    """
+
+    provider: GeneratorProvider
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        provider = self.provider.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "provider": provider,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        provider = GeneratorProvider(d.pop("provider"))
+
+        generator_config = cls(
+            provider=provider,
+        )
+
+        generator_config.additional_properties = d
+        return generator_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/generator_provider.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+
+class GeneratorProvider(str, Enum):
+    ANTFLY = "antfly"
+    ANTHROPIC = "anthropic"
+    BEDROCK = "bedrock"
+    COHERE = "cohere"
+    GEMINI = "gemini"
+    MOCK = "mock"
+    OLLAMA = "ollama"
+    OPENAI = "openai"
+    OPENROUTER = "openrouter"
+    VERTEX = "vertex"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/geo_bounding_box_query.py

@@ -0,0 +1,101 @@
+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="GeoBoundingBoxQuery")
+
+
+@_attrs_define
+class GeoBoundingBoxQuery:
+    """
+    Attributes:
+        top_left (list[float]): [lon, lat]
+        bottom_right (list[float]): [lon, lat]
+        field (str | Unset):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    top_left: list[float]
+    bottom_right: list[float]
+    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]:
+        top_left = self.top_left
+
+        bottom_right = self.bottom_right
+
+        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(
+            {
+                "top_left": top_left,
+                "bottom_right": bottom_right,
+            }
+        )
+        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)
+        top_left = cast(list[float], d.pop("top_left"))
+
+        bottom_right = cast(list[float], d.pop("bottom_right"))
+
+        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))
+
+        geo_bounding_box_query = cls(
+            top_left=top_left,
+            bottom_right=bottom_right,
+            field=field,
+            boost=boost,
+        )
+
+        geo_bounding_box_query.additional_properties = d
+        return geo_bounding_box_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/geo_bounding_polygon_query.py

@@ -0,0 +1,107 @@
+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.geo_point import GeoPoint
+
+
+T = TypeVar("T", bound="GeoBoundingPolygonQuery")
+
+
+@_attrs_define
+class GeoBoundingPolygonQuery:
+    """
+    Attributes:
+        polygon_points (list[GeoPoint]):
+        field (str | Unset):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    polygon_points: list[GeoPoint]
+    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]:
+        polygon_points = []
+        for polygon_points_item_data in self.polygon_points:
+            polygon_points_item = polygon_points_item_data.to_dict()
+            polygon_points.append(polygon_points_item)
+
+        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(
+            {
+                "polygon_points": polygon_points,
+            }
+        )
+        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:
+        from ..models.geo_point import GeoPoint
+
+        d = dict(src_dict)
+        polygon_points = []
+        _polygon_points = d.pop("polygon_points")
+        for polygon_points_item_data in _polygon_points:
+            polygon_points_item = GeoPoint.from_dict(polygon_points_item_data)
+
+            polygon_points.append(polygon_points_item)
+
+        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))
+
+        geo_bounding_polygon_query = cls(
+            polygon_points=polygon_points,
+            field=field,
+            boost=boost,
+        )
+
+        geo_bounding_polygon_query.additional_properties = d
+        return geo_bounding_polygon_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/geo_distance_query.py

@@ -0,0 +1,101 @@
+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="GeoDistanceQuery")
+
+
+@_attrs_define
+class GeoDistanceQuery:
+    """
+    Attributes:
+        location (list[float]): [lon, lat]
+        distance (str):  Example: 10km.
+        field (str | Unset):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    location: list[float]
+    distance: 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]:
+        location = self.location
+
+        distance = self.distance
+
+        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(
+            {
+                "location": location,
+                "distance": distance,
+            }
+        )
+        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)
+        location = cast(list[float], d.pop("location"))
+
+        distance = d.pop("distance")
+
+        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))
+
+        geo_distance_query = cls(
+            location=location,
+            distance=distance,
+            field=field,
+            boost=boost,
+        )
+
+        geo_distance_query.additional_properties = d
+        return geo_distance_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