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

antfly/client_generated/models/inferenceschemas_config.py

@@ -0,0 +1,88 @@
+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.inference_level import InferenceLevel
+from ..models.inference_style import InferenceStyle
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="InferenceschemasConfig")
+
+
+@_attrs_define
+class InferenceschemasConfig:
+    """Logging configuration for inference services
+
+    Attributes:
+        level (InferenceLevel | Unset): Logging verbosity level Example: info.
+        style (InferenceStyle | Unset): Logging output format style. 'terminal' for colorized console, 'json' for
+            structured JSON, 'logfmt' for token-efficient key=value pairs, 'noop' for silent. Example: terminal.
+    """
+
+    level: InferenceLevel | Unset = UNSET
+    style: InferenceStyle | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        level: str | Unset = UNSET
+        if not isinstance(self.level, Unset):
+            level = self.level.value
+
+        style: str | Unset = UNSET
+        if not isinstance(self.style, Unset):
+            style = self.style.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if level is not UNSET:
+            field_dict["level"] = level
+        if style is not UNSET:
+            field_dict["style"] = style
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        _level = d.pop("level", UNSET)
+        level: InferenceLevel | Unset
+        if isinstance(_level, Unset):
+            level = UNSET
+        else:
+            level = InferenceLevel(_level)
+
+        _style = d.pop("style", UNSET)
+        style: InferenceStyle | Unset
+        if isinstance(_style, Unset):
+            style = UNSET
+        else:
+            style = InferenceStyle(_style)
+
+        inferenceschemas_config = cls(
+            level=level,
+            style=style,
+        )
+
+        inferenceschemas_config.additional_properties = d
+        return inferenceschemas_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/ip_range_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="IPRangeQuery")
+
+
+@_attrs_define
+class IPRangeQuery:
+    """
+    Attributes:
+        cidr (str):
+        field (str | Unset):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    cidr: 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]:
+        cidr = self.cidr
+
+        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(
+            {
+                "cidr": cidr,
+            }
+        )
+        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)
+        cidr = d.pop("cidr")
+
+        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))
+
+        ip_range_query = cls(
+            cidr=cidr,
+            field=field,
+            boost=boost,
+        )
+
+        ip_range_query.additional_properties = d
+        return ip_range_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/join_condition.py

@@ -0,0 +1,95 @@
+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.join_operator import JoinOperator
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="JoinCondition")
+
+
+@_attrs_define
+class JoinCondition:
+    """Condition for matching rows between tables.
+
+    Attributes:
+        left_field (str): Field from the left (primary) table to match on. Example: customer_id.
+        right_field (str): Field from the right (joined) table to match on. Example: id.
+        operator (JoinOperator | Unset): Comparison operator for join condition:
+            - `eq`: Equal (default)
+            - `neq`: Not equal
+            - `lt`: Less than
+            - `lte`: Less than or equal
+            - `gt`: Greater than
+            - `gte`: Greater than or equal
+    """
+
+    left_field: str
+    right_field: str
+    operator: JoinOperator | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        left_field = self.left_field
+
+        right_field = self.right_field
+
+        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(
+            {
+                "left_field": left_field,
+                "right_field": right_field,
+            }
+        )
+        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)
+        left_field = d.pop("left_field")
+
+        right_field = d.pop("right_field")
+
+        _operator = d.pop("operator", UNSET)
+        operator: JoinOperator | Unset
+        if isinstance(_operator, Unset):
+            operator = UNSET
+        else:
+            operator = JoinOperator(_operator)
+
+        join_condition = cls(
+            left_field=left_field,
+            right_field=right_field,
+            operator=operator,
+        )
+
+        join_condition.additional_properties = d
+        return join_condition
+
+    @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/join_operator.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class JoinOperator(str, Enum):
+    EQ = "eq"
+    GT = "gt"
+    GTE = "gte"
+    LT = "lt"
+    LTE = "lte"
+    NEQ = "neq"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/join_profile.py

@@ -0,0 +1,130 @@
+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.join_strategy import JoinStrategy
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="JoinProfile")
+
+
+@_attrs_define
+class JoinProfile:
+    """Join execution statistics.
+
+    Attributes:
+        strategy_used (JoinStrategy | Unset): Strategy for executing the join:
+            - `broadcast`: Broadcast small table to all shards of large table.
+              Best for dimension tables < 10MB. O(small_table) memory per shard.
+            - `index_lookup`: Use batch key lookups via indexes.
+              Best for selective joins with indexed join keys. Low memory overhead.
+            - `shuffle`: Hash-partition both tables by join key.
+              Best for large-large table joins. Requires data movement.
+        left_rows_scanned (int | Unset): Number of rows scanned from the left table.
+        right_rows_scanned (int | Unset): Number of rows scanned from the right table.
+        rows_matched (int | Unset): Number of rows that matched the join condition.
+        rows_unmatched_left (int | Unset): Number of left rows without a match (for left/full joins).
+        rows_unmatched_right (int | Unset): Number of right rows without a match (for right/full joins).
+        duration_ms (int | Unset): Time spent executing the join in milliseconds.
+    """
+
+    strategy_used: JoinStrategy | Unset = UNSET
+    left_rows_scanned: int | Unset = UNSET
+    right_rows_scanned: int | Unset = UNSET
+    rows_matched: int | Unset = UNSET
+    rows_unmatched_left: int | Unset = UNSET
+    rows_unmatched_right: int | Unset = UNSET
+    duration_ms: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        strategy_used: str | Unset = UNSET
+        if not isinstance(self.strategy_used, Unset):
+            strategy_used = self.strategy_used.value
+
+        left_rows_scanned = self.left_rows_scanned
+
+        right_rows_scanned = self.right_rows_scanned
+
+        rows_matched = self.rows_matched
+
+        rows_unmatched_left = self.rows_unmatched_left
+
+        rows_unmatched_right = self.rows_unmatched_right
+
+        duration_ms = self.duration_ms
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if strategy_used is not UNSET:
+            field_dict["strategy_used"] = strategy_used
+        if left_rows_scanned is not UNSET:
+            field_dict["left_rows_scanned"] = left_rows_scanned
+        if right_rows_scanned is not UNSET:
+            field_dict["right_rows_scanned"] = right_rows_scanned
+        if rows_matched is not UNSET:
+            field_dict["rows_matched"] = rows_matched
+        if rows_unmatched_left is not UNSET:
+            field_dict["rows_unmatched_left"] = rows_unmatched_left
+        if rows_unmatched_right is not UNSET:
+            field_dict["rows_unmatched_right"] = rows_unmatched_right
+        if duration_ms is not UNSET:
+            field_dict["duration_ms"] = duration_ms
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        _strategy_used = d.pop("strategy_used", UNSET)
+        strategy_used: JoinStrategy | Unset
+        if isinstance(_strategy_used, Unset):
+            strategy_used = UNSET
+        else:
+            strategy_used = JoinStrategy(_strategy_used)
+
+        left_rows_scanned = d.pop("left_rows_scanned", UNSET)
+
+        right_rows_scanned = d.pop("right_rows_scanned", UNSET)
+
+        rows_matched = d.pop("rows_matched", UNSET)
+
+        rows_unmatched_left = d.pop("rows_unmatched_left", UNSET)
+
+        rows_unmatched_right = d.pop("rows_unmatched_right", UNSET)
+
+        duration_ms = d.pop("duration_ms", UNSET)
+
+        join_profile = cls(
+            strategy_used=strategy_used,
+            left_rows_scanned=left_rows_scanned,
+            right_rows_scanned=right_rows_scanned,
+            rows_matched=rows_matched,
+            rows_unmatched_left=rows_unmatched_left,
+            rows_unmatched_right=rows_unmatched_right,
+            duration_ms=duration_ms,
+        )
+
+        join_profile.additional_properties = d
+        return join_profile
+
+    @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/join_strategy.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class JoinStrategy(str, Enum):
+    BROADCAST = "broadcast"
+    INDEX_LOOKUP = "index_lookup"
+    SHUFFLE = "shuffle"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/join_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class JoinType(str, Enum):
+    INNER = "inner"
+    LEFT = "left"
+    RIGHT = "right"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/key_range.py

@@ -0,0 +1,71 @@
+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="KeyRange")
+
+
+@_attrs_define
+class KeyRange:
+    """Key range processed in this request
+
+    Attributes:
+        from_ (str | Unset):
+        to (str | Unset):
+    """
+
+    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]:
+        from_ = self.from_
+
+        to = self.to
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        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)
+        from_ = d.pop("from", UNSET)
+
+        to = d.pop("to", UNSET)
+
+        key_range = cls(
+            from_=from_,
+            to=to,
+        )
+
+        key_range.additional_properties = d
+        return key_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/linear_merge_page_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class LinearMergePageStatus(str, Enum):
+    ERROR = "error"
+    PARTIAL = "partial"
+    SUCCESS = "success"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/linear_merge_request.py

@@ -0,0 +1,150 @@
+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.sync_level import SyncLevel
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.linear_merge_request_records import LinearMergeRequestRecords
+
+
+T = TypeVar("T", bound="LinearMergeRequest")
+
+
+@_attrs_define
+class LinearMergeRequest:
+    """Linear merge operation for syncing sorted records from external sources.
+    Use this to keep Antfly in sync with an external database or data source.
+
+    Requests may be sent as plain JSON or gzip-compressed JSON
+    (`Content-Encoding: gzip`).
+
+    Request bodies are limited to 64 MiB after decompression. Requests that
+    exceed this limit return HTTP 413.
+
+    **How it works:**
+    1. Send sorted records from your external source
+    2. Server upserts records that exist in your batch
+    3. Server deletes Antfly records in the key range that are absent from your batch
+    4. If stopped at shard boundary, use next_cursor for next request
+
+    **WARNING:** Not safe for concurrent operations with overlapping key ranges.
+
+        Attributes:
+            records (LinearMergeRequestRecords): Map of resource ID to resource object: {"resource_id_1": {...},
+                "resource_id_2": {...}}
+
+                Requirements:
+                - The server processes keys in lexicographic order
+                - Use consistent key naming (e.g., all start with same prefix)
+
+                This format avoids duplicate IDs and matches Antfly's batch write interface.
+                 Example: {'product:001': {'name': 'Laptop', 'price': 999.99}, 'product:002': {'name': 'Mouse', 'price': 29.99},
+                'product:003': {'name': 'Keyboard', 'price': 79.99}}.
+            last_merged_id (str | Unset): ID of last record from previous merge request.
+                - First request: Use empty string ""
+                - Subsequent requests: Use next_cursor from previous response
+                - Defines lower bound of key range to process
+
+                This enables pagination for large datasets.
+                 Example: product:003.
+            dry_run (bool | Unset): If true, returns what would be deleted without making changes.
+
+                Use cases:
+                - Validate sync behavior before committing
+                - Check which records will be removed
+                - Test key range boundaries
+
+                Response includes deleted_ids array when dry_run=true.
+                 Default: False.
+            sync_level (SyncLevel | Unset): Synchronization level for batch operations:
+                - "propose": Wait for Raft proposal acceptance (fastest, default)
+                - "write": Wait for Pebble KV write
+                - "full_text": Wait for full-text index WAL write
+                - "enrichments": Pre-compute enrichments before Raft proposal (synchronous enrichment generation)
+                - "aknn": Wait for vector index write with best-effort synchronous embedding (falls back to async on timeout,
+                slowest, most durable)
+                - "full_index": Wait for all index writes to complete (full-text + enrichments + aknn)
+    """
+
+    records: LinearMergeRequestRecords
+    last_merged_id: str | Unset = UNSET
+    dry_run: bool | Unset = False
+    sync_level: SyncLevel | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        records = self.records.to_dict()
+
+        last_merged_id = self.last_merged_id
+
+        dry_run = self.dry_run
+
+        sync_level: str | Unset = UNSET
+        if not isinstance(self.sync_level, Unset):
+            sync_level = self.sync_level.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "records": records,
+            }
+        )
+        if last_merged_id is not UNSET:
+            field_dict["last_merged_id"] = last_merged_id
+        if dry_run is not UNSET:
+            field_dict["dry_run"] = dry_run
+        if sync_level is not UNSET:
+            field_dict["sync_level"] = sync_level
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.linear_merge_request_records import LinearMergeRequestRecords
+
+        d = dict(src_dict)
+        records = LinearMergeRequestRecords.from_dict(d.pop("records"))
+
+        last_merged_id = d.pop("last_merged_id", UNSET)
+
+        dry_run = d.pop("dry_run", UNSET)
+
+        _sync_level = d.pop("sync_level", UNSET)
+        sync_level: SyncLevel | Unset
+        if isinstance(_sync_level, Unset):
+            sync_level = UNSET
+        else:
+            sync_level = SyncLevel(_sync_level)
+
+        linear_merge_request = cls(
+            records=records,
+            last_merged_id=last_merged_id,
+            dry_run=dry_run,
+            sync_level=sync_level,
+        )
+
+        linear_merge_request.additional_properties = d
+        return linear_merge_request
+
+    @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