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

antfly/client_generated/models/index_status.py

@@ -0,0 +1,190 @@
+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.algebraic_index_config import AlgebraicIndexConfig
+    from ..models.algebraic_index_stats import AlgebraicIndexStats
+    from ..models.embeddings_index_config import EmbeddingsIndexConfig
+    from ..models.embeddings_index_stats import EmbeddingsIndexStats
+    from ..models.full_text_index_config import FullTextIndexConfig
+    from ..models.full_text_index_stats import FullTextIndexStats
+    from ..models.graph_index_config import GraphIndexConfig
+    from ..models.graph_index_stats import GraphIndexStats
+    from ..models.index_status_shard_status import IndexStatusShardStatus
+
+
+T = TypeVar("T", bound="IndexStatus")
+
+
+@_attrs_define
+class IndexStatus:
+    """
+    Attributes:
+        shard_status (IndexStatusShardStatus):
+        config (AlgebraicIndexConfig | EmbeddingsIndexConfig | FullTextIndexConfig | GraphIndexConfig): Configuration
+            for an index
+        status (AlgebraicIndexStats | EmbeddingsIndexStats | FullTextIndexStats | GraphIndexStats): Statistics for an
+            index
+    """
+
+    shard_status: IndexStatusShardStatus
+    config: AlgebraicIndexConfig | EmbeddingsIndexConfig | FullTextIndexConfig | GraphIndexConfig
+    status: AlgebraicIndexStats | EmbeddingsIndexStats | FullTextIndexStats | GraphIndexStats
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.embeddings_index_config import EmbeddingsIndexConfig
+        from ..models.embeddings_index_stats import EmbeddingsIndexStats
+        from ..models.full_text_index_config import FullTextIndexConfig
+        from ..models.full_text_index_stats import FullTextIndexStats
+        from ..models.graph_index_config import GraphIndexConfig
+        from ..models.graph_index_stats import GraphIndexStats
+
+        shard_status = self.shard_status.to_dict()
+
+        config: dict[str, Any]
+        if isinstance(self.config, FullTextIndexConfig):
+            config = self.config.to_dict()
+        elif isinstance(self.config, EmbeddingsIndexConfig):
+            config = self.config.to_dict()
+        elif isinstance(self.config, GraphIndexConfig):
+            config = self.config.to_dict()
+        else:
+            config = self.config.to_dict()
+
+        status: dict[str, Any]
+        if isinstance(self.status, FullTextIndexStats):
+            status = self.status.to_dict()
+        elif isinstance(self.status, EmbeddingsIndexStats):
+            status = self.status.to_dict()
+        elif isinstance(self.status, GraphIndexStats):
+            status = self.status.to_dict()
+        else:
+            status = self.status.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "shard_status": shard_status,
+                "config": config,
+                "status": status,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.algebraic_index_config import AlgebraicIndexConfig
+        from ..models.algebraic_index_stats import AlgebraicIndexStats
+        from ..models.embeddings_index_config import EmbeddingsIndexConfig
+        from ..models.embeddings_index_stats import EmbeddingsIndexStats
+        from ..models.full_text_index_config import FullTextIndexConfig
+        from ..models.full_text_index_stats import FullTextIndexStats
+        from ..models.graph_index_config import GraphIndexConfig
+        from ..models.graph_index_stats import GraphIndexStats
+        from ..models.index_status_shard_status import IndexStatusShardStatus
+
+        d = dict(src_dict)
+        shard_status = IndexStatusShardStatus.from_dict(d.pop("shard_status"))
+
+        def _parse_config(
+            data: object,
+        ) -> AlgebraicIndexConfig | EmbeddingsIndexConfig | FullTextIndexConfig | GraphIndexConfig:
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_index_config_type_0 = FullTextIndexConfig.from_dict(data)
+
+                return componentsschemas_index_config_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_index_config_type_1 = EmbeddingsIndexConfig.from_dict(data)
+
+                return componentsschemas_index_config_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_index_config_type_2 = GraphIndexConfig.from_dict(data)
+
+                return componentsschemas_index_config_type_2
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            componentsschemas_index_config_type_3 = AlgebraicIndexConfig.from_dict(data)
+
+            return componentsschemas_index_config_type_3
+
+        config = _parse_config(d.pop("config"))
+
+        def _parse_status(
+            data: object,
+        ) -> AlgebraicIndexStats | EmbeddingsIndexStats | FullTextIndexStats | GraphIndexStats:
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_index_stats_type_0 = FullTextIndexStats.from_dict(data)
+
+                return componentsschemas_index_stats_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_index_stats_type_1 = EmbeddingsIndexStats.from_dict(data)
+
+                return componentsschemas_index_stats_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_index_stats_type_2 = GraphIndexStats.from_dict(data)
+
+                return componentsschemas_index_stats_type_2
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            if not isinstance(data, dict):
+                raise TypeError()
+            componentsschemas_index_stats_type_3 = AlgebraicIndexStats.from_dict(data)
+
+            return componentsschemas_index_stats_type_3
+
+        status = _parse_status(d.pop("status"))
+
+        index_status = cls(
+            shard_status=shard_status,
+            config=config,
+            status=status,
+        )
+
+        index_status.additional_properties = d
+        return index_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/index_status_shard_status.py

@@ -0,0 +1,116 @@
+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.algebraic_index_stats import AlgebraicIndexStats
+    from ..models.embeddings_index_stats import EmbeddingsIndexStats
+    from ..models.full_text_index_stats import FullTextIndexStats
+    from ..models.graph_index_stats import GraphIndexStats
+
+
+T = TypeVar("T", bound="IndexStatusShardStatus")
+
+
+@_attrs_define
+class IndexStatusShardStatus:
+    """ """
+
+    additional_properties: dict[
+        str, AlgebraicIndexStats | EmbeddingsIndexStats | FullTextIndexStats | GraphIndexStats
+    ] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.embeddings_index_stats import EmbeddingsIndexStats
+        from ..models.full_text_index_stats import FullTextIndexStats
+        from ..models.graph_index_stats import GraphIndexStats
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            if isinstance(prop, FullTextIndexStats):
+                field_dict[prop_name] = prop.to_dict()
+            elif isinstance(prop, EmbeddingsIndexStats):
+                field_dict[prop_name] = prop.to_dict()
+            elif isinstance(prop, GraphIndexStats):
+                field_dict[prop_name] = prop.to_dict()
+            else:
+                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.algebraic_index_stats import AlgebraicIndexStats
+        from ..models.embeddings_index_stats import EmbeddingsIndexStats
+        from ..models.full_text_index_stats import FullTextIndexStats
+        from ..models.graph_index_stats import GraphIndexStats
+
+        d = dict(src_dict)
+        index_status_shard_status = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+
+            def _parse_additional_property(
+                data: object,
+            ) -> AlgebraicIndexStats | EmbeddingsIndexStats | FullTextIndexStats | GraphIndexStats:
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_index_stats_type_0 = FullTextIndexStats.from_dict(data)
+
+                    return componentsschemas_index_stats_type_0
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_index_stats_type_1 = EmbeddingsIndexStats.from_dict(data)
+
+                    return componentsschemas_index_stats_type_1
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    componentsschemas_index_stats_type_2 = GraphIndexStats.from_dict(data)
+
+                    return componentsschemas_index_stats_type_2
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_index_stats_type_3 = AlgebraicIndexStats.from_dict(data)
+
+                return componentsschemas_index_stats_type_3
+
+            additional_property = _parse_additional_property(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        index_status_shard_status.additional_properties = additional_properties
+        return index_status_shard_status
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(
+        self, key: str
+    ) -> AlgebraicIndexStats | EmbeddingsIndexStats | FullTextIndexStats | GraphIndexStats:
+        return self.additional_properties[key]
+
+    def __setitem__(
+        self, key: str, value: AlgebraicIndexStats | EmbeddingsIndexStats | FullTextIndexStats | GraphIndexStats
+    ) -> 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/index_type.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class IndexType(str, Enum):
+    ALGEBRAIC = "algebraic"
+    EMBEDDINGS = "embeddings"
+    FULL_TEXT = "full_text"
+    GRAPH = "graph"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/inference_audio_chunk_config.py

@@ -0,0 +1,95 @@
+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.inference_vad_options import InferenceVADOptions
+
+
+T = TypeVar("T", bound="InferenceAudioChunkConfig")
+
+
+@_attrs_define
+class InferenceAudioChunkConfig:
+    """Audio chunking configuration for inference, including VAD options.
+
+    Attributes:
+        window_duration_ms (int | Unset): Window duration in milliseconds for fixed-window audio chunking (default:
+            30000).
+        overlap_duration_ms (int | Unset): Overlap duration in milliseconds between audio chunks (default: 0).
+        vad (InferenceVADOptions | Unset): Options for Voice Activity Detection (VAD) based audio segmentation.
+            inference-specific.
+    """
+
+    window_duration_ms: int | Unset = UNSET
+    overlap_duration_ms: int | Unset = UNSET
+    vad: InferenceVADOptions | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        window_duration_ms = self.window_duration_ms
+
+        overlap_duration_ms = self.overlap_duration_ms
+
+        vad: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.vad, Unset):
+            vad = self.vad.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if window_duration_ms is not UNSET:
+            field_dict["window_duration_ms"] = window_duration_ms
+        if overlap_duration_ms is not UNSET:
+            field_dict["overlap_duration_ms"] = overlap_duration_ms
+        if vad is not UNSET:
+            field_dict["vad"] = vad
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_vad_options import InferenceVADOptions
+
+        d = dict(src_dict)
+        window_duration_ms = d.pop("window_duration_ms", UNSET)
+
+        overlap_duration_ms = d.pop("overlap_duration_ms", UNSET)
+
+        _vad = d.pop("vad", UNSET)
+        vad: InferenceVADOptions | Unset
+        if isinstance(_vad, Unset):
+            vad = UNSET
+        else:
+            vad = InferenceVADOptions.from_dict(_vad)
+
+        inference_audio_chunk_config = cls(
+            window_duration_ms=window_duration_ms,
+            overlap_duration_ms=overlap_duration_ms,
+            vad=vad,
+        )
+
+        inference_audio_chunk_config.additional_properties = d
+        return inference_audio_chunk_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/inference_backend_runtimes.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="InferenceBackendRuntimes")
+
+
+@_attrs_define
+class InferenceBackendRuntimes:
+    """Runtime backends compiled into this inference server.
+
+    Attributes:
+        native (bool | Unset): Whether the native CPU backend is built into this runtime Example: True.
+        onnx (bool | Unset): Whether the ONNX Runtime backend is built into this runtime
+        metal (bool | Unset): Whether the Metal backend is built into this runtime Example: True.
+        mlx (bool | Unset): Whether the MLX backend is built into this runtime Example: True.
+        cuda (bool | Unset): Whether the CUDA backend is built into this runtime
+        xla (bool | Unset): Whether the PJRT/XLA backend is built into this runtime
+        wasm (bool | Unset): Whether the WASM backend is built into this runtime
+    """
+
+    native: bool | Unset = UNSET
+    onnx: bool | Unset = UNSET
+    metal: bool | Unset = UNSET
+    mlx: bool | Unset = UNSET
+    cuda: bool | Unset = UNSET
+    xla: bool | Unset = UNSET
+    wasm: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        native = self.native
+
+        onnx = self.onnx
+
+        metal = self.metal
+
+        mlx = self.mlx
+
+        cuda = self.cuda
+
+        xla = self.xla
+
+        wasm = self.wasm
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if native is not UNSET:
+            field_dict["native"] = native
+        if onnx is not UNSET:
+            field_dict["onnx"] = onnx
+        if metal is not UNSET:
+            field_dict["metal"] = metal
+        if mlx is not UNSET:
+            field_dict["mlx"] = mlx
+        if cuda is not UNSET:
+            field_dict["cuda"] = cuda
+        if xla is not UNSET:
+            field_dict["xla"] = xla
+        if wasm is not UNSET:
+            field_dict["wasm"] = wasm
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        native = d.pop("native", UNSET)
+
+        onnx = d.pop("onnx", UNSET)
+
+        metal = d.pop("metal", UNSET)
+
+        mlx = d.pop("mlx", UNSET)
+
+        cuda = d.pop("cuda", UNSET)
+
+        xla = d.pop("xla", UNSET)
+
+        wasm = d.pop("wasm", UNSET)
+
+        inference_backend_runtimes = cls(
+            native=native,
+            onnx=onnx,
+            metal=metal,
+            mlx=mlx,
+            cuda=cuda,
+            xla=xla,
+            wasm=wasm,
+        )
+
+        inference_backend_runtimes.additional_properties = d
+        return inference_backend_runtimes
+
+    @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/inference_binary_content.py

@@ -0,0 +1,98 @@
+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="InferenceBinaryContent")
+
+
+@_attrs_define
+class InferenceBinaryContent:
+    """Binary media content with format-specific metadata.
+
+    Attributes:
+        data (str | Unset): Base64-encoded binary data (valid WAV, PNG, etc.)
+        start_time_ms (float | Unset): Audio: window start time in milliseconds
+        end_time_ms (float | Unset): Audio: window end time in milliseconds
+        frame_index (int | Unset): Animation: frame number
+        frame_delay_ms (int | Unset): Animation: display delay in milliseconds
+    """
+
+    data: str | Unset = UNSET
+    start_time_ms: float | Unset = UNSET
+    end_time_ms: float | Unset = UNSET
+    frame_index: int | Unset = UNSET
+    frame_delay_ms: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        data = self.data
+
+        start_time_ms = self.start_time_ms
+
+        end_time_ms = self.end_time_ms
+
+        frame_index = self.frame_index
+
+        frame_delay_ms = self.frame_delay_ms
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if data is not UNSET:
+            field_dict["data"] = data
+        if start_time_ms is not UNSET:
+            field_dict["start_time_ms"] = start_time_ms
+        if end_time_ms is not UNSET:
+            field_dict["end_time_ms"] = end_time_ms
+        if frame_index is not UNSET:
+            field_dict["frame_index"] = frame_index
+        if frame_delay_ms is not UNSET:
+            field_dict["frame_delay_ms"] = frame_delay_ms
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        data = d.pop("data", UNSET)
+
+        start_time_ms = d.pop("start_time_ms", UNSET)
+
+        end_time_ms = d.pop("end_time_ms", UNSET)
+
+        frame_index = d.pop("frame_index", UNSET)
+
+        frame_delay_ms = d.pop("frame_delay_ms", UNSET)
+
+        inference_binary_content = cls(
+            data=data,
+            start_time_ms=start_time_ms,
+            end_time_ms=end_time_ms,
+            frame_index=frame_index,
+            frame_delay_ms=frame_delay_ms,
+        )
+
+        inference_binary_content.additional_properties = d
+        return inference_binary_content
+
+    @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