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

antfly/client_generated/models/aggregation_date_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="AggregationDateRange")
+
+
+@_attrs_define
+class AggregationDateRange:
+    """
+    Attributes:
+        name (str): Name of the date range bucket
+        from_ (str | Unset): Start date (ISO 8601 or relative like "now-7d")
+        to (str | Unset): End date (ISO 8601 or relative like "now")
+    """
+
+    name: str
+    from_: str | Unset = UNSET
+    to: str | 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)
+
+        aggregation_date_range = cls(
+            name=name,
+            from_=from_,
+            to=to,
+        )
+
+        aggregation_date_range.additional_properties = d
+        return aggregation_date_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/aggregation_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="AggregationRange")
+
+
+@_attrs_define
+class AggregationRange:
+    """
+    Attributes:
+        name (str): Name of the range bucket
+        from_ (float | Unset): Lower bound (inclusive)
+        to (float | Unset): Upper bound (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)
+
+        aggregation_range = cls(
+            name=name,
+            from_=from_,
+            to=to,
+        )
+
+        aggregation_range.additional_properties = d
+        return aggregation_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/aggregation_result.py

@@ -0,0 +1,160 @@
+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.aggregation_bucket import AggregationBucket
+
+
+T = TypeVar("T", bound="AggregationResult")
+
+
+@_attrs_define
+class AggregationResult:
+    """
+    Attributes:
+        value (float | Unset): Single value for metric aggregations (sum, avg, min, max, count, cardinality)
+        count (int | Unset): Document count for stats aggregations
+        min_ (float | Unset): Minimum value for stats aggregations
+        max_ (float | Unset): Maximum value for stats aggregations
+        sum_ (float | Unset): Sum for stats aggregations
+        sum_of_squares (float | Unset): Sum of squares for stats aggregations
+        avg (float | Unset): Average for stats aggregations
+        std_deviation (float | Unset): Standard deviation for stats aggregations
+        variance (float | Unset): Variance for stats aggregations
+        buckets (list[AggregationBucket] | Unset): Buckets for bucketing aggregations (terms, range, histogram, etc.)
+    """
+
+    value: float | Unset = UNSET
+    count: int | Unset = UNSET
+    min_: float | Unset = UNSET
+    max_: float | Unset = UNSET
+    sum_: float | Unset = UNSET
+    sum_of_squares: float | Unset = UNSET
+    avg: float | Unset = UNSET
+    std_deviation: float | Unset = UNSET
+    variance: float | Unset = UNSET
+    buckets: list[AggregationBucket] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        value = self.value
+
+        count = self.count
+
+        min_ = self.min_
+
+        max_ = self.max_
+
+        sum_ = self.sum_
+
+        sum_of_squares = self.sum_of_squares
+
+        avg = self.avg
+
+        std_deviation = self.std_deviation
+
+        variance = self.variance
+
+        buckets: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.buckets, Unset):
+            buckets = []
+            for buckets_item_data in self.buckets:
+                buckets_item = buckets_item_data.to_dict()
+                buckets.append(buckets_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if value is not UNSET:
+            field_dict["value"] = value
+        if count is not UNSET:
+            field_dict["count"] = count
+        if min_ is not UNSET:
+            field_dict["min"] = min_
+        if max_ is not UNSET:
+            field_dict["max"] = max_
+        if sum_ is not UNSET:
+            field_dict["sum"] = sum_
+        if sum_of_squares is not UNSET:
+            field_dict["sum_of_squares"] = sum_of_squares
+        if avg is not UNSET:
+            field_dict["avg"] = avg
+        if std_deviation is not UNSET:
+            field_dict["std_deviation"] = std_deviation
+        if variance is not UNSET:
+            field_dict["variance"] = variance
+        if buckets is not UNSET:
+            field_dict["buckets"] = buckets
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.aggregation_bucket import AggregationBucket
+
+        d = dict(src_dict)
+        value = d.pop("value", UNSET)
+
+        count = d.pop("count", UNSET)
+
+        min_ = d.pop("min", UNSET)
+
+        max_ = d.pop("max", UNSET)
+
+        sum_ = d.pop("sum", UNSET)
+
+        sum_of_squares = d.pop("sum_of_squares", UNSET)
+
+        avg = d.pop("avg", UNSET)
+
+        std_deviation = d.pop("std_deviation", UNSET)
+
+        variance = d.pop("variance", UNSET)
+
+        _buckets = d.pop("buckets", UNSET)
+        buckets: list[AggregationBucket] | Unset = UNSET
+        if _buckets is not UNSET:
+            buckets = []
+            for buckets_item_data in _buckets:
+                buckets_item = AggregationBucket.from_dict(buckets_item_data)
+
+                buckets.append(buckets_item)
+
+        aggregation_result = cls(
+            value=value,
+            count=count,
+            min_=min_,
+            max_=max_,
+            sum_=sum_,
+            sum_of_squares=sum_of_squares,
+            avg=avg,
+            std_deviation=std_deviation,
+            variance=variance,
+            buckets=buckets,
+        )
+
+        aggregation_result.additional_properties = d
+        return aggregation_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/aggregation_type.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+
+class AggregationType(str, Enum):
+    AVG = "avg"
+    CARDINALITY = "cardinality"
+    COUNT = "count"
+    DATE_HISTOGRAM = "date_histogram"
+    DATE_RANGE = "date_range"
+    GEOHASH_GRID = "geohash_grid"
+    GEO_DISTANCE = "geo_distance"
+    HISTOGRAM = "histogram"
+    MAX = "max"
+    MIN = "min"
+    RANGE = "range"
+    SIGNIFICANT_TERMS = "significant_terms"
+    STATS = "stats"
+    SUM = "sum"
+    SUMSQUARES = "sumsquares"
+    TERMS = "terms"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/algebraic_aggregation_join.py

@@ -0,0 +1,96 @@
+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.algebraic_aggregation_join_kind import AlgebraicAggregationJoinKind
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="AlgebraicAggregationJoin")
+
+
+@_attrs_define
+class AlgebraicAggregationJoin:
+    """
+    Attributes:
+        name (str): Algebraic join materialization or capability name
+        group_side (str): Join side that supplies grouping bucket values
+        measure_side (str): Join side that supplies metric values
+        kind (AlgebraicAggregationJoinKind | Unset): Temporal join mode for the algebraic materialization
+    """
+
+    name: str
+    group_side: str
+    measure_side: str
+    kind: AlgebraicAggregationJoinKind | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        group_side = self.group_side
+
+        measure_side = self.measure_side
+
+        kind: str | Unset = UNSET
+        if not isinstance(self.kind, Unset):
+            kind = self.kind.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "group_side": group_side,
+                "measure_side": measure_side,
+            }
+        )
+        if kind is not UNSET:
+            field_dict["kind"] = kind
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        group_side = d.pop("group_side")
+
+        measure_side = d.pop("measure_side")
+
+        _kind = d.pop("kind", UNSET)
+        kind: AlgebraicAggregationJoinKind | Unset
+        if isinstance(_kind, Unset):
+            kind = UNSET
+        else:
+            kind = AlgebraicAggregationJoinKind(_kind)
+
+        algebraic_aggregation_join = cls(
+            name=name,
+            group_side=group_side,
+            measure_side=measure_side,
+            kind=kind,
+        )
+
+        algebraic_aggregation_join.additional_properties = d
+        return algebraic_aggregation_join
+
+    @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/algebraic_aggregation_join_kind.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class AlgebraicAggregationJoinKind(str, Enum):
+    BUCKET = "bucket"
+    BUCKET_WINDOW = "bucket_window"
+    NONE = "none"
+    WINDOW = "window"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/algebraic_index_config.py

@@ -0,0 +1,64 @@
+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="AlgebraicIndexConfig")
+
+
+@_attrs_define
+class AlgebraicIndexConfig:
+    """Schema-derived algebraic sidecar configuration. Public requests may opt into schema derivation, while
+    materializations remain engine-owned.
+
+        Attributes:
+            derive_from_schema (bool | Unset): When true, derive the algebraic capability sidecar from the table schema.
+                Internal fields and materialization definitions are not public API.
+    """
+
+    derive_from_schema: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        derive_from_schema = self.derive_from_schema
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if derive_from_schema is not UNSET:
+            field_dict["derive_from_schema"] = derive_from_schema
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        derive_from_schema = d.pop("derive_from_schema", UNSET)
+
+        algebraic_index_config = cls(
+            derive_from_schema=derive_from_schema,
+        )
+
+        algebraic_index_config.additional_properties = d
+        return algebraic_index_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