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

antfly/client_generated/models/linear_merge_request_records.py

@@ -0,0 +1,59 @@
+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="LinearMergeRequestRecords")
+
+
+@_attrs_define
+class 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}}
+
+    """
+
+    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)
+        linear_merge_request_records = cls()
+
+        linear_merge_request_records.additional_properties = d
+        return linear_merge_request_records
+
+    @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_result.py

@@ -0,0 +1,183 @@
+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 ..models.linear_merge_page_status import LinearMergePageStatus
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.failed_operation import FailedOperation
+    from ..models.key_range import KeyRange
+
+
+T = TypeVar("T", bound="LinearMergeResult")
+
+
+@_attrs_define
+class LinearMergeResult:
+    """
+    Attributes:
+        status (LinearMergePageStatus): Status of a linear merge page operation:
+            - "success": All records in batch processed successfully
+            - "partial": Processing stopped at shard boundary, client should retry with next_cursor
+            - "error": Fatal error occurred, no records processed successfully
+        upserted (int): Records inserted or updated (0 if dry_run=true)
+        skipped (int): Records skipped because content hash matched (unchanged)
+        deleted (int): Records deleted or would be deleted (if dry_run=true)
+        next_cursor (str): ID of last record in this batch (use for next request)
+        deleted_ids (list[str] | Unset): IDs that were deleted (or would be deleted if dry_run=true). Only included if
+            dry_run=true.
+        failed (list[FailedOperation] | Unset):
+        key_range (KeyRange | Unset): Key range processed in this request
+        keys_scanned (int | Unset): Total number of keys scanned from Antfly during range query
+        message (str | Unset): Additional information (e.g., "stopped at shard boundary", "dry run - no changes made")
+        took (int | Unset):
+    """
+
+    status: LinearMergePageStatus
+    upserted: int
+    skipped: int
+    deleted: int
+    next_cursor: str
+    deleted_ids: list[str] | Unset = UNSET
+    failed: list[FailedOperation] | Unset = UNSET
+    key_range: KeyRange | Unset = UNSET
+    keys_scanned: int | Unset = UNSET
+    message: str | Unset = UNSET
+    took: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status.value
+
+        upserted = self.upserted
+
+        skipped = self.skipped
+
+        deleted = self.deleted
+
+        next_cursor = self.next_cursor
+
+        deleted_ids: list[str] | Unset = UNSET
+        if not isinstance(self.deleted_ids, Unset):
+            deleted_ids = self.deleted_ids
+
+        failed: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.failed, Unset):
+            failed = []
+            for failed_item_data in self.failed:
+                failed_item = failed_item_data.to_dict()
+                failed.append(failed_item)
+
+        key_range: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.key_range, Unset):
+            key_range = self.key_range.to_dict()
+
+        keys_scanned = self.keys_scanned
+
+        message = self.message
+
+        took = self.took
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+                "upserted": upserted,
+                "skipped": skipped,
+                "deleted": deleted,
+                "next_cursor": next_cursor,
+            }
+        )
+        if deleted_ids is not UNSET:
+            field_dict["deleted_ids"] = deleted_ids
+        if failed is not UNSET:
+            field_dict["failed"] = failed
+        if key_range is not UNSET:
+            field_dict["key_range"] = key_range
+        if keys_scanned is not UNSET:
+            field_dict["keys_scanned"] = keys_scanned
+        if message is not UNSET:
+            field_dict["message"] = message
+        if took is not UNSET:
+            field_dict["took"] = took
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.failed_operation import FailedOperation
+        from ..models.key_range import KeyRange
+
+        d = dict(src_dict)
+        status = LinearMergePageStatus(d.pop("status"))
+
+        upserted = d.pop("upserted")
+
+        skipped = d.pop("skipped")
+
+        deleted = d.pop("deleted")
+
+        next_cursor = d.pop("next_cursor")
+
+        deleted_ids = cast(list[str], d.pop("deleted_ids", UNSET))
+
+        _failed = d.pop("failed", UNSET)
+        failed: list[FailedOperation] | Unset = UNSET
+        if _failed is not UNSET:
+            failed = []
+            for failed_item_data in _failed:
+                failed_item = FailedOperation.from_dict(failed_item_data)
+
+                failed.append(failed_item)
+
+        _key_range = d.pop("key_range", UNSET)
+        key_range: KeyRange | Unset
+        if isinstance(_key_range, Unset):
+            key_range = UNSET
+        else:
+            key_range = KeyRange.from_dict(_key_range)
+
+        keys_scanned = d.pop("keys_scanned", UNSET)
+
+        message = d.pop("message", UNSET)
+
+        took = d.pop("took", UNSET)
+
+        linear_merge_result = cls(
+            status=status,
+            upserted=upserted,
+            skipped=skipped,
+            deleted=deleted,
+            next_cursor=next_cursor,
+            deleted_ids=deleted_ids,
+            failed=failed,
+            key_range=key_range,
+            keys_scanned=keys_scanned,
+            message=message,
+            took=took,
+        )
+
+        linear_merge_result.additional_properties = d
+        return linear_merge_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/list_users_response_200_item.py

@@ -0,0 +1,61 @@
+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="ListUsersResponse200Item")
+
+
+@_attrs_define
+class ListUsersResponse200Item:
+    """
+    Attributes:
+        username (str | Unset):  Example: johndoe.
+    """
+
+    username: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        username = self.username
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if username is not UNSET:
+            field_dict["username"] = username
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        username = d.pop("username", UNSET)
+
+        list_users_response_200_item = cls(
+            username=username,
+        )
+
+        list_users_response_200_item.additional_properties = d
+        return list_users_response_200_item
+
+    @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/lookup_key_response_200.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="LookupKeyResponse200")
+
+
+@_attrs_define
+class LookupKeyResponse200:
+    """ """
+
+    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)
+        lookup_key_response_200 = cls()
+
+        lookup_key_response_200.additional_properties = d
+        return lookup_key_response_200
+
+    @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/lsm_storage_status.py

@@ -0,0 +1,116 @@
+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="LsmStorageStatus")
+
+
+@_attrs_define
+class LsmStorageStatus:
+    """Compact LSM backend operational status. Detailed low-level counters are available through metrics.
+
+    Attributes:
+        run_count (int | Unset):
+        run_bytes (int | Unset):
+        l0_run_count (int | Unset):
+        l0_bytes (int | Unset):
+        wal_retained_bytes (int | Unset):
+        compaction_backlog_bytes (int | Unset):
+        active_readers (int | Unset):
+    """
+
+    run_count: int | Unset = UNSET
+    run_bytes: int | Unset = UNSET
+    l0_run_count: int | Unset = UNSET
+    l0_bytes: int | Unset = UNSET
+    wal_retained_bytes: int | Unset = UNSET
+    compaction_backlog_bytes: int | Unset = UNSET
+    active_readers: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        run_count = self.run_count
+
+        run_bytes = self.run_bytes
+
+        l0_run_count = self.l0_run_count
+
+        l0_bytes = self.l0_bytes
+
+        wal_retained_bytes = self.wal_retained_bytes
+
+        compaction_backlog_bytes = self.compaction_backlog_bytes
+
+        active_readers = self.active_readers
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if run_count is not UNSET:
+            field_dict["run_count"] = run_count
+        if run_bytes is not UNSET:
+            field_dict["run_bytes"] = run_bytes
+        if l0_run_count is not UNSET:
+            field_dict["l0_run_count"] = l0_run_count
+        if l0_bytes is not UNSET:
+            field_dict["l0_bytes"] = l0_bytes
+        if wal_retained_bytes is not UNSET:
+            field_dict["wal_retained_bytes"] = wal_retained_bytes
+        if compaction_backlog_bytes is not UNSET:
+            field_dict["compaction_backlog_bytes"] = compaction_backlog_bytes
+        if active_readers is not UNSET:
+            field_dict["active_readers"] = active_readers
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        run_count = d.pop("run_count", UNSET)
+
+        run_bytes = d.pop("run_bytes", UNSET)
+
+        l0_run_count = d.pop("l0_run_count", UNSET)
+
+        l0_bytes = d.pop("l0_bytes", UNSET)
+
+        wal_retained_bytes = d.pop("wal_retained_bytes", UNSET)
+
+        compaction_backlog_bytes = d.pop("compaction_backlog_bytes", UNSET)
+
+        active_readers = d.pop("active_readers", UNSET)
+
+        lsm_storage_status = cls(
+            run_count=run_count,
+            run_bytes=run_bytes,
+            l0_run_count=l0_run_count,
+            l0_bytes=l0_bytes,
+            wal_retained_bytes=wal_retained_bytes,
+            compaction_backlog_bytes=compaction_backlog_bytes,
+            active_readers=active_readers,
+        )
+
+        lsm_storage_status.additional_properties = d
+        return lsm_storage_status
+
+    @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_all_query.py

@@ -0,0 +1,90 @@
+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.match_all_query_match_all import MatchAllQueryMatchAll
+
+
+T = TypeVar("T", bound="MatchAllQuery")
+
+
+@_attrs_define
+class MatchAllQuery:
+    """
+    Attributes:
+        match_all (MatchAllQueryMatchAll):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    match_all: MatchAllQueryMatchAll
+    boost: float | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        match_all = self.match_all.to_dict()
+
+        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(
+            {
+                "match_all": match_all,
+            }
+        )
+        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:
+        from ..models.match_all_query_match_all import MatchAllQueryMatchAll
+
+        d = dict(src_dict)
+        match_all = MatchAllQueryMatchAll.from_dict(d.pop("match_all"))
+
+        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))
+
+        match_all_query = cls(
+            match_all=match_all,
+            boost=boost,
+        )
+
+        match_all_query.additional_properties = d
+        return match_all_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_all_query_match_all.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="MatchAllQueryMatchAll")
+
+
+@_attrs_define
+class MatchAllQueryMatchAll:
+    """ """
+
+    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_all_query_match_all = cls()
+
+        match_all_query_match_all.additional_properties = d
+        return match_all_query_match_all
+
+    @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_none_query.py

@@ -0,0 +1,90 @@
+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.match_none_query_match_none import MatchNoneQueryMatchNone
+
+
+T = TypeVar("T", bound="MatchNoneQuery")
+
+
+@_attrs_define
+class MatchNoneQuery:
+    """
+    Attributes:
+        match_none (MatchNoneQueryMatchNone):
+        boost (float | None | Unset): A floating-point number used to decrease or increase the relevance scores of a
+            query.
+    """
+
+    match_none: MatchNoneQueryMatchNone
+    boost: float | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        match_none = self.match_none.to_dict()
+
+        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(
+            {
+                "match_none": match_none,
+            }
+        )
+        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:
+        from ..models.match_none_query_match_none import MatchNoneQueryMatchNone
+
+        d = dict(src_dict)
+        match_none = MatchNoneQueryMatchNone.from_dict(d.pop("match_none"))
+
+        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))
+
+        match_none_query = cls(
+            match_none=match_none,
+            boost=boost,
+        )
+
+        match_none_query.additional_properties = d
+        return match_none_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