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

antfly/client_generated/models/inference_rewrite_response.py

@@ -0,0 +1,103 @@
+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.inference_rewrite_response_object import InferenceRewriteResponseObject
+
+if TYPE_CHECKING:
+    from ..models.inference_generate_usage import InferenceGenerateUsage
+    from ..models.inference_rewrite_object import InferenceRewriteObject
+
+
+T = TypeVar("T", bound="InferenceRewriteResponse")
+
+
+@_attrs_define
+class InferenceRewriteResponse:
+    """
+    Attributes:
+        object_ (InferenceRewriteResponseObject): Object type, always "list"
+        data (list[InferenceRewriteObject]): Rewritten text objects, one per input.
+        model (str): Name of model used for rewriting
+        usage (InferenceGenerateUsage):
+    """
+
+    object_: InferenceRewriteResponseObject
+    data: list[InferenceRewriteObject]
+    model: str
+    usage: InferenceGenerateUsage
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        object_ = self.object_.value
+
+        data = []
+        for data_item_data in self.data:
+            data_item = data_item_data.to_dict()
+            data.append(data_item)
+
+        model = self.model
+
+        usage = self.usage.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "object": object_,
+                "data": data,
+                "model": model,
+                "usage": usage,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_generate_usage import InferenceGenerateUsage
+        from ..models.inference_rewrite_object import InferenceRewriteObject
+
+        d = dict(src_dict)
+        object_ = InferenceRewriteResponseObject(d.pop("object"))
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = InferenceRewriteObject.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        model = d.pop("model")
+
+        usage = InferenceGenerateUsage.from_dict(d.pop("usage"))
+
+        inference_rewrite_response = cls(
+            object_=object_,
+            data=data,
+            model=model,
+            usage=usage,
+        )
+
+        inference_rewrite_response.additional_properties = d
+        return inference_rewrite_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/inference_rewrite_response_object.py

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

antfly/client_generated/models/inference_role.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class InferenceRole(str, Enum):
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+    TOOL = "tool"
+    USER = "user"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/inference_sparse_vector.py

@@ -0,0 +1,70 @@
+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
+
+T = TypeVar("T", bound="InferenceSparseVector")
+
+
+@_attrs_define
+class InferenceSparseVector:
+    """A sparse vector with parallel index/value arrays, sorted by index ascending
+
+    Attributes:
+        indices (list[int]): Token IDs from the model vocabulary (sorted ascending)
+        values (list[float]): Corresponding weights for each index (always positive)
+    """
+
+    indices: list[int]
+    values: list[float]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        indices = self.indices
+
+        values = self.values
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "indices": indices,
+                "values": values,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        indices = cast(list[int], d.pop("indices"))
+
+        values = cast(list[float], d.pop("values"))
+
+        inference_sparse_vector = cls(
+            indices=indices,
+            values=values,
+        )
+
+        inference_sparse_vector.additional_properties = d
+        return inference_sparse_vector
+
+    @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_style.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class InferenceStyle(str, Enum):
+    JSON = "json"
+    LOGFMT = "logfmt"
+    NOOP = "noop"
+    TERMINAL = "terminal"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/inference_text_chunk_options.py

@@ -0,0 +1,82 @@
+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="InferenceTextChunkOptions")
+
+
+@_attrs_define
+class InferenceTextChunkOptions:
+    r"""Options specific to text chunking.
+
+    Attributes:
+        target_tokens (int | Unset): Target number of tokens per chunk.
+        overlap_tokens (int | Unset): Number of tokens to overlap between consecutive chunks. Helps maintain context
+            across chunk boundaries. Only used by fixed-size chunkers.
+        separator (str | Unset): Separator string for splitting (e.g., '\n\n' for paragraphs). Only used by fixed-size
+            chunkers.
+    """
+
+    target_tokens: int | Unset = UNSET
+    overlap_tokens: int | Unset = UNSET
+    separator: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        target_tokens = self.target_tokens
+
+        overlap_tokens = self.overlap_tokens
+
+        separator = self.separator
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if target_tokens is not UNSET:
+            field_dict["target_tokens"] = target_tokens
+        if overlap_tokens is not UNSET:
+            field_dict["overlap_tokens"] = overlap_tokens
+        if separator is not UNSET:
+            field_dict["separator"] = separator
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        target_tokens = d.pop("target_tokens", UNSET)
+
+        overlap_tokens = d.pop("overlap_tokens", UNSET)
+
+        separator = d.pop("separator", UNSET)
+
+        inference_text_chunk_options = cls(
+            target_tokens=target_tokens,
+            overlap_tokens=overlap_tokens,
+            separator=separator,
+        )
+
+        inference_text_chunk_options.additional_properties = d
+        return inference_text_chunk_options
+
+    @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_text_content.py

@@ -0,0 +1,78 @@
+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="InferenceTextContent")
+
+
+@_attrs_define
+class InferenceTextContent:
+    """Text content with character offsets.
+
+    Attributes:
+        text (str): The chunk text content
+        start_char (int): Character position in original text where chunk starts
+        end_char (int): Character position in original text where chunk ends (exclusive)
+    """
+
+    text: str
+    start_char: int
+    end_char: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        text = self.text
+
+        start_char = self.start_char
+
+        end_char = self.end_char
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "text": text,
+                "start_char": start_char,
+                "end_char": end_char,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        text = d.pop("text")
+
+        start_char = d.pop("start_char")
+
+        end_char = d.pop("end_char")
+
+        inference_text_content = cls(
+            text=text,
+            start_char=start_char,
+            end_char=end_char,
+        )
+
+        inference_text_content.additional_properties = d
+        return inference_text_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

antfly/client_generated/models/inference_text_content_part.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.inference_text_content_part_type import InferenceTextContentPartType
+
+T = TypeVar("T", bound="InferenceTextContentPart")
+
+
+@_attrs_define
+class InferenceTextContentPart:
+    """Text content for multimodal input.
+
+    Attributes:
+        type_ (InferenceTextContentPartType):
+        text (str): Text content.
+    """
+
+    type_: InferenceTextContentPartType
+    text: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_.value
+
+        text = self.text
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "text": text,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        type_ = InferenceTextContentPartType(d.pop("type"))
+
+        text = d.pop("text")
+
+        inference_text_content_part = cls(
+            type_=type_,
+            text=text,
+        )
+
+        inference_text_content_part.additional_properties = d
+        return inference_text_content_part
+
+    @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_text_content_part_type.py

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

antfly/client_generated/models/inference_text_region.py

@@ -0,0 +1,89 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="InferenceTextRegion")
+
+
+@_attrs_define
+class InferenceTextRegion:
+    """
+    Attributes:
+        text (str): Recognized text within the region
+        bbox (list[float]): Bounding box [x1, y1, x2, y2] in pixel coordinates
+        confidence (float | Unset): Recognition confidence score (0-1)
+        label (str | Unset): Semantic label from layout analysis (e.g., text, title, table)
+    """
+
+    text: str
+    bbox: list[float]
+    confidence: float | Unset = UNSET
+    label: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        text = self.text
+
+        bbox = self.bbox
+
+        confidence = self.confidence
+
+        label = self.label
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "text": text,
+                "bbox": bbox,
+            }
+        )
+        if confidence is not UNSET:
+            field_dict["confidence"] = confidence
+        if label is not UNSET:
+            field_dict["label"] = label
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        text = d.pop("text")
+
+        bbox = cast(list[float], d.pop("bbox"))
+
+        confidence = d.pop("confidence", UNSET)
+
+        label = d.pop("label", UNSET)
+
+        inference_text_region = cls(
+            text=text,
+            bbox=bbox,
+            confidence=confidence,
+            label=label,
+        )
+
+        inference_text_region.additional_properties = d
+        return inference_text_region
+
+    @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_tool.py

@@ -0,0 +1,78 @@
+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.inference_tool_type import InferenceToolType
+
+if TYPE_CHECKING:
+    from ..models.inference_function_definition import InferenceFunctionDefinition
+
+
+T = TypeVar("T", bound="InferenceTool")
+
+
+@_attrs_define
+class InferenceTool:
+    """A tool (function) that the model can call
+
+    Attributes:
+        type_ (InferenceToolType): The type of tool (currently only "function" is supported)
+        function (InferenceFunctionDefinition): Definition of a function that can be called by the model
+    """
+
+    type_: InferenceToolType
+    function: InferenceFunctionDefinition
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_.value
+
+        function = self.function.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "function": function,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_function_definition import InferenceFunctionDefinition
+
+        d = dict(src_dict)
+        type_ = InferenceToolType(d.pop("type"))
+
+        function = InferenceFunctionDefinition.from_dict(d.pop("function"))
+
+        inference_tool = cls(
+            type_=type_,
+            function=function,
+        )
+
+        inference_tool.additional_properties = d
+        return inference_tool
+
+    @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