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

antfly/client_generated/models/disjunction_query.py

@@ -0,0 +1,501 @@
+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.bool_field_query import BoolFieldQuery
+    from ..models.boolean_query import BooleanQuery
+    from ..models.conjunction_query import ConjunctionQuery
+    from ..models.date_range_string_query import DateRangeStringQuery
+    from ..models.doc_id_query import DocIdQuery
+    from ..models.fuzzy_query import FuzzyQuery
+    from ..models.geo_bounding_box_query import GeoBoundingBoxQuery
+    from ..models.geo_bounding_polygon_query import GeoBoundingPolygonQuery
+    from ..models.geo_distance_query import GeoDistanceQuery
+    from ..models.geo_shape_query import GeoShapeQuery
+    from ..models.ip_range_query import IPRangeQuery
+    from ..models.match_all_query import MatchAllQuery
+    from ..models.match_none_query import MatchNoneQuery
+    from ..models.match_phrase_query import MatchPhraseQuery
+    from ..models.match_query import MatchQuery
+    from ..models.multi_match_query import MultiMatchQuery
+    from ..models.multi_phrase_query import MultiPhraseQuery
+    from ..models.numeric_range_query import NumericRangeQuery
+    from ..models.phrase_query import PhraseQuery
+    from ..models.prefix_query import PrefixQuery
+    from ..models.query_string_query import QueryStringQuery
+    from ..models.regexp_query import RegexpQuery
+    from ..models.term_query import TermQuery
+    from ..models.term_range_query import TermRangeQuery
+    from ..models.wildcard_query import WildcardQuery
+
+
+T = TypeVar("T", bound="DisjunctionQuery")
+
+
+@_attrs_define
+class DisjunctionQuery:
+    """
+    Attributes:
+        disjuncts (list[BooleanQuery | BoolFieldQuery | ConjunctionQuery | DateRangeStringQuery | DisjunctionQuery |
+            DocIdQuery | FuzzyQuery | GeoBoundingBoxQuery | GeoBoundingPolygonQuery | GeoDistanceQuery | GeoShapeQuery |
+            IPRangeQuery | MatchAllQuery | MatchNoneQuery | MatchPhraseQuery | MatchQuery | MultiMatchQuery |
+            MultiPhraseQuery | NumericRangeQuery | PhraseQuery | PrefixQuery | QueryStringQuery | RegexpQuery | TermQuery |
+            TermRangeQuery | WildcardQuery]):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+        min_ (float | Unset):
+    """
+
+    disjuncts: list[
+        BooleanQuery
+        | BoolFieldQuery
+        | ConjunctionQuery
+        | DateRangeStringQuery
+        | DisjunctionQuery
+        | DocIdQuery
+        | FuzzyQuery
+        | GeoBoundingBoxQuery
+        | GeoBoundingPolygonQuery
+        | GeoDistanceQuery
+        | GeoShapeQuery
+        | IPRangeQuery
+        | MatchAllQuery
+        | MatchNoneQuery
+        | MatchPhraseQuery
+        | MatchQuery
+        | MultiMatchQuery
+        | MultiPhraseQuery
+        | NumericRangeQuery
+        | PhraseQuery
+        | PrefixQuery
+        | QueryStringQuery
+        | RegexpQuery
+        | TermQuery
+        | TermRangeQuery
+        | WildcardQuery
+    ]
+    boost: float | None | Unset = UNSET
+    min_: float | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.bool_field_query import BoolFieldQuery
+        from ..models.boolean_query import BooleanQuery
+        from ..models.conjunction_query import ConjunctionQuery
+        from ..models.date_range_string_query import DateRangeStringQuery
+        from ..models.doc_id_query import DocIdQuery
+        from ..models.fuzzy_query import FuzzyQuery
+        from ..models.geo_bounding_box_query import GeoBoundingBoxQuery
+        from ..models.geo_bounding_polygon_query import GeoBoundingPolygonQuery
+        from ..models.geo_distance_query import GeoDistanceQuery
+        from ..models.ip_range_query import IPRangeQuery
+        from ..models.match_all_query import MatchAllQuery
+        from ..models.match_none_query import MatchNoneQuery
+        from ..models.match_phrase_query import MatchPhraseQuery
+        from ..models.match_query import MatchQuery
+        from ..models.multi_match_query import MultiMatchQuery
+        from ..models.multi_phrase_query import MultiPhraseQuery
+        from ..models.numeric_range_query import NumericRangeQuery
+        from ..models.phrase_query import PhraseQuery
+        from ..models.prefix_query import PrefixQuery
+        from ..models.query_string_query import QueryStringQuery
+        from ..models.regexp_query import RegexpQuery
+        from ..models.term_query import TermQuery
+        from ..models.term_range_query import TermRangeQuery
+        from ..models.wildcard_query import WildcardQuery
+
+        disjuncts = []
+        for disjuncts_item_data in self.disjuncts:
+            disjuncts_item: dict[str, Any]
+            if isinstance(disjuncts_item_data, TermQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, MatchQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, MultiMatchQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, MatchPhraseQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, PhraseQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, MultiPhraseQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, FuzzyQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, PrefixQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, RegexpQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, WildcardQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, QueryStringQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, NumericRangeQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, TermRangeQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, DateRangeStringQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, BooleanQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, ConjunctionQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, DisjunctionQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, MatchAllQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, MatchNoneQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, DocIdQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, BoolFieldQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, IPRangeQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, GeoBoundingBoxQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, GeoDistanceQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            elif isinstance(disjuncts_item_data, GeoBoundingPolygonQuery):
+                disjuncts_item = disjuncts_item_data.to_dict()
+            else:
+                disjuncts_item = disjuncts_item_data.to_dict()
+
+            disjuncts.append(disjuncts_item)
+
+        boost: float | None | Unset
+        if isinstance(self.boost, Unset):
+            boost = UNSET
+        else:
+            boost = self.boost
+
+        min_ = self.min_
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "disjuncts": disjuncts,
+            }
+        )
+        if boost is not UNSET:
+            field_dict["boost"] = boost
+        if min_ is not UNSET:
+            field_dict["min"] = min_
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.bool_field_query import BoolFieldQuery
+        from ..models.boolean_query import BooleanQuery
+        from ..models.conjunction_query import ConjunctionQuery
+        from ..models.date_range_string_query import DateRangeStringQuery
+        from ..models.doc_id_query import DocIdQuery
+        from ..models.fuzzy_query import FuzzyQuery
+        from ..models.geo_bounding_box_query import GeoBoundingBoxQuery
+        from ..models.geo_bounding_polygon_query import GeoBoundingPolygonQuery
+        from ..models.geo_distance_query import GeoDistanceQuery
+        from ..models.geo_shape_query import GeoShapeQuery
+        from ..models.ip_range_query import IPRangeQuery
+        from ..models.match_all_query import MatchAllQuery
+        from ..models.match_none_query import MatchNoneQuery
+        from ..models.match_phrase_query import MatchPhraseQuery
+        from ..models.match_query import MatchQuery
+        from ..models.multi_match_query import MultiMatchQuery
+        from ..models.multi_phrase_query import MultiPhraseQuery
+        from ..models.numeric_range_query import NumericRangeQuery
+        from ..models.phrase_query import PhraseQuery
+        from ..models.prefix_query import PrefixQuery
+        from ..models.query_string_query import QueryStringQuery
+        from ..models.regexp_query import RegexpQuery
+        from ..models.term_query import TermQuery
+        from ..models.term_range_query import TermRangeQuery
+        from ..models.wildcard_query import WildcardQuery
+
+        d = dict(src_dict)
+        disjuncts = []
+        _disjuncts = d.pop("disjuncts")
+        for disjuncts_item_data in _disjuncts:
+
+            def _parse_disjuncts_item(
+                data: object,
+            ) -> (
+                BooleanQuery
+                | BoolFieldQuery
+                | ConjunctionQuery
+                | DateRangeStringQuery
+                | DisjunctionQuery
+                | DocIdQuery
+                | FuzzyQuery
+                | GeoBoundingBoxQuery
+                | GeoBoundingPolygonQuery
+                | GeoDistanceQuery
+                | GeoShapeQuery
+                | IPRangeQuery
+                | MatchAllQuery
+                | MatchNoneQuery
+                | MatchPhraseQuery
+                | MatchQuery
+                | MultiMatchQuery
+                | MultiPhraseQuery
+                | NumericRangeQuery
+                | PhraseQuery
+                | PrefixQuery
+                | QueryStringQuery
+                | RegexpQuery
+                | TermQuery
+                | TermRangeQuery
+                | WildcardQuery
+            ):
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_0 = TermQuery.from_dict(data)
+
+                    return componentsschemas_query_type_0
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_1 = MatchQuery.from_dict(data)
+
+                    return componentsschemas_query_type_1
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_2 = MultiMatchQuery.from_dict(data)
+
+                    return componentsschemas_query_type_2
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_3 = MatchPhraseQuery.from_dict(data)
+
+                    return componentsschemas_query_type_3
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_4 = PhraseQuery.from_dict(data)
+
+                    return componentsschemas_query_type_4
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_5 = MultiPhraseQuery.from_dict(data)
+
+                    return componentsschemas_query_type_5
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_6 = FuzzyQuery.from_dict(data)
+
+                    return componentsschemas_query_type_6
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_7 = PrefixQuery.from_dict(data)
+
+                    return componentsschemas_query_type_7
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_8 = RegexpQuery.from_dict(data)
+
+                    return componentsschemas_query_type_8
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_9 = WildcardQuery.from_dict(data)
+
+                    return componentsschemas_query_type_9
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_10 = QueryStringQuery.from_dict(data)
+
+                    return componentsschemas_query_type_10
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_11 = NumericRangeQuery.from_dict(data)
+
+                    return componentsschemas_query_type_11
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_12 = TermRangeQuery.from_dict(data)
+
+                    return componentsschemas_query_type_12
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_13 = DateRangeStringQuery.from_dict(data)
+
+                    return componentsschemas_query_type_13
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_14 = BooleanQuery.from_dict(data)
+
+                    return componentsschemas_query_type_14
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_15 = ConjunctionQuery.from_dict(data)
+
+                    return componentsschemas_query_type_15
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_16 = DisjunctionQuery.from_dict(data)
+
+                    return componentsschemas_query_type_16
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_17 = MatchAllQuery.from_dict(data)
+
+                    return componentsschemas_query_type_17
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_18 = MatchNoneQuery.from_dict(data)
+
+                    return componentsschemas_query_type_18
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_19 = DocIdQuery.from_dict(data)
+
+                    return componentsschemas_query_type_19
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_20 = BoolFieldQuery.from_dict(data)
+
+                    return componentsschemas_query_type_20
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_21 = IPRangeQuery.from_dict(data)
+
+                    return componentsschemas_query_type_21
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_22 = GeoBoundingBoxQuery.from_dict(data)
+
+                    return componentsschemas_query_type_22
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_23 = GeoDistanceQuery.from_dict(data)
+
+                    return componentsschemas_query_type_23
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_query_type_24 = GeoBoundingPolygonQuery.from_dict(data)
+
+                    return componentsschemas_query_type_24
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_query_type_25 = GeoShapeQuery.from_dict(data)
+
+                return componentsschemas_query_type_25
+
+            disjuncts_item = _parse_disjuncts_item(disjuncts_item_data)
+
+            disjuncts.append(disjuncts_item)
+
+        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))
+
+        min_ = d.pop("min", UNSET)
+
+        disjunction_query = cls(
+            disjuncts=disjuncts,
+            boost=boost,
+            min_=min_,
+        )
+
+        disjunction_query.additional_properties = d
+        return disjunction_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/distance_metric.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class DistanceMetric(str, Enum):
+    COSINE = "cosine"
+    INNER_PRODUCT = "inner_product"
+    L2_SQUARED = "l2_squared"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/distance_range.py

@@ -0,0 +1,81 @@
+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="DistanceRange")
+
+
+@_attrs_define
+class DistanceRange:
+    """
+    Attributes:
+        name (str): Name of the distance range bucket
+        from_ (float | Unset): Minimum distance (inclusive)
+        to (float | Unset): Maximum distance (exclusive)
+    """
+
+    name: str
+    from_: float | Unset = UNSET
+    to: float | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        from_ = self.from_
+
+        to = self.to
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if from_ is not UNSET:
+            field_dict["from"] = from_
+        if to is not UNSET:
+            field_dict["to"] = to
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        from_ = d.pop("from", UNSET)
+
+        to = d.pop("to", UNSET)
+
+        distance_range = cls(
+            name=name,
+            from_=from_,
+            to=to,
+        )
+
+        distance_range.additional_properties = d
+        return distance_range
+
+    @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/distance_unit.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class DistanceUnit(str, Enum):
+    FT = "ft"
+    KM = "km"
+    M = "m"
+    MI = "mi"
+    YD = "yd"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/doc_id_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="DocIdQuery")
+
+
+@_attrs_define
+class DocIdQuery:
+    """
+    Attributes:
+        ids (list[str]):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    ids: list[str]
+    boost: float | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ids = self.ids
+
+        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(
+            {
+                "ids": ids,
+            }
+        )
+        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)
+        ids = cast(list[str], d.pop("ids"))
+
+        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))
+
+        doc_id_query = cls(
+            ids=ids,
+            boost=boost,
+        )
+
+        doc_id_query.additional_properties = d
+        return doc_id_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