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

antfly/client_generated/models/table_backup_status_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class TableBackupStatusStatus(str, Enum):
+    COMPLETED = "completed"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/table_migration.py

@@ -0,0 +1,79 @@
+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.table_migration_state import TableMigrationState
+
+if TYPE_CHECKING:
+    from ..models.table_schema import TableSchema
+
+
+T = TypeVar("T", bound="TableMigration")
+
+
+@_attrs_define
+class TableMigration:
+    """Describes an in-progress schema migration. The table serves reads from read_schema while rebuilding full-text
+    indexes for the new schema.
+
+        Attributes:
+            state (TableMigrationState):
+            read_schema (TableSchema): Schema definition for a table with multiple document types
+    """
+
+    state: TableMigrationState
+    read_schema: TableSchema
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        state = self.state.value
+
+        read_schema = self.read_schema.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "state": state,
+                "read_schema": read_schema,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.table_schema import TableSchema
+
+        d = dict(src_dict)
+        state = TableMigrationState(d.pop("state"))
+
+        read_schema = TableSchema.from_dict(d.pop("read_schema"))
+
+        table_migration = cls(
+            state=state,
+            read_schema=read_schema,
+        )
+
+        table_migration.additional_properties = d
+        return table_migration
+
+    @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/table_migration_state.py

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

antfly/client_generated/models/table_restore_status.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 ..models.table_restore_status_status import TableRestoreStatusStatus
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TableRestoreStatus")
+
+
+@_attrs_define
+class TableRestoreStatus:
+    """
+    Attributes:
+        name (str): Table name Example: users.
+        status (TableRestoreStatusStatus): Restore status for this table Example: triggered.
+        error (str | Unset): Error message if restore failed
+    """
+
+    name: str
+    status: TableRestoreStatusStatus
+    error: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        status = self.status.value
+
+        error = self.error
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "status": status,
+            }
+        )
+        if error is not UNSET:
+            field_dict["error"] = error
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        status = TableRestoreStatusStatus(d.pop("status"))
+
+        error = d.pop("error", UNSET)
+
+        table_restore_status = cls(
+            name=name,
+            status=status,
+            error=error,
+        )
+
+        table_restore_status.additional_properties = d
+        return table_restore_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/table_restore_status_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class TableRestoreStatusStatus(str, Enum):
+    FAILED = "failed"
+    SKIPPED = "skipped"
+    TRIGGERED = "triggered"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/table_schema.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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.dynamic_template import DynamicTemplate
+    from ..models.table_schema_document_schemas import TableSchemaDocumentSchemas
+
+
+T = TypeVar("T", bound="TableSchema")
+
+
+@_attrs_define
+class TableSchema:
+    """Schema definition for a table with multiple document types
+
+    Attributes:
+        version (int | Unset): Version of the schema. Used for migrations.
+        default_type (str | Unset): Default type to use from the document_types.
+        enforce_types (bool | Unset): Whether to enforce that documents must match one of the provided document types.
+            If false, documents not matching any type will be accepted but not indexed.
+        document_schemas (TableSchemaDocumentSchemas | Unset): A map of type names to their document json schemas.
+        ttl_field (str | Unset): The field containing the timestamp for TTL expiration (optional).
+            Defaults to "_timestamp" if ttl_duration is specified but ttl_field is not.
+        ttl_duration (str | Unset): The duration after which documents should expire, based on the ttl_field timestamp
+            (optional).
+            Uses Go duration format (e.g., '24h', '7d', '168h').
+        dynamic_templates (list[DynamicTemplate] | Unset): Rules for mapping dynamically detected fields. When a
+            document contains fields
+            that don't have explicit mappings and dynamic mapping is enabled, templates are
+            evaluated in order to determine how those fields should be indexed.
+    """
+
+    version: int | Unset = UNSET
+    default_type: str | Unset = UNSET
+    enforce_types: bool | Unset = UNSET
+    document_schemas: TableSchemaDocumentSchemas | Unset = UNSET
+    ttl_field: str | Unset = UNSET
+    ttl_duration: str | Unset = UNSET
+    dynamic_templates: list[DynamicTemplate] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        version = self.version
+
+        default_type = self.default_type
+
+        enforce_types = self.enforce_types
+
+        document_schemas: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.document_schemas, Unset):
+            document_schemas = self.document_schemas.to_dict()
+
+        ttl_field = self.ttl_field
+
+        ttl_duration = self.ttl_duration
+
+        dynamic_templates: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.dynamic_templates, Unset):
+            dynamic_templates = []
+            for dynamic_templates_item_data in self.dynamic_templates:
+                dynamic_templates_item = dynamic_templates_item_data.to_dict()
+                dynamic_templates.append(dynamic_templates_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if version is not UNSET:
+            field_dict["version"] = version
+        if default_type is not UNSET:
+            field_dict["default_type"] = default_type
+        if enforce_types is not UNSET:
+            field_dict["enforce_types"] = enforce_types
+        if document_schemas is not UNSET:
+            field_dict["document_schemas"] = document_schemas
+        if ttl_field is not UNSET:
+            field_dict["ttl_field"] = ttl_field
+        if ttl_duration is not UNSET:
+            field_dict["ttl_duration"] = ttl_duration
+        if dynamic_templates is not UNSET:
+            field_dict["dynamic_templates"] = dynamic_templates
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.dynamic_template import DynamicTemplate
+        from ..models.table_schema_document_schemas import TableSchemaDocumentSchemas
+
+        d = dict(src_dict)
+        version = d.pop("version", UNSET)
+
+        default_type = d.pop("default_type", UNSET)
+
+        enforce_types = d.pop("enforce_types", UNSET)
+
+        _document_schemas = d.pop("document_schemas", UNSET)
+        document_schemas: TableSchemaDocumentSchemas | Unset
+        if isinstance(_document_schemas, Unset):
+            document_schemas = UNSET
+        else:
+            document_schemas = TableSchemaDocumentSchemas.from_dict(_document_schemas)
+
+        ttl_field = d.pop("ttl_field", UNSET)
+
+        ttl_duration = d.pop("ttl_duration", UNSET)
+
+        _dynamic_templates = d.pop("dynamic_templates", UNSET)
+        dynamic_templates: list[DynamicTemplate] | Unset = UNSET
+        if _dynamic_templates is not UNSET:
+            dynamic_templates = []
+            for dynamic_templates_item_data in _dynamic_templates:
+                dynamic_templates_item = DynamicTemplate.from_dict(dynamic_templates_item_data)
+
+                dynamic_templates.append(dynamic_templates_item)
+
+        table_schema = cls(
+            version=version,
+            default_type=default_type,
+            enforce_types=enforce_types,
+            document_schemas=document_schemas,
+            ttl_field=ttl_field,
+            ttl_duration=ttl_duration,
+            dynamic_templates=dynamic_templates,
+        )
+
+        table_schema.additional_properties = d
+        return table_schema
+
+    @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/table_schema_document_schemas.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.document_schema import DocumentSchema
+
+
+T = TypeVar("T", bound="TableSchemaDocumentSchemas")
+
+
+@_attrs_define
+class TableSchemaDocumentSchemas:
+    """A map of type names to their document json schemas."""
+
+    additional_properties: dict[str, DocumentSchema] = _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.document_schema import DocumentSchema
+
+        d = dict(src_dict)
+        table_schema_document_schemas = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = DocumentSchema.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        table_schema_document_schemas.additional_properties = additional_properties
+        return table_schema_document_schemas
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> DocumentSchema:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: DocumentSchema) -> 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/table_statistics.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import datetime
+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 dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.table_statistics_field_stats import TableStatisticsFieldStats
+
+
+T = TypeVar("T", bound="TableStatistics")
+
+
+@_attrs_define
+class TableStatistics:
+    """Statistics about a table used for query planning.
+
+    Attributes:
+        row_count (int | Unset): Approximate number of rows in the table.
+        size_bytes (int | Unset): Approximate size of the table in bytes.
+        field_stats (TableStatisticsFieldStats | Unset): Per-field statistics for query optimization.
+        last_updated (datetime.datetime | Unset): When these statistics were last computed.
+    """
+
+    row_count: int | Unset = UNSET
+    size_bytes: int | Unset = UNSET
+    field_stats: TableStatisticsFieldStats | Unset = UNSET
+    last_updated: datetime.datetime | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        row_count = self.row_count
+
+        size_bytes = self.size_bytes
+
+        field_stats: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.field_stats, Unset):
+            field_stats = self.field_stats.to_dict()
+
+        last_updated: str | Unset = UNSET
+        if not isinstance(self.last_updated, Unset):
+            last_updated = self.last_updated.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if row_count is not UNSET:
+            field_dict["row_count"] = row_count
+        if size_bytes is not UNSET:
+            field_dict["size_bytes"] = size_bytes
+        if field_stats is not UNSET:
+            field_dict["field_stats"] = field_stats
+        if last_updated is not UNSET:
+            field_dict["last_updated"] = last_updated
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.table_statistics_field_stats import TableStatisticsFieldStats
+
+        d = dict(src_dict)
+        row_count = d.pop("row_count", UNSET)
+
+        size_bytes = d.pop("size_bytes", UNSET)
+
+        _field_stats = d.pop("field_stats", UNSET)
+        field_stats: TableStatisticsFieldStats | Unset
+        if isinstance(_field_stats, Unset):
+            field_stats = UNSET
+        else:
+            field_stats = TableStatisticsFieldStats.from_dict(_field_stats)
+
+        _last_updated = d.pop("last_updated", UNSET)
+        last_updated: datetime.datetime | Unset
+        if isinstance(_last_updated, Unset):
+            last_updated = UNSET
+        else:
+            last_updated = isoparse(_last_updated)
+
+        table_statistics = cls(
+            row_count=row_count,
+            size_bytes=size_bytes,
+            field_stats=field_stats,
+            last_updated=last_updated,
+        )
+
+        table_statistics.additional_properties = d
+        return table_statistics
+
+    @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/table_statistics_field_stats.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.field_statistics import FieldStatistics
+
+
+T = TypeVar("T", bound="TableStatisticsFieldStats")
+
+
+@_attrs_define
+class TableStatisticsFieldStats:
+    """Per-field statistics for query optimization."""
+
+    additional_properties: dict[str, FieldStatistics] = _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.field_statistics import FieldStatistics
+
+        d = dict(src_dict)
+        table_statistics_field_stats = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = FieldStatistics.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        table_statistics_field_stats.additional_properties = additional_properties
+        return table_statistics_field_stats
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> FieldStatistics:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: FieldStatistics) -> 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