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

antfly/client_generated/models/auth_subject.py

@@ -0,0 +1,72 @@
+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.auth_subject_kind import AuthSubjectKind
+
+T = TypeVar("T", bound="AuthSubject")
+
+
+@_attrs_define
+class AuthSubject:
+    """
+    Attributes:
+        subject (str): Casbin subject name. Example: role:tenant_reader.
+        kind (AuthSubjectKind): Conservative subject classification inferred from user records and subject prefixes.
+            Example: role.
+    """
+
+    subject: str
+    kind: AuthSubjectKind
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        subject = self.subject
+
+        kind = self.kind.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "subject": subject,
+                "kind": kind,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        subject = d.pop("subject")
+
+        kind = AuthSubjectKind(d.pop("kind"))
+
+        auth_subject = cls(
+            subject=subject,
+            kind=kind,
+        )
+
+        auth_subject.additional_properties = d
+        return auth_subject
+
+    @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/auth_subject_kind.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class AuthSubjectKind(str, Enum):
+    GROUP = "group"
+    ROLE = "role"
+    SUBJECT = "subject"
+    USER = "user"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/backup_info.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.backup_info_format import BackupInfoFormat
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="BackupInfo")
+
+
+@_attrs_define
+class BackupInfo:
+    """
+    Attributes:
+        backup_id (str): The backup identifier Example: cluster-backup-2025-01-15.
+        timestamp (datetime.datetime): When the backup was created Example: 2025-01-15T10:30:00Z.
+        tables (list[str]): Tables included in the backup Example: ['users', 'products'].
+        location (str): Storage location of the backup Example: s3://mybucket/antfly-backups/cluster/2025-01-15.
+        antfly_version (str | Unset): Antfly version that created the backup Example: v1.0.0.
+        format_ (BackupInfoFormat | Unset): Backup format used Example: portable.
+    """
+
+    backup_id: str
+    timestamp: datetime.datetime
+    tables: list[str]
+    location: str
+    antfly_version: str | Unset = UNSET
+    format_: BackupInfoFormat | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        backup_id = self.backup_id
+
+        timestamp = self.timestamp.isoformat()
+
+        tables = self.tables
+
+        location = self.location
+
+        antfly_version = self.antfly_version
+
+        format_: str | Unset = UNSET
+        if not isinstance(self.format_, Unset):
+            format_ = self.format_.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "backup_id": backup_id,
+                "timestamp": timestamp,
+                "tables": tables,
+                "location": location,
+            }
+        )
+        if antfly_version is not UNSET:
+            field_dict["antfly_version"] = antfly_version
+        if format_ is not UNSET:
+            field_dict["format"] = format_
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        backup_id = d.pop("backup_id")
+
+        timestamp = isoparse(d.pop("timestamp"))
+
+        tables = cast(list[str], d.pop("tables"))
+
+        location = d.pop("location")
+
+        antfly_version = d.pop("antfly_version", UNSET)
+
+        _format_ = d.pop("format", UNSET)
+        format_: BackupInfoFormat | Unset
+        if isinstance(_format_, Unset):
+            format_ = UNSET
+        else:
+            format_ = BackupInfoFormat(_format_)
+
+        backup_info = cls(
+            backup_id=backup_id,
+            timestamp=timestamp,
+            tables=tables,
+            location=location,
+            antfly_version=antfly_version,
+            format_=format_,
+        )
+
+        backup_info.additional_properties = d
+        return backup_info
+
+    @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/backup_info_format.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class BackupInfoFormat(str, Enum):
+    NATIVE = "native"
+    PORTABLE = "portable"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/backup_list_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
+
+if TYPE_CHECKING:
+    from ..models.backup_info import BackupInfo
+
+
+T = TypeVar("T", bound="BackupListResponse")
+
+
+@_attrs_define
+class BackupListResponse:
+    """
+    Attributes:
+        backups (list[BackupInfo]): List of available backups
+    """
+
+    backups: list[BackupInfo]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        backups = []
+        for backups_item_data in self.backups:
+            backups_item = backups_item_data.to_dict()
+            backups.append(backups_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "backups": backups,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.backup_info import BackupInfo
+
+        d = dict(src_dict)
+        backups = []
+        _backups = d.pop("backups")
+        for backups_item_data in _backups:
+            backups_item = BackupInfo.from_dict(backups_item_data)
+
+            backups.append(backups_item)
+
+        backup_list_response = cls(
+            backups=backups,
+        )
+
+        backup_list_response.additional_properties = d
+        return backup_list_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/backup_request.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.backup_request_format import BackupRequestFormat
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="BackupRequest")
+
+
+@_attrs_define
+class BackupRequest:
+    """
+    Attributes:
+        backup_id (str): Unique identifier for this backup. Used to reference the backup for restore operations.
+            Choose a meaningful name that includes date/version information.
+             Example: backup-2025-01-15-v2.
+        location (str): Storage location for the backup. Supports multiple backends:
+            - Local filesystem: `file:///path/to/backup`
+            - Amazon S3: `s3://bucket-name/path/to/backup`
+
+            The backup includes all table data, indexes, and metadata for the specified table.
+             Example: s3://mybucket/antfly-backups/users-table/2025-01-15.
+        format_ (BackupRequestFormat | Unset): Backup format to use:
+            - `native`: Engine-specific physical snapshot (fast backup and restore, same-backend only)
+            - `portable`: Cross-backend logical backup in AFB format (slower restore due to index rebuild, but can be
+            restored by any Antfly backend)
+
+            On restore, the format is auto-detected from file magic bytes.
+             Default: BackupRequestFormat.PORTABLE. Example: portable.
+    """
+
+    backup_id: str
+    location: str
+    format_: BackupRequestFormat | Unset = BackupRequestFormat.PORTABLE
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        backup_id = self.backup_id
+
+        location = self.location
+
+        format_: str | Unset = UNSET
+        if not isinstance(self.format_, Unset):
+            format_ = self.format_.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "backup_id": backup_id,
+                "location": location,
+            }
+        )
+        if format_ is not UNSET:
+            field_dict["format"] = format_
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        backup_id = d.pop("backup_id")
+
+        location = d.pop("location")
+
+        _format_ = d.pop("format", UNSET)
+        format_: BackupRequestFormat | Unset
+        if isinstance(_format_, Unset):
+            format_ = UNSET
+        else:
+            format_ = BackupRequestFormat(_format_)
+
+        backup_request = cls(
+            backup_id=backup_id,
+            location=location,
+            format_=format_,
+        )
+
+        backup_request.additional_properties = d
+        return backup_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/backup_request_format.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class BackupRequestFormat(str, Enum):
+    NATIVE = "native"
+    PORTABLE = "portable"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/backup_table_response_201.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="BackupTableResponse201")
+
+
+@_attrs_define
+class BackupTableResponse201:
+    """
+    Attributes:
+        backup (str | Unset):  Example: successful.
+    """
+
+    backup: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        backup = self.backup
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if backup is not UNSET:
+            field_dict["backup"] = backup
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        backup = d.pop("backup", UNSET)
+
+        backup_table_response_201 = cls(
+            backup=backup,
+        )
+
+        backup_table_response_201.additional_properties = d
+        return backup_table_response_201
+
+    @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/batch_request.py

@@ -0,0 +1,195 @@
+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.sync_level import SyncLevel
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.batch_request_inserts import BatchRequestInserts
+    from ..models.transform import Transform
+
+
+T = TypeVar("T", bound="BatchRequest")
+
+
+@_attrs_define
+class BatchRequest:
+    """Batch insert, delete, and transform operations in a single request.
+
+    **Atomicity**:
+    - **Single shard**: Operations are atomic within shard boundaries
+    - **Multiple shards**: Uses distributed 2-phase commit (2PC) for atomic cross-shard writes
+
+    **How distributed transactions work**:
+    1. Metadata server allocates HLC timestamp and selects coordinator shard
+    2. Coordinator writes transaction record, participants write intents
+    3. After all intents succeed, coordinator commits transaction
+    4. Participants are notified asynchronously to resolve intents
+    5. Recovery loop ensures notifications complete even after coordinator failure
+
+    **Performance**:
+    - Single-shard batches: < 5ms latency
+    - Cross-shard transactions: ~20ms latency
+    - Intent resolution: < 30 seconds worst-case (via recovery loop)
+
+    **Guarantees**:
+    - All writes succeed or all fail (atomicity across all shards)
+    - Coordinator failure is recoverable (new leader resumes notifications)
+    - Idempotent resolution (duplicate notifications are safe)
+
+    **Benefits**:
+    - Reduces network overhead compared to individual requests
+    - More efficient indexing (updates are batched)
+    - Automatic distributed transactions when operations span shards
+
+    The inserts are upserts - existing keys are overwritten, new keys are created.
+
+        Example:
+            {'inserts': {'user:123': {'name': 'John Doe', 'email': 'john@example.com', 'age': 30, 'tags': ['customer',
+                'premium']}, 'user:456': {'name': 'Jane Smith', 'email': 'jane@example.com', 'age': 25, 'tags': ['customer']}},
+                'deletes': ['user:789', 'user:old_account']}
+
+        Attributes:
+            inserts (BatchRequestInserts | Unset): Map of document IDs to document objects. Each key is the unique
+                identifier for the document.
+
+                Best practices:
+                - Use consistent key naming schemes (e.g., "user:123", "article:456")
+                - Key length affects storage and performance - keep them reasonably short
+                - Keys are sorted lexicographically, so choose prefixes that support range scans
+                 Example: {'user:123': {'name': 'John Doe', 'email': 'john@example.com', 'age': 30, 'tags': ['customer',
+                'premium']}, 'user:456': {'name': 'Jane Smith', 'email': 'jane@example.com', 'age': 25, 'tags': ['customer']}}.
+            deletes (list[str] | Unset): Array of document IDs to delete. Documents are removed from all indexes.
+
+                Notes:
+                - Non-existent keys are silently ignored
+                - Deletions are processed before inserts in the same batch
+                - Keys are permanently removed from storage and indexes
+                 Example: ['user:789', 'user:old_account'].
+            transforms (list[Transform] | Unset): Array of transform operations for in-place document updates using MongoDB-
+                style operators.
+
+                Transform operations allow you to modify documents without read-modify-write races:
+                - Operations are applied atomically on the server
+                - Multiple operations per document are applied in sequence
+                - Supports numeric operations ($inc, $mul), array operations ($push, $pull), and more
+
+                Common use cases:
+                - Increment counters (views, likes, votes)
+                - Update timestamps ($currentDate)
+                - Manage arrays (add/remove tags, items)
+                - Update nested fields without overwriting the entire document
+                 Example: [{'key': 'article:123', 'operations': [{'op': '$inc', 'path': '$.views', 'value': 1}, {'op':
+                '$currentDate', 'path': '$.lastViewed'}]}, {'key': 'user:456', 'operations': [{'op': '$push', 'path': '$.tags',
+                'value': 'vip'}]}].
+            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)
+    """
+
+    inserts: BatchRequestInserts | Unset = UNSET
+    deletes: list[str] | Unset = UNSET
+    transforms: list[Transform] | Unset = UNSET
+    sync_level: SyncLevel | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        inserts: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.inserts, Unset):
+            inserts = self.inserts.to_dict()
+
+        deletes: list[str] | Unset = UNSET
+        if not isinstance(self.deletes, Unset):
+            deletes = self.deletes
+
+        transforms: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.transforms, Unset):
+            transforms = []
+            for transforms_item_data in self.transforms:
+                transforms_item = transforms_item_data.to_dict()
+                transforms.append(transforms_item)
+
+        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({})
+        if inserts is not UNSET:
+            field_dict["inserts"] = inserts
+        if deletes is not UNSET:
+            field_dict["deletes"] = deletes
+        if transforms is not UNSET:
+            field_dict["transforms"] = transforms
+        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.batch_request_inserts import BatchRequestInserts
+        from ..models.transform import Transform
+
+        d = dict(src_dict)
+        _inserts = d.pop("inserts", UNSET)
+        inserts: BatchRequestInserts | Unset
+        if isinstance(_inserts, Unset):
+            inserts = UNSET
+        else:
+            inserts = BatchRequestInserts.from_dict(_inserts)
+
+        deletes = cast(list[str], d.pop("deletes", UNSET))
+
+        _transforms = d.pop("transforms", UNSET)
+        transforms: list[Transform] | Unset = UNSET
+        if _transforms is not UNSET:
+            transforms = []
+            for transforms_item_data in _transforms:
+                transforms_item = Transform.from_dict(transforms_item_data)
+
+                transforms.append(transforms_item)
+
+        _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)
+
+        batch_request = cls(
+            inserts=inserts,
+            deletes=deletes,
+            transforms=transforms,
+            sync_level=sync_level,
+        )
+
+        batch_request.additional_properties = d
+        return 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