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

antfly/client_generated/models/inference_generate_usage.py

@@ -0,0 +1,77 @@
+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="InferenceGenerateUsage")
+
+
+@_attrs_define
+class InferenceGenerateUsage:
+    """
+    Attributes:
+        prompt_tokens (int): Number of tokens in the prompt
+        completion_tokens (int): Number of tokens in the completion
+        total_tokens (int): Total tokens used (prompt + completion)
+    """
+
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        prompt_tokens = self.prompt_tokens
+
+        completion_tokens = self.completion_tokens
+
+        total_tokens = self.total_tokens
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "prompt_tokens": prompt_tokens,
+                "completion_tokens": completion_tokens,
+                "total_tokens": total_tokens,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        prompt_tokens = d.pop("prompt_tokens")
+
+        completion_tokens = d.pop("completion_tokens")
+
+        total_tokens = d.pop("total_tokens")
+
+        inference_generate_usage = cls(
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            total_tokens=total_tokens,
+        )
+
+        inference_generate_usage.additional_properties = d
+        return inference_generate_usage
+
+    @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_image_url.py

@@ -0,0 +1,62 @@
+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="InferenceImageURL")
+
+
+@_attrs_define
+class InferenceImageURL:
+    """Image URL or data URI.
+
+    Attributes:
+        url (str): URL or data URI (data:image/png;base64,...). Example: data:image/png;base64,iVBORw0KGgo....
+    """
+
+    url: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "url": url,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        inference_image_url = cls(
+            url=url,
+        )
+
+        inference_image_url.additional_properties = d
+        return inference_image_url
+
+    @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_image_url_content_part.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_image_url_content_part_type import InferenceImageURLContentPartType
+
+if TYPE_CHECKING:
+    from ..models.image_url import ImageURL
+
+
+T = TypeVar("T", bound="InferenceImageURLContentPart")
+
+
+@_attrs_define
+class InferenceImageURLContentPart:
+    """Image content in OpenAI-compatible format.
+
+    Attributes:
+        type_ (InferenceImageURLContentPartType):
+        image_url (ImageURL): Image URL or data URI.
+    """
+
+    type_: InferenceImageURLContentPartType
+    image_url: ImageURL
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_.value
+
+        image_url = self.image_url.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "image_url": image_url,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.image_url import ImageURL
+
+        d = dict(src_dict)
+        type_ = InferenceImageURLContentPartType(d.pop("type"))
+
+        image_url = ImageURL.from_dict(d.pop("image_url"))
+
+        inference_image_url_content_part = cls(
+            type_=type_,
+            image_url=image_url,
+        )
+
+        inference_image_url_content_part.additional_properties = d
+        return inference_image_url_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_image_url_content_part_type.py

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

antfly/client_generated/models/inference_level.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class InferenceLevel(str, Enum):
+    DEBUG = "debug"
+    ERROR = "error"
+    INFO = "info"
+    WARN = "warn"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/inference_media_content_part.py

@@ -0,0 +1,80 @@
+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_media_content_part_type import InferenceMediaContentPartType
+
+T = TypeVar("T", bound="InferenceMediaContentPart")
+
+
+@_attrs_define
+class InferenceMediaContentPart:
+    """Inline binary media content (audio, image, etc.).
+
+    Attributes:
+        type_ (InferenceMediaContentPartType):
+        data (str): Base64-encoded binary data.
+        mime_type (str): MIME type (audio/wav, image/gif, image/png, etc.).
+    """
+
+    type_: InferenceMediaContentPartType
+    data: str
+    mime_type: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_.value
+
+        data = self.data
+
+        mime_type = self.mime_type
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "data": data,
+                "mime_type": mime_type,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        type_ = InferenceMediaContentPartType(d.pop("type"))
+
+        data = d.pop("data")
+
+        mime_type = d.pop("mime_type")
+
+        inference_media_content_part = cls(
+            type_=type_,
+            data=data,
+            mime_type=mime_type,
+        )
+
+        inference_media_content_part.additional_properties = d
+        return inference_media_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_media_content_part_type.py

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

antfly/client_generated/models/inference_model_info.py

@@ -0,0 +1,76 @@
+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="InferenceModelInfo")
+
+
+@_attrs_define
+class InferenceModelInfo:
+    """Information about a model including its capabilities
+
+    Attributes:
+        capabilities (list[str] | Unset): List of capabilities this model supports (omitted when empty). For rerankers,
+            `late_interaction` or `colbert` selects native MaxSim token scoring.
+        inputs (list[str] | Unset): List of input modalities this model accepts, such as `text`, `image`, or `audio`
+    """
+
+    capabilities: list[str] | Unset = UNSET
+    inputs: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        capabilities: list[str] | Unset = UNSET
+        if not isinstance(self.capabilities, Unset):
+            capabilities = self.capabilities
+
+        inputs: list[str] | Unset = UNSET
+        if not isinstance(self.inputs, Unset):
+            inputs = self.inputs
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if capabilities is not UNSET:
+            field_dict["capabilities"] = capabilities
+        if inputs is not UNSET:
+            field_dict["inputs"] = inputs
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        capabilities = cast(list[str], d.pop("capabilities", UNSET))
+
+        inputs = cast(list[str], d.pop("inputs", UNSET))
+
+        inference_model_info = cls(
+            capabilities=capabilities,
+            inputs=inputs,
+        )
+
+        inference_model_info.additional_properties = d
+        return inference_model_info
+
+    @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_models_response.py

@@ -0,0 +1,204 @@
+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_models_response_object import InferenceModelsResponseObject
+
+if TYPE_CHECKING:
+    from ..models.inference_backend_runtimes import InferenceBackendRuntimes
+    from ..models.inference_models_response_chunkers import InferenceModelsResponseChunkers
+    from ..models.inference_models_response_classifiers import InferenceModelsResponseClassifiers
+    from ..models.inference_models_response_data_item import InferenceModelsResponseDataItem
+    from ..models.inference_models_response_embedders import InferenceModelsResponseEmbedders
+    from ..models.inference_models_response_extractors import InferenceModelsResponseExtractors
+    from ..models.inference_models_response_generators import InferenceModelsResponseGenerators
+    from ..models.inference_models_response_readers import InferenceModelsResponseReaders
+    from ..models.inference_models_response_recognizers import InferenceModelsResponseRecognizers
+    from ..models.inference_models_response_rerankers import InferenceModelsResponseRerankers
+    from ..models.inference_models_response_rewriters import InferenceModelsResponseRewriters
+    from ..models.inference_models_response_transcribers import InferenceModelsResponseTranscribers
+
+
+T = TypeVar("T", bound="InferenceModelsResponse")
+
+
+@_attrs_define
+class InferenceModelsResponse:
+    """
+    Attributes:
+        object_ (InferenceModelsResponseObject): OpenAI-compatible response object type.
+        data (list[InferenceModelsResponseDataItem]): OpenAI-compatible flat model list for generation/embedding models.
+        allow_downloads (bool): Whether clients should show model download commands. Default: True.
+        backends (InferenceBackendRuntimes): Runtime backends compiled into this inference server.
+        chunkers (InferenceModelsResponseChunkers): Available chunking models (always includes "fixed")
+        rerankers (InferenceModelsResponseRerankers): Available reranking models
+        classifiers (InferenceModelsResponseClassifiers): Available zero-shot classification models
+        embedders (InferenceModelsResponseEmbedders): Available embedding models from models_dir/embedders/
+        extractors (InferenceModelsResponseExtractors): Available extractor models (models with 'extraction' capability)
+        generators (InferenceModelsResponseGenerators): Available generator/LLM models from models_dir/generators/
+        recognizers (InferenceModelsResponseRecognizers): Available recognizer models from models_dir/recognizers/
+        rewriters (InferenceModelsResponseRewriters): Available Seq2Seq rewriter models from models_dir/rewriters/
+        readers (InferenceModelsResponseReaders): Available reader/OCR models from models_dir/readers/
+        transcribers (InferenceModelsResponseTranscribers): Available transcriber/speech-to-text models from
+            models_dir/transcribers/
+    """
+
+    object_: InferenceModelsResponseObject
+    data: list[InferenceModelsResponseDataItem]
+    backends: InferenceBackendRuntimes
+    chunkers: InferenceModelsResponseChunkers
+    rerankers: InferenceModelsResponseRerankers
+    classifiers: InferenceModelsResponseClassifiers
+    embedders: InferenceModelsResponseEmbedders
+    extractors: InferenceModelsResponseExtractors
+    generators: InferenceModelsResponseGenerators
+    recognizers: InferenceModelsResponseRecognizers
+    rewriters: InferenceModelsResponseRewriters
+    readers: InferenceModelsResponseReaders
+    transcribers: InferenceModelsResponseTranscribers
+    allow_downloads: bool = True
+    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)
+
+        allow_downloads = self.allow_downloads
+
+        backends = self.backends.to_dict()
+
+        chunkers = self.chunkers.to_dict()
+
+        rerankers = self.rerankers.to_dict()
+
+        classifiers = self.classifiers.to_dict()
+
+        embedders = self.embedders.to_dict()
+
+        extractors = self.extractors.to_dict()
+
+        generators = self.generators.to_dict()
+
+        recognizers = self.recognizers.to_dict()
+
+        rewriters = self.rewriters.to_dict()
+
+        readers = self.readers.to_dict()
+
+        transcribers = self.transcribers.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "object": object_,
+                "data": data,
+                "allow_downloads": allow_downloads,
+                "backends": backends,
+                "chunkers": chunkers,
+                "rerankers": rerankers,
+                "classifiers": classifiers,
+                "embedders": embedders,
+                "extractors": extractors,
+                "generators": generators,
+                "recognizers": recognizers,
+                "rewriters": rewriters,
+                "readers": readers,
+                "transcribers": transcribers,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_backend_runtimes import InferenceBackendRuntimes
+        from ..models.inference_models_response_chunkers import InferenceModelsResponseChunkers
+        from ..models.inference_models_response_classifiers import InferenceModelsResponseClassifiers
+        from ..models.inference_models_response_data_item import InferenceModelsResponseDataItem
+        from ..models.inference_models_response_embedders import InferenceModelsResponseEmbedders
+        from ..models.inference_models_response_extractors import InferenceModelsResponseExtractors
+        from ..models.inference_models_response_generators import InferenceModelsResponseGenerators
+        from ..models.inference_models_response_readers import InferenceModelsResponseReaders
+        from ..models.inference_models_response_recognizers import InferenceModelsResponseRecognizers
+        from ..models.inference_models_response_rerankers import InferenceModelsResponseRerankers
+        from ..models.inference_models_response_rewriters import InferenceModelsResponseRewriters
+        from ..models.inference_models_response_transcribers import InferenceModelsResponseTranscribers
+
+        d = dict(src_dict)
+        object_ = InferenceModelsResponseObject(d.pop("object"))
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = InferenceModelsResponseDataItem.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        allow_downloads = d.pop("allow_downloads")
+
+        backends = InferenceBackendRuntimes.from_dict(d.pop("backends"))
+
+        chunkers = InferenceModelsResponseChunkers.from_dict(d.pop("chunkers"))
+
+        rerankers = InferenceModelsResponseRerankers.from_dict(d.pop("rerankers"))
+
+        classifiers = InferenceModelsResponseClassifiers.from_dict(d.pop("classifiers"))
+
+        embedders = InferenceModelsResponseEmbedders.from_dict(d.pop("embedders"))
+
+        extractors = InferenceModelsResponseExtractors.from_dict(d.pop("extractors"))
+
+        generators = InferenceModelsResponseGenerators.from_dict(d.pop("generators"))
+
+        recognizers = InferenceModelsResponseRecognizers.from_dict(d.pop("recognizers"))
+
+        rewriters = InferenceModelsResponseRewriters.from_dict(d.pop("rewriters"))
+
+        readers = InferenceModelsResponseReaders.from_dict(d.pop("readers"))
+
+        transcribers = InferenceModelsResponseTranscribers.from_dict(d.pop("transcribers"))
+
+        inference_models_response = cls(
+            object_=object_,
+            data=data,
+            allow_downloads=allow_downloads,
+            backends=backends,
+            chunkers=chunkers,
+            rerankers=rerankers,
+            classifiers=classifiers,
+            embedders=embedders,
+            extractors=extractors,
+            generators=generators,
+            recognizers=recognizers,
+            rewriters=rewriters,
+            readers=readers,
+            transcribers=transcribers,
+        )
+
+        inference_models_response.additional_properties = d
+        return inference_models_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_models_response_chunkers.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.inference_model_info import InferenceModelInfo
+
+
+T = TypeVar("T", bound="InferenceModelsResponseChunkers")
+
+
+@_attrs_define
+class InferenceModelsResponseChunkers:
+    """Available chunking models (always includes "fixed")"""
+
+    additional_properties: dict[str, InferenceModelInfo] = _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.inference_model_info import InferenceModelInfo
+
+        d = dict(src_dict)
+        inference_models_response_chunkers = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = InferenceModelInfo.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        inference_models_response_chunkers.additional_properties = additional_properties
+        return inference_models_response_chunkers
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> InferenceModelInfo:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: InferenceModelInfo) -> 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