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

antfly/client_generated/models/cluster_restore_request.py

@@ -0,0 +1,107 @@
+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.cluster_restore_request_restore_mode import ClusterRestoreRequestRestoreMode
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ClusterRestoreRequest")
+
+
+@_attrs_define
+class ClusterRestoreRequest:
+    """
+    Attributes:
+        backup_id (str): Unique identifier of the backup to restore from.
+             Example: cluster-backup-2025-01-15.
+        location (str): Storage location where the backup is stored.
+             Example: s3://mybucket/antfly-backups/cluster/2025-01-15.
+        table_names (list[str] | Unset): Optional list of tables to restore. If omitted, all tables in the backup are
+            restored.
+             Example: ['users', 'products'].
+        restore_mode (ClusterRestoreRequestRestoreMode | Unset): How to handle existing tables:
+            - `fail_if_exists`: Abort if any table already exists (default)
+            - `skip_if_exists`: Skip existing tables, restore others
+            - `overwrite`: Drop and recreate existing tables
+             Default: ClusterRestoreRequestRestoreMode.FAIL_IF_EXISTS. Example: skip_if_exists.
+    """
+
+    backup_id: str
+    location: str
+    table_names: list[str] | Unset = UNSET
+    restore_mode: ClusterRestoreRequestRestoreMode | Unset = ClusterRestoreRequestRestoreMode.FAIL_IF_EXISTS
+    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
+
+        table_names: list[str] | Unset = UNSET
+        if not isinstance(self.table_names, Unset):
+            table_names = self.table_names
+
+        restore_mode: str | Unset = UNSET
+        if not isinstance(self.restore_mode, Unset):
+            restore_mode = self.restore_mode.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "backup_id": backup_id,
+                "location": location,
+            }
+        )
+        if table_names is not UNSET:
+            field_dict["table_names"] = table_names
+        if restore_mode is not UNSET:
+            field_dict["restore_mode"] = restore_mode
+
+        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")
+
+        table_names = cast(list[str], d.pop("table_names", UNSET))
+
+        _restore_mode = d.pop("restore_mode", UNSET)
+        restore_mode: ClusterRestoreRequestRestoreMode | Unset
+        if isinstance(_restore_mode, Unset):
+            restore_mode = UNSET
+        else:
+            restore_mode = ClusterRestoreRequestRestoreMode(_restore_mode)
+
+        cluster_restore_request = cls(
+            backup_id=backup_id,
+            location=location,
+            table_names=table_names,
+            restore_mode=restore_mode,
+        )
+
+        cluster_restore_request.additional_properties = d
+        return cluster_restore_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/cluster_restore_request_restore_mode.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ClusterRestoreRequestRestoreMode(str, Enum):
+    FAIL_IF_EXISTS = "fail_if_exists"
+    OVERWRITE = "overwrite"
+    SKIP_IF_EXISTS = "skip_if_exists"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/cluster_restore_response.py

@@ -0,0 +1,85 @@
+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.cluster_restore_response_status import ClusterRestoreResponseStatus
+
+if TYPE_CHECKING:
+    from ..models.table_restore_status import TableRestoreStatus
+
+
+T = TypeVar("T", bound="ClusterRestoreResponse")
+
+
+@_attrs_define
+class ClusterRestoreResponse:
+    """
+    Attributes:
+        tables (list[TableRestoreStatus]): Status of each table restore
+        status (ClusterRestoreResponseStatus): Overall restore status Example: triggered.
+    """
+
+    tables: list[TableRestoreStatus]
+    status: ClusterRestoreResponseStatus
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        tables = []
+        for tables_item_data in self.tables:
+            tables_item = tables_item_data.to_dict()
+            tables.append(tables_item)
+
+        status = self.status.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "tables": tables,
+                "status": status,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.table_restore_status import TableRestoreStatus
+
+        d = dict(src_dict)
+        tables = []
+        _tables = d.pop("tables")
+        for tables_item_data in _tables:
+            tables_item = TableRestoreStatus.from_dict(tables_item_data)
+
+            tables.append(tables_item)
+
+        status = ClusterRestoreResponseStatus(d.pop("status"))
+
+        cluster_restore_response = cls(
+            tables=tables,
+            status=status,
+        )
+
+        cluster_restore_response.additional_properties = d
+        return cluster_restore_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/cluster_restore_response_status.py

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

antfly/client_generated/models/cluster_status.py

@@ -0,0 +1,114 @@
+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.cluster_health import ClusterHealth
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.secret_store_status import SecretStoreStatus
+
+
+T = TypeVar("T", bound="ClusterStatus")
+
+
+@_attrs_define
+class ClusterStatus:
+    """
+    Attributes:
+        health (ClusterHealth): Overall health status of the cluster
+        message (str | Unset): Optional message providing details about the health status
+        auth_enabled (bool | Unset): Indicates whether authentication is enabled for the cluster
+        swarm_mode (bool | Unset): Indicates whether the cluster is running in single-node swarm mode
+        secret_store (SecretStoreStatus | Unset): Non-secret status for the local secrets file store, when one is
+            available.
+    """
+
+    health: ClusterHealth
+    message: str | Unset = UNSET
+    auth_enabled: bool | Unset = UNSET
+    swarm_mode: bool | Unset = UNSET
+    secret_store: SecretStoreStatus | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        health = self.health.value
+
+        message = self.message
+
+        auth_enabled = self.auth_enabled
+
+        swarm_mode = self.swarm_mode
+
+        secret_store: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.secret_store, Unset):
+            secret_store = self.secret_store.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "health": health,
+            }
+        )
+        if message is not UNSET:
+            field_dict["message"] = message
+        if auth_enabled is not UNSET:
+            field_dict["auth_enabled"] = auth_enabled
+        if swarm_mode is not UNSET:
+            field_dict["swarm_mode"] = swarm_mode
+        if secret_store is not UNSET:
+            field_dict["secret_store"] = secret_store
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.secret_store_status import SecretStoreStatus
+
+        d = dict(src_dict)
+        health = ClusterHealth(d.pop("health"))
+
+        message = d.pop("message", UNSET)
+
+        auth_enabled = d.pop("auth_enabled", UNSET)
+
+        swarm_mode = d.pop("swarm_mode", UNSET)
+
+        _secret_store = d.pop("secret_store", UNSET)
+        secret_store: SecretStoreStatus | Unset
+        if isinstance(_secret_store, Unset):
+            secret_store = UNSET
+        else:
+            secret_store = SecretStoreStatus.from_dict(_secret_store)
+
+        cluster_status = cls(
+            health=health,
+            message=message,
+            auth_enabled=auth_enabled,
+            swarm_mode=swarm_mode,
+            secret_store=secret_store,
+        )
+
+        cluster_status.additional_properties = d
+        return cluster_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/cluster_topology.py

@@ -0,0 +1,124 @@
+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.cluster_health import ClusterHealth
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.cluster_data_status import ClusterDataStatus
+    from ..models.secret_store_status import SecretStoreStatus
+
+
+T = TypeVar("T", bound="ClusterTopology")
+
+
+@_attrs_define
+class ClusterTopology:
+    """
+    Attributes:
+        health (ClusterHealth): Overall health status of the cluster
+        data (ClusterDataStatus): Typed Zig status view for table data topology and range placement.
+        message (str | Unset): Optional message providing details about the health status
+        auth_enabled (bool | Unset): Indicates whether authentication is enabled for the cluster
+        swarm_mode (bool | Unset): Indicates whether the cluster is running in single-node swarm mode
+        secret_store (SecretStoreStatus | Unset): Non-secret status for the local secrets file store, when one is
+            available.
+    """
+
+    health: ClusterHealth
+    data: ClusterDataStatus
+    message: str | Unset = UNSET
+    auth_enabled: bool | Unset = UNSET
+    swarm_mode: bool | Unset = UNSET
+    secret_store: SecretStoreStatus | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        health = self.health.value
+
+        data = self.data.to_dict()
+
+        message = self.message
+
+        auth_enabled = self.auth_enabled
+
+        swarm_mode = self.swarm_mode
+
+        secret_store: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.secret_store, Unset):
+            secret_store = self.secret_store.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "health": health,
+                "data": data,
+            }
+        )
+        if message is not UNSET:
+            field_dict["message"] = message
+        if auth_enabled is not UNSET:
+            field_dict["auth_enabled"] = auth_enabled
+        if swarm_mode is not UNSET:
+            field_dict["swarm_mode"] = swarm_mode
+        if secret_store is not UNSET:
+            field_dict["secret_store"] = secret_store
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.cluster_data_status import ClusterDataStatus
+        from ..models.secret_store_status import SecretStoreStatus
+
+        d = dict(src_dict)
+        health = ClusterHealth(d.pop("health"))
+
+        data = ClusterDataStatus.from_dict(d.pop("data"))
+
+        message = d.pop("message", UNSET)
+
+        auth_enabled = d.pop("auth_enabled", UNSET)
+
+        swarm_mode = d.pop("swarm_mode", UNSET)
+
+        _secret_store = d.pop("secret_store", UNSET)
+        secret_store: SecretStoreStatus | Unset
+        if isinstance(_secret_store, Unset):
+            secret_store = UNSET
+        else:
+            secret_store = SecretStoreStatus.from_dict(_secret_store)
+
+        cluster_topology = cls(
+            health=health,
+            data=data,
+            message=message,
+            auth_enabled=auth_enabled,
+            swarm_mode=swarm_mode,
+            secret_store=secret_store,
+        )
+
+        cluster_topology.additional_properties = d
+        return cluster_topology
+
+    @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/cohere_embedder_config.py

@@ -0,0 +1,119 @@
+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.cohere_embedder_config_input_type import CohereEmbedderConfigInputType
+from ..models.cohere_embedder_config_truncate import CohereEmbedderConfigTruncate
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CohereEmbedderConfig")
+
+
+@_attrs_define
+class CohereEmbedderConfig:
+    """Configuration for the Cohere embedding provider.
+
+    API key via `api_key` field or `COHERE_API_KEY` environment variable.
+
+    **Example Models:** embed-english-v3.0 (default, 1024 dims), embed-multilingual-v3.0
+
+    **Docs:** https://docs.cohere.com/reference/embed
+
+        Example:
+            {'provider': 'cohere', 'model': 'embed-english-v3.0', 'input_type': 'search_document'}
+
+        Attributes:
+            model (str): The name of the Cohere embedding model to use. Default: 'embed-english-v3.0'. Example: embed-
+                english-v3.0.
+            api_key (str | Unset): The Cohere API key. Can also be set via COHERE_API_KEY environment variable.
+            input_type (CohereEmbedderConfigInputType | Unset): Specifies the type of input for optimized embeddings.
+                Default: CohereEmbedderConfigInputType.SEARCH_DOCUMENT.
+            truncate (CohereEmbedderConfigTruncate | Unset): How to handle inputs longer than the max token length. Default:
+                CohereEmbedderConfigTruncate.END.
+    """
+
+    model: str = "embed-english-v3.0"
+    api_key: str | Unset = UNSET
+    input_type: CohereEmbedderConfigInputType | Unset = CohereEmbedderConfigInputType.SEARCH_DOCUMENT
+    truncate: CohereEmbedderConfigTruncate | Unset = CohereEmbedderConfigTruncate.END
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        api_key = self.api_key
+
+        input_type: str | Unset = UNSET
+        if not isinstance(self.input_type, Unset):
+            input_type = self.input_type.value
+
+        truncate: str | Unset = UNSET
+        if not isinstance(self.truncate, Unset):
+            truncate = self.truncate.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+            }
+        )
+        if api_key is not UNSET:
+            field_dict["api_key"] = api_key
+        if input_type is not UNSET:
+            field_dict["input_type"] = input_type
+        if truncate is not UNSET:
+            field_dict["truncate"] = truncate
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        api_key = d.pop("api_key", UNSET)
+
+        _input_type = d.pop("input_type", UNSET)
+        input_type: CohereEmbedderConfigInputType | Unset
+        if isinstance(_input_type, Unset):
+            input_type = UNSET
+        else:
+            input_type = CohereEmbedderConfigInputType(_input_type)
+
+        _truncate = d.pop("truncate", UNSET)
+        truncate: CohereEmbedderConfigTruncate | Unset
+        if isinstance(_truncate, Unset):
+            truncate = UNSET
+        else:
+            truncate = CohereEmbedderConfigTruncate(_truncate)
+
+        cohere_embedder_config = cls(
+            model=model,
+            api_key=api_key,
+            input_type=input_type,
+            truncate=truncate,
+        )
+
+        cohere_embedder_config.additional_properties = d
+        return cohere_embedder_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/cohere_embedder_config_input_type.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class CohereEmbedderConfigInputType(str, Enum):
+    CLASSIFICATION = "classification"
+    CLUSTERING = "clustering"
+    SEARCH_DOCUMENT = "search_document"
+    SEARCH_QUERY = "search_query"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/cohere_embedder_config_truncate.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class CohereEmbedderConfigTruncate(str, Enum):
+    END = "END"
+    NONE = "NONE"
+    START = "START"
+
+    def __str__(self) -> str:
+        return str(self.value)