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

antfly/client_generated/models/inference_chat_message.py

@@ -0,0 +1,198 @@
+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.inference_role import InferenceRole
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.image_url_content_part import ImageURLContentPart
+    from ..models.media_content_part import MediaContentPart
+    from ..models.text_content_part import TextContentPart
+    from ..models.tool_call import ToolCall
+
+
+T = TypeVar("T", bound="InferenceChatMessage")
+
+
+@_attrs_define
+class InferenceChatMessage:
+    """
+    Attributes:
+        role (InferenceRole): Role of the message sender in a generation/chat conversation
+        content (list[ImageURLContentPart | MediaContentPart | TextContentPart] | str | Unset): Message content.
+            Supports two formats:
+            - Simple string: "Hello, how are you?"
+            - Array of content parts: [{"type": "text", "text": "Hello"}]
+        tool_calls (list[ToolCall] | Unset): Tool calls made by the assistant (only for role=assistant)
+        tool_call_id (str | Unset): ID of the tool call this message is responding to (only for role=tool)
+    """
+
+    role: InferenceRole
+    content: list[ImageURLContentPart | MediaContentPart | TextContentPart] | str | Unset = UNSET
+    tool_calls: list[ToolCall] | Unset = UNSET
+    tool_call_id: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.image_url_content_part import ImageURLContentPart
+        from ..models.text_content_part import TextContentPart
+
+        role = self.role.value
+
+        content: list[dict[str, Any]] | str | Unset
+        if isinstance(self.content, Unset):
+            content = UNSET
+        elif isinstance(self.content, list):
+            content = []
+            for componentsschemas_chat_message_content_type_1_item_data in self.content:
+                componentsschemas_chat_message_content_type_1_item: dict[str, Any]
+                if isinstance(componentsschemas_chat_message_content_type_1_item_data, TextContentPart):
+                    componentsschemas_chat_message_content_type_1_item = (
+                        componentsschemas_chat_message_content_type_1_item_data.to_dict()
+                    )
+                elif isinstance(componentsschemas_chat_message_content_type_1_item_data, ImageURLContentPart):
+                    componentsschemas_chat_message_content_type_1_item = (
+                        componentsschemas_chat_message_content_type_1_item_data.to_dict()
+                    )
+                else:
+                    componentsschemas_chat_message_content_type_1_item = (
+                        componentsschemas_chat_message_content_type_1_item_data.to_dict()
+                    )
+
+                content.append(componentsschemas_chat_message_content_type_1_item)
+
+        else:
+            content = self.content
+
+        tool_calls: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.tool_calls, Unset):
+            tool_calls = []
+            for tool_calls_item_data in self.tool_calls:
+                tool_calls_item = tool_calls_item_data.to_dict()
+                tool_calls.append(tool_calls_item)
+
+        tool_call_id = self.tool_call_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "role": role,
+            }
+        )
+        if content is not UNSET:
+            field_dict["content"] = content
+        if tool_calls is not UNSET:
+            field_dict["tool_calls"] = tool_calls
+        if tool_call_id is not UNSET:
+            field_dict["tool_call_id"] = tool_call_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.image_url_content_part import ImageURLContentPart
+        from ..models.media_content_part import MediaContentPart
+        from ..models.text_content_part import TextContentPart
+        from ..models.tool_call import ToolCall
+
+        d = dict(src_dict)
+        role = InferenceRole(d.pop("role"))
+
+        def _parse_content(
+            data: object,
+        ) -> list[ImageURLContentPart | MediaContentPart | TextContentPart] | str | Unset:
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                componentsschemas_chat_message_content_type_1 = []
+                _componentsschemas_chat_message_content_type_1 = data
+                for (
+                    componentsschemas_chat_message_content_type_1_item_data
+                ) in _componentsschemas_chat_message_content_type_1:
+
+                    def _parse_componentsschemas_chat_message_content_type_1_item(
+                        data: object,
+                    ) -> ImageURLContentPart | MediaContentPart | TextContentPart:
+                        try:
+                            if not isinstance(data, dict):
+                                raise TypeError()
+                            componentsschemas_content_part_type_0 = TextContentPart.from_dict(data)
+
+                            return componentsschemas_content_part_type_0
+                        except (TypeError, ValueError, AttributeError, KeyError):
+                            pass
+                        try:
+                            if not isinstance(data, dict):
+                                raise TypeError()
+                            componentsschemas_content_part_type_1 = ImageURLContentPart.from_dict(data)
+
+                            return componentsschemas_content_part_type_1
+                        except (TypeError, ValueError, AttributeError, KeyError):
+                            pass
+                        if not isinstance(data, dict):
+                            raise TypeError()
+                        componentsschemas_content_part_type_2 = MediaContentPart.from_dict(data)
+
+                        return componentsschemas_content_part_type_2
+
+                    componentsschemas_chat_message_content_type_1_item = (
+                        _parse_componentsschemas_chat_message_content_type_1_item(
+                            componentsschemas_chat_message_content_type_1_item_data
+                        )
+                    )
+
+                    componentsschemas_chat_message_content_type_1.append(
+                        componentsschemas_chat_message_content_type_1_item
+                    )
+
+                return componentsschemas_chat_message_content_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[ImageURLContentPart | MediaContentPart | TextContentPart] | str | Unset, data)
+
+        content = _parse_content(d.pop("content", UNSET))
+
+        _tool_calls = d.pop("tool_calls", UNSET)
+        tool_calls: list[ToolCall] | Unset = UNSET
+        if _tool_calls is not UNSET:
+            tool_calls = []
+            for tool_calls_item_data in _tool_calls:
+                tool_calls_item = ToolCall.from_dict(tool_calls_item_data)
+
+                tool_calls.append(tool_calls_item)
+
+        tool_call_id = d.pop("tool_call_id", UNSET)
+
+        inference_chat_message = cls(
+            role=role,
+            content=content,
+            tool_calls=tool_calls,
+            tool_call_id=tool_call_id,
+        )
+
+        inference_chat_message.additional_properties = d
+        return inference_chat_message
+
+    @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_chunk.py

@@ -0,0 +1,70 @@
+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="InferenceChunk")
+
+
+@_attrs_define
+class InferenceChunk:
+    """A chunk of content. Text chunks have mime_type text/plain.
+
+    Attributes:
+        id (int): Sequence number of the chunk (0, 1, 2, ...)
+        mime_type (str): MIME type: text/plain, audio/wav, image/png, etc.
+    """
+
+    id: int
+    mime_type: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        mime_type = self.mime_type
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "mime_type": mime_type,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        mime_type = d.pop("mime_type")
+
+        inference_chunk = cls(
+            id=id,
+            mime_type=mime_type,
+        )
+
+        inference_chunk.additional_properties = d
+        return inference_chunk
+
+    @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_chunk_config.py

@@ -0,0 +1,123 @@
+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_audio_chunk_config import InferenceAudioChunkConfig
+    from ..models.inference_text_chunk_options import InferenceTextChunkOptions
+
+
+T = TypeVar("T", bound="InferenceChunkConfig")
+
+
+@_attrs_define
+class InferenceChunkConfig:
+    """Configuration for chunking requests to Inference API.
+    Combines shared text options with inference-specific audio/VAD options.
+
+        Attributes:
+            model (str | Unset): The chunking model to use. Either 'fixed' for simple token-based chunking, or a model name
+                from models/chunkers/{name}/. Default: 'fixed'. Example: fixed.
+            max_chunks (int | Unset): Maximum number of chunks to generate per document.
+            threshold (float | Unset): Confidence threshold for model-based chunking (0.0-1.0). Used by ONNX text models and
+                VAD audio models.
+            text (InferenceTextChunkOptions | Unset): Options specific to text chunking.
+            audio (InferenceAudioChunkConfig | Unset): Audio chunking configuration for inference, including VAD options.
+    """
+
+    model: str | Unset = "fixed"
+    max_chunks: int | Unset = UNSET
+    threshold: float | Unset = UNSET
+    text: InferenceTextChunkOptions | Unset = UNSET
+    audio: InferenceAudioChunkConfig | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        max_chunks = self.max_chunks
+
+        threshold = self.threshold
+
+        text: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.text, Unset):
+            text = self.text.to_dict()
+
+        audio: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.audio, Unset):
+            audio = self.audio.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if model is not UNSET:
+            field_dict["model"] = model
+        if max_chunks is not UNSET:
+            field_dict["max_chunks"] = max_chunks
+        if threshold is not UNSET:
+            field_dict["threshold"] = threshold
+        if text is not UNSET:
+            field_dict["text"] = text
+        if audio is not UNSET:
+            field_dict["audio"] = audio
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_audio_chunk_config import InferenceAudioChunkConfig
+        from ..models.inference_text_chunk_options import InferenceTextChunkOptions
+
+        d = dict(src_dict)
+        model = d.pop("model", UNSET)
+
+        max_chunks = d.pop("max_chunks", UNSET)
+
+        threshold = d.pop("threshold", UNSET)
+
+        _text = d.pop("text", UNSET)
+        text: InferenceTextChunkOptions | Unset
+        if isinstance(_text, Unset):
+            text = UNSET
+        else:
+            text = InferenceTextChunkOptions.from_dict(_text)
+
+        _audio = d.pop("audio", UNSET)
+        audio: InferenceAudioChunkConfig | Unset
+        if isinstance(_audio, Unset):
+            audio = UNSET
+        else:
+            audio = InferenceAudioChunkConfig.from_dict(_audio)
+
+        inference_chunk_config = cls(
+            model=model,
+            max_chunks=max_chunks,
+            threshold=threshold,
+            text=text,
+            audio=audio,
+        )
+
+        inference_chunk_config.additional_properties = d
+        return inference_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_chunk_object.py

@@ -0,0 +1,88 @@
+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.inference_chunk_object_object import InferenceChunkObjectObject
+
+T = TypeVar("T", bound="InferenceChunkObject")
+
+
+@_attrs_define
+class InferenceChunkObject:
+    """A chunk result object. Text chunks have mime_type text/plain.
+
+    Attributes:
+        id (int): Sequence number of the chunk (0, 1, 2, ...)
+        mime_type (str): MIME type: text/plain, audio/wav, image/png, etc.
+        object_ (InferenceChunkObjectObject):
+        index (int): Position of this chunk object in the response data array.
+    """
+
+    id: int
+    mime_type: str
+    object_: InferenceChunkObjectObject
+    index: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        mime_type = self.mime_type
+
+        object_ = self.object_.value
+
+        index = self.index
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "mime_type": mime_type,
+                "object": object_,
+                "index": index,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        mime_type = d.pop("mime_type")
+
+        object_ = InferenceChunkObjectObject(d.pop("object"))
+
+        index = d.pop("index")
+
+        inference_chunk_object = cls(
+            id=id,
+            mime_type=mime_type,
+            object_=object_,
+            index=index,
+        )
+
+        inference_chunk_object.additional_properties = d
+        return inference_chunk_object
+
+    @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_chunk_object_object.py

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

antfly/client_generated/models/inference_chunk_request.py

@@ -0,0 +1,148 @@
+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.image_url_content_part import ImageURLContentPart
+    from ..models.inference_chunk_config import InferenceChunkConfig
+    from ..models.media_content_part import MediaContentPart
+    from ..models.text_content_part import TextContentPart
+
+
+T = TypeVar("T", bound="InferenceChunkRequest")
+
+
+@_attrs_define
+class InferenceChunkRequest:
+    """
+    Attributes:
+        input_ (ImageURLContentPart | MediaContentPart | str | TextContentPart | Unset): Input content to chunk.
+            Supports two formats:
+            - Text string: `"This is a long document..."` (backward compatible)
+            - ContentPart: `{"type": "media", "data": "<base64>", "mime_type": "audio/wav"}`
+            - ContentPart: `{"type": "text", "text": "..."}`
+        text (str | Unset): DEPRECATED: Use 'input' instead. Text to chunk. Example: This is a long document that needs
+            to be split into smaller chunks....
+        config (InferenceChunkConfig | Unset): Configuration for chunking requests to Inference API.
+            Combines shared text options with inference-specific audio/VAD options.
+    """
+
+    input_: ImageURLContentPart | MediaContentPart | str | TextContentPart | Unset = UNSET
+    text: str | Unset = UNSET
+    config: InferenceChunkConfig | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.image_url_content_part import ImageURLContentPart
+        from ..models.media_content_part import MediaContentPart
+        from ..models.text_content_part import TextContentPart
+
+        input_: dict[str, Any] | str | Unset
+        if isinstance(self.input_, Unset):
+            input_ = UNSET
+        elif isinstance(self.input_, TextContentPart):
+            input_ = self.input_.to_dict()
+        elif isinstance(self.input_, ImageURLContentPart):
+            input_ = self.input_.to_dict()
+        elif isinstance(self.input_, MediaContentPart):
+            input_ = self.input_.to_dict()
+        else:
+            input_ = self.input_
+
+        text = self.text
+
+        config: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.config, Unset):
+            config = self.config.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if input_ is not UNSET:
+            field_dict["input"] = input_
+        if text is not UNSET:
+            field_dict["text"] = text
+        if config is not UNSET:
+            field_dict["config"] = config
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.image_url_content_part import ImageURLContentPart
+        from ..models.inference_chunk_config import InferenceChunkConfig
+        from ..models.media_content_part import MediaContentPart
+        from ..models.text_content_part import TextContentPart
+
+        d = dict(src_dict)
+
+        def _parse_input_(data: object) -> ImageURLContentPart | MediaContentPart | str | TextContentPart | Unset:
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_content_part_type_0 = TextContentPart.from_dict(data)
+
+                return componentsschemas_content_part_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_content_part_type_1 = ImageURLContentPart.from_dict(data)
+
+                return componentsschemas_content_part_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                componentsschemas_content_part_type_2 = MediaContentPart.from_dict(data)
+
+                return componentsschemas_content_part_type_2
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(ImageURLContentPart | MediaContentPart | str | TextContentPart | Unset, data)
+
+        input_ = _parse_input_(d.pop("input", UNSET))
+
+        text = d.pop("text", UNSET)
+
+        _config = d.pop("config", UNSET)
+        config: InferenceChunkConfig | Unset
+        if isinstance(_config, Unset):
+            config = UNSET
+        else:
+            config = InferenceChunkConfig.from_dict(_config)
+
+        inference_chunk_request = cls(
+            input_=input_,
+            text=text,
+            config=config,
+        )
+
+        inference_chunk_request.additional_properties = d
+        return inference_chunk_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