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

antfly/client_generated/models/merge_profile.py

@@ -0,0 +1,101 @@
+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.merge_strategy import MergeStrategy
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MergeProfile")
+
+
+@_attrs_define
+class MergeProfile:
+    """Result merge statistics for hybrid search.
+
+    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
+        full_text_hits (int | Unset): Number of hits from full-text search before merge.
+        semantic_hits (int | Unset): Number of hits from semantic search before merge.
+        duration_ms (int | Unset): Time spent merging results in milliseconds.
+    """
+
+    strategy: MergeStrategy | Unset = UNSET
+    full_text_hits: int | Unset = UNSET
+    semantic_hits: 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: str | Unset = UNSET
+        if not isinstance(self.strategy, Unset):
+            strategy = self.strategy.value
+
+        full_text_hits = self.full_text_hits
+
+        semantic_hits = self.semantic_hits
+
+        duration_ms = self.duration_ms
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if strategy is not UNSET:
+            field_dict["strategy"] = strategy
+        if full_text_hits is not UNSET:
+            field_dict["full_text_hits"] = full_text_hits
+        if semantic_hits is not UNSET:
+            field_dict["semantic_hits"] = semantic_hits
+        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 = d.pop("strategy", UNSET)
+        strategy: MergeStrategy | Unset
+        if isinstance(_strategy, Unset):
+            strategy = UNSET
+        else:
+            strategy = MergeStrategy(_strategy)
+
+        full_text_hits = d.pop("full_text_hits", UNSET)
+
+        semantic_hits = d.pop("semantic_hits", UNSET)
+
+        duration_ms = d.pop("duration_ms", UNSET)
+
+        merge_profile = cls(
+            strategy=strategy,
+            full_text_hits=full_text_hits,
+            semantic_hits=semantic_hits,
+            duration_ms=duration_ms,
+        )
+
+        merge_profile.additional_properties = d
+        return merge_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/merge_strategy.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class MergeStrategy(str, Enum):
+    FAILOVER = "failover"
+    RRF = "rrf"
+    RSF = "rsf"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/multi_batch_request.py

@@ -0,0 +1,104 @@
+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.multi_batch_request_tables import MultiBatchRequestTables
+
+
+T = TypeVar("T", bound="MultiBatchRequest")
+
+
+@_attrs_define
+class MultiBatchRequest:
+    """Cross-table batch operations in a single atomic transaction.
+
+    Groups batch operations by table name. All operations across all tables
+    are committed atomically using distributed 2-phase commit (2PC).
+
+    **Atomicity**: Either all operations across all tables succeed, or none do.
+    This enables use cases like transferring a record from one table to another,
+    or maintaining referential integrity across tables.
+
+        Attributes:
+            tables (MultiBatchRequestTables): Map of table names to batch operations for that table.
+                Each entry follows the same format as a single-table BatchRequest.
+                 Example: {'users': {'inserts': {'user:123': {'name': 'John Doe', 'email': 'john@example.com'}}}, 'orders':
+                {'inserts': {'order:456': {'user_id': 'user:123', 'total': 99.99}}}}.
+            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)
+    """
+
+    tables: MultiBatchRequestTables
+    sync_level: SyncLevel | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        tables = self.tables.to_dict()
+
+        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(
+            {
+                "tables": tables,
+            }
+        )
+        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.multi_batch_request_tables import MultiBatchRequestTables
+
+        d = dict(src_dict)
+        tables = MultiBatchRequestTables.from_dict(d.pop("tables"))
+
+        _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)
+
+        multi_batch_request = cls(
+            tables=tables,
+            sync_level=sync_level,
+        )
+
+        multi_batch_request.additional_properties = d
+        return multi_batch_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

antfly/client_generated/models/multi_batch_request_tables.py

@@ -0,0 +1,67 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.batch_request import BatchRequest
+
+
+T = TypeVar("T", bound="MultiBatchRequestTables")
+
+
+@_attrs_define
+class MultiBatchRequestTables:
+    """Map of table names to batch operations for that table.
+    Each entry follows the same format as a single-table BatchRequest.
+
+        Example:
+            {'users': {'inserts': {'user:123': {'name': 'John Doe', 'email': 'john@example.com'}}}, 'orders': {'inserts':
+                {'order:456': {'user_id': 'user:123', 'total': 99.99}}}}
+
+    """
+
+    additional_properties: dict[str, BatchRequest] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.batch_request import BatchRequest
+
+        d = dict(src_dict)
+        multi_batch_request_tables = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = BatchRequest.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        multi_batch_request_tables.additional_properties = additional_properties
+        return multi_batch_request_tables
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> BatchRequest:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: BatchRequest) -> 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/multi_batch_response.py

@@ -0,0 +1,75 @@
+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.multi_batch_response_tables import MultiBatchResponseTables
+
+
+T = TypeVar("T", bound="MultiBatchResponse")
+
+
+@_attrs_define
+class MultiBatchResponse:
+    """Response for a cross-table batch operation. Contains per-table results.
+
+    Attributes:
+        tables (MultiBatchResponseTables | Unset): Per-table batch results
+    """
+
+    tables: MultiBatchResponseTables | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        tables: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.tables, Unset):
+            tables = self.tables.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if tables is not UNSET:
+            field_dict["tables"] = tables
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.multi_batch_response_tables import MultiBatchResponseTables
+
+        d = dict(src_dict)
+        _tables = d.pop("tables", UNSET)
+        tables: MultiBatchResponseTables | Unset
+        if isinstance(_tables, Unset):
+            tables = UNSET
+        else:
+            tables = MultiBatchResponseTables.from_dict(_tables)
+
+        multi_batch_response = cls(
+            tables=tables,
+        )
+
+        multi_batch_response.additional_properties = d
+        return multi_batch_response
+
+    @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/multi_batch_response_tables.py

@@ -0,0 +1,60 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.batch_response import BatchResponse
+
+
+T = TypeVar("T", bound="MultiBatchResponseTables")
+
+
+@_attrs_define
+class MultiBatchResponseTables:
+    """Per-table batch results"""
+
+    additional_properties: dict[str, BatchResponse] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.batch_response import BatchResponse
+
+        d = dict(src_dict)
+        multi_batch_response_tables = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = BatchResponse.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        multi_batch_response_tables.additional_properties = additional_properties
+        return multi_batch_response_tables
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> BatchResponse:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: BatchResponse) -> 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/multi_match_body.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 ..models.multi_match_body_type import MultiMatchBodyType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="MultiMatchBody")
+
+
+@_attrs_define
+class MultiMatchBody:
+    """
+    Attributes:
+        query (str):
+        fields (list[str]):
+        type_ (MultiMatchBodyType):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    query: str
+    fields: list[str]
+    type_: MultiMatchBodyType
+    boost: float | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        query = self.query
+
+        fields = self.fields
+
+        type_ = self.type_.value
+
+        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(
+            {
+                "query": query,
+                "fields": fields,
+                "type": type_,
+            }
+        )
+        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)
+        query = d.pop("query")
+
+        fields = cast(list[str], d.pop("fields"))
+
+        type_ = MultiMatchBodyType(d.pop("type"))
+
+        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))
+
+        multi_match_body = cls(
+            query=query,
+            fields=fields,
+            type_=type_,
+            boost=boost,
+        )
+
+        multi_match_body.additional_properties = d
+        return multi_match_body
+
+    @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/multi_match_body_type.py

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

antfly/client_generated/models/multi_match_query.py

@@ -0,0 +1,67 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.multi_match_body import MultiMatchBody
+
+
+T = TypeVar("T", bound="MultiMatchQuery")
+
+
+@_attrs_define
+class MultiMatchQuery:
+    """
+    Attributes:
+        multi_match (MultiMatchBody):
+    """
+
+    multi_match: MultiMatchBody
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        multi_match = self.multi_match.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "multi_match": multi_match,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.multi_match_body import MultiMatchBody
+
+        d = dict(src_dict)
+        multi_match = MultiMatchBody.from_dict(d.pop("multi_match"))
+
+        multi_match_query = cls(
+            multi_match=multi_match,
+        )
+
+        multi_match_query.additional_properties = d
+        return multi_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