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

antfly/client_generated/models/match_none_query_match_none.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="MatchNoneQueryMatchNone")
+
+
+@_attrs_define
+class MatchNoneQueryMatchNone:
+    """ """
+
+    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)
+        match_none_query_match_none = cls()
+
+        match_none_query_match_none.additional_properties = d
+        return match_none_query_match_none
+
+    @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/match_phrase_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="MatchPhraseQuery")
+
+
+@_attrs_define
+class MatchPhraseQuery:
+    """
+    Attributes:
+        match_phrase (str):
+        field (str | Unset):
+        analyzer (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".
+    """
+
+    match_phrase: str
+    field: str | Unset = UNSET
+    analyzer: 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]:
+        match_phrase = self.match_phrase
+
+        field = self.field
+
+        analyzer = self.analyzer
+
+        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(
+            {
+                "match_phrase": match_phrase,
+            }
+        )
+        if field is not UNSET:
+            field_dict["field"] = field
+        if analyzer is not UNSET:
+            field_dict["analyzer"] = analyzer
+        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)
+        match_phrase = d.pop("match_phrase")
+
+        field = d.pop("field", UNSET)
+
+        analyzer = d.pop("analyzer", 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))
+
+        match_phrase_query = cls(
+            match_phrase=match_phrase,
+            field=field,
+            analyzer=analyzer,
+            boost=boost,
+            fuzziness=fuzziness,
+        )
+
+        match_phrase_query.additional_properties = d
+        return match_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/match_query.py

@@ -0,0 +1,157 @@
+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 ..models.match_query_operator import MatchQueryOperator
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MatchQuery")
+
+
+@_attrs_define
+class MatchQuery:
+    """
+    Attributes:
+        match (str):
+        field (str | Unset):
+        analyzer (str | Unset):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+        prefix_length (int | Unset):
+        fuzziness (FuzzinessType1 | int | Unset): The fuzziness of the query. Can be an integer or "auto".
+        operator (MatchQueryOperator | Unset):
+    """
+
+    match: str
+    field: str | Unset = UNSET
+    analyzer: str | Unset = UNSET
+    boost: float | None | Unset = UNSET
+    prefix_length: int | Unset = UNSET
+    fuzziness: FuzzinessType1 | int | Unset = UNSET
+    operator: MatchQueryOperator | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        match = self.match
+
+        field = self.field
+
+        analyzer = self.analyzer
+
+        boost: float | None | Unset
+        if isinstance(self.boost, Unset):
+            boost = UNSET
+        else:
+            boost = self.boost
+
+        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
+
+        operator: str | Unset = UNSET
+        if not isinstance(self.operator, Unset):
+            operator = self.operator.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "match": match,
+            }
+        )
+        if field is not UNSET:
+            field_dict["field"] = field
+        if analyzer is not UNSET:
+            field_dict["analyzer"] = analyzer
+        if boost is not UNSET:
+            field_dict["boost"] = boost
+        if prefix_length is not UNSET:
+            field_dict["prefix_length"] = prefix_length
+        if fuzziness is not UNSET:
+            field_dict["fuzziness"] = fuzziness
+        if operator is not UNSET:
+            field_dict["operator"] = operator
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        match = d.pop("match")
+
+        field = d.pop("field", UNSET)
+
+        analyzer = d.pop("analyzer", 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_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))
+
+        _operator = d.pop("operator", UNSET)
+        operator: MatchQueryOperator | Unset
+        if isinstance(_operator, Unset):
+            operator = UNSET
+        else:
+            operator = MatchQueryOperator(_operator)
+
+        match_query = cls(
+            match=match,
+            field=field,
+            analyzer=analyzer,
+            boost=boost,
+            prefix_length=prefix_length,
+            fuzziness=fuzziness,
+            operator=operator,
+        )
+
+        match_query.additional_properties = d
+        return match_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/match_query_operator.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class MatchQueryOperator(str, Enum):
+    AND = "and"
+    OR = "or"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/media_content_part.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.media_content_part_type import MediaContentPartType
+
+T = TypeVar("T", bound="MediaContentPart")
+
+
+@_attrs_define
+class MediaContentPart:
+    """Inline binary media content (audio, image, etc.).
+
+    Attributes:
+        type_ (MediaContentPartType):
+        data (str): Base64-encoded binary data.
+        mime_type (str): MIME type (audio/wav, image/gif, image/png, etc.).
+    """
+
+    type_: MediaContentPartType
+    data: str
+    mime_type: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_.value
+
+        data = self.data
+
+        mime_type = self.mime_type
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "data": data,
+                "mime_type": mime_type,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        type_ = MediaContentPartType(d.pop("type"))
+
+        data = d.pop("data")
+
+        mime_type = d.pop("mime_type")
+
+        media_content_part = cls(
+            type_=type_,
+            data=data,
+            mime_type=mime_type,
+        )
+
+        media_content_part.additional_properties = d
+        return media_content_part
+
+    @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/media_content_part_type.py

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

antfly/client_generated/models/merge_config.py

@@ -0,0 +1,118 @@
+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.merge_strategy import MergeStrategy
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.merge_config_weights import MergeConfigWeights
+
+
+T = TypeVar("T", bound="MergeConfig")
+
+
+@_attrs_define
+class MergeConfig:
+    """Configuration for result fusion when combining multiple search indexes.
+
+    Attributes:
+        strategy (MergeStrategy | Unset): Merge strategy for combining results from the semantic_search and
+            full_text_search.
+            rrf: Reciprocal Rank Fusion - combines scores using reciprocal rank formula
+            rsf: Relative Score Fusion - normalizes scores by min/max within a window and combines weighted scores
+            failover: Use full_text_search if embedding generation fails
+        weights (MergeConfigWeights | Unset): Named weights keyed by index name. `full_text` for the full-text search
+            index;
+            embedding index names for vector indexes.
+            Unspecified indexes default to 1.0. Applied in both RRF and RSF.
+             Example: {'full_text': 0.3, 'title_embedding': 1.0}.
+        window_size (int | Unset): RSF normalization window size. Defaults to `limit`.
+        rank_constant (float | Unset): RRF k constant (1/(k+rank)). Defaults to 60.0.
+    """
+
+    strategy: MergeStrategy | Unset = UNSET
+    weights: MergeConfigWeights | Unset = UNSET
+    window_size: int | Unset = UNSET
+    rank_constant: float | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        strategy: str | Unset = UNSET
+        if not isinstance(self.strategy, Unset):
+            strategy = self.strategy.value
+
+        weights: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.weights, Unset):
+            weights = self.weights.to_dict()
+
+        window_size = self.window_size
+
+        rank_constant = self.rank_constant
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if strategy is not UNSET:
+            field_dict["strategy"] = strategy
+        if weights is not UNSET:
+            field_dict["weights"] = weights
+        if window_size is not UNSET:
+            field_dict["window_size"] = window_size
+        if rank_constant is not UNSET:
+            field_dict["rank_constant"] = rank_constant
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.merge_config_weights import MergeConfigWeights
+
+        d = dict(src_dict)
+        _strategy = d.pop("strategy", UNSET)
+        strategy: MergeStrategy | Unset
+        if isinstance(_strategy, Unset):
+            strategy = UNSET
+        else:
+            strategy = MergeStrategy(_strategy)
+
+        _weights = d.pop("weights", UNSET)
+        weights: MergeConfigWeights | Unset
+        if isinstance(_weights, Unset):
+            weights = UNSET
+        else:
+            weights = MergeConfigWeights.from_dict(_weights)
+
+        window_size = d.pop("window_size", UNSET)
+
+        rank_constant = d.pop("rank_constant", UNSET)
+
+        merge_config = cls(
+            strategy=strategy,
+            weights=weights,
+            window_size=window_size,
+            rank_constant=rank_constant,
+        )
+
+        merge_config.additional_properties = d
+        return merge_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/merge_config_weights.py

@@ -0,0 +1,54 @@
+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="MergeConfigWeights")
+
+
+@_attrs_define
+class MergeConfigWeights:
+    """Named weights keyed by index name. `full_text` for the full-text search index;
+    embedding index names for vector indexes.
+    Unspecified indexes default to 1.0. Applied in both RRF and RSF.
+
+        Example:
+            {'full_text': 0.3, 'title_embedding': 1.0}
+
+    """
+
+    additional_properties: dict[str, float] = _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)
+        merge_config_weights = cls()
+
+        merge_config_weights.additional_properties = d
+        return merge_config_weights
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> float:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: float) -> 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