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

antfly/client_generated/models/inference_extract_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_extract_response_object import InferenceExtractResponseObject
+
+if TYPE_CHECKING:
+    from ..models.inference_extract_object import InferenceExtractObject
+    from ..models.inference_generate_usage import InferenceGenerateUsage
+
+
+T = TypeVar("T", bound="InferenceExtractResponse")
+
+
+@_attrs_define
+class InferenceExtractResponse:
+    """
+    Attributes:
+        object_ (InferenceExtractResponseObject): Object type, always "list"
+        data (list[InferenceExtractObject]): Extraction result objects, one per input.
+        model (str): Name of model used for extraction
+        usage (InferenceGenerateUsage):
+    """
+
+    object_: InferenceExtractResponseObject
+    data: list[InferenceExtractObject]
+    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_extract_object import InferenceExtractObject
+        from ..models.inference_generate_usage import InferenceGenerateUsage
+
+        d = dict(src_dict)
+        object_ = InferenceExtractResponseObject(d.pop("object"))
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = InferenceExtractObject.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        model = d.pop("model")
+
+        usage = InferenceGenerateUsage.from_dict(d.pop("usage"))
+
+        inference_extract_response = cls(
+            object_=object_,
+            data=data,
+            model=model,
+            usage=usage,
+        )
+
+        inference_extract_response.additional_properties = d
+        return inference_extract_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_extract_response_object.py

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

antfly/client_generated/models/inference_finish_reason.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class InferenceFinishReason(str, Enum):
+    CONTENT_FILTER = "content_filter"
+    FUNCTION_CALL = "function_call"
+    LENGTH = "length"
+    STOP = "stop"
+    TOOL_CALLS = "tool_calls"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/inference_function_definition.py

@@ -0,0 +1,107 @@
+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_function_definition_parameters import InferenceFunctionDefinitionParameters
+
+
+T = TypeVar("T", bound="InferenceFunctionDefinition")
+
+
+@_attrs_define
+class InferenceFunctionDefinition:
+    """Definition of a function that can be called by the model
+
+    Attributes:
+        name (str): The name of the function to call Example: get_weather.
+        description (str | Unset): A description of what the function does Example: Get the current weather in a
+            location.
+        parameters (InferenceFunctionDefinitionParameters | Unset): JSON Schema object describing the function
+            parameters Example: {'type': 'object', 'properties': {'location': {'type': 'string', 'description': 'The city
+            and state, e.g. San Francisco, CA'}}, 'required': ['location']}.
+        strict (bool | Unset): Whether to enforce strict parameter validation Default: False.
+    """
+
+    name: str
+    description: str | Unset = UNSET
+    parameters: InferenceFunctionDefinitionParameters | Unset = UNSET
+    strict: bool | Unset = False
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        description = self.description
+
+        parameters: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.parameters, Unset):
+            parameters = self.parameters.to_dict()
+
+        strict = self.strict
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if description is not UNSET:
+            field_dict["description"] = description
+        if parameters is not UNSET:
+            field_dict["parameters"] = parameters
+        if strict is not UNSET:
+            field_dict["strict"] = strict
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_function_definition_parameters import InferenceFunctionDefinitionParameters
+
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        description = d.pop("description", UNSET)
+
+        _parameters = d.pop("parameters", UNSET)
+        parameters: InferenceFunctionDefinitionParameters | Unset
+        if isinstance(_parameters, Unset):
+            parameters = UNSET
+        else:
+            parameters = InferenceFunctionDefinitionParameters.from_dict(_parameters)
+
+        strict = d.pop("strict", UNSET)
+
+        inference_function_definition = cls(
+            name=name,
+            description=description,
+            parameters=parameters,
+            strict=strict,
+        )
+
+        inference_function_definition.additional_properties = d
+        return inference_function_definition
+
+    @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_function_definition_parameters.py

@@ -0,0 +1,53 @@
+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="InferenceFunctionDefinitionParameters")
+
+
+@_attrs_define
+class InferenceFunctionDefinitionParameters:
+    """JSON Schema object describing the function parameters
+
+    Example:
+        {'type': 'object', 'properties': {'location': {'type': 'string', 'description': 'The city and state, e.g. San
+            Francisco, CA'}}, 'required': ['location']}
+
+    """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        inference_function_definition_parameters = cls()
+
+        inference_function_definition_parameters.additional_properties = d
+        return inference_function_definition_parameters
+
+    @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_generate_choice.py

@@ -0,0 +1,121 @@
+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_finish_reason import InferenceFinishReason
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.inference_generate_choice_logprobs_type_0 import InferenceGenerateChoiceLogprobsType0
+    from ..models.inference_generate_message import InferenceGenerateMessage
+
+
+T = TypeVar("T", bound="InferenceGenerateChoice")
+
+
+@_attrs_define
+class InferenceGenerateChoice:
+    """
+    Attributes:
+        index (int): Index of this choice in the list
+        message (InferenceGenerateMessage):
+        finish_reason (InferenceFinishReason): Reason why generation stopped
+        logprobs (InferenceGenerateChoiceLogprobsType0 | None | Unset): Log probability information (not supported,
+            always null)
+    """
+
+    index: int
+    message: InferenceGenerateMessage
+    finish_reason: InferenceFinishReason
+    logprobs: InferenceGenerateChoiceLogprobsType0 | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.inference_generate_choice_logprobs_type_0 import InferenceGenerateChoiceLogprobsType0
+
+        index = self.index
+
+        message = self.message.to_dict()
+
+        finish_reason = self.finish_reason.value
+
+        logprobs: dict[str, Any] | None | Unset
+        if isinstance(self.logprobs, Unset):
+            logprobs = UNSET
+        elif isinstance(self.logprobs, InferenceGenerateChoiceLogprobsType0):
+            logprobs = self.logprobs.to_dict()
+        else:
+            logprobs = self.logprobs
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "index": index,
+                "message": message,
+                "finish_reason": finish_reason,
+            }
+        )
+        if logprobs is not UNSET:
+            field_dict["logprobs"] = logprobs
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_generate_choice_logprobs_type_0 import InferenceGenerateChoiceLogprobsType0
+        from ..models.inference_generate_message import InferenceGenerateMessage
+
+        d = dict(src_dict)
+        index = d.pop("index")
+
+        message = InferenceGenerateMessage.from_dict(d.pop("message"))
+
+        finish_reason = InferenceFinishReason(d.pop("finish_reason"))
+
+        def _parse_logprobs(data: object) -> InferenceGenerateChoiceLogprobsType0 | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                logprobs_type_0 = InferenceGenerateChoiceLogprobsType0.from_dict(data)
+
+                return logprobs_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(InferenceGenerateChoiceLogprobsType0 | None | Unset, data)
+
+        logprobs = _parse_logprobs(d.pop("logprobs", UNSET))
+
+        inference_generate_choice = cls(
+            index=index,
+            message=message,
+            finish_reason=finish_reason,
+            logprobs=logprobs,
+        )
+
+        inference_generate_choice.additional_properties = d
+        return inference_generate_choice
+
+    @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_generate_choice_logprobs_type_0.py

@@ -0,0 +1,47 @@
+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="InferenceGenerateChoiceLogprobsType0")
+
+
+@_attrs_define
+class InferenceGenerateChoiceLogprobsType0:
+    """Log probability information (not supported, always null)"""
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        inference_generate_choice_logprobs_type_0 = cls()
+
+        inference_generate_choice_logprobs_type_0.additional_properties = d
+        return inference_generate_choice_logprobs_type_0
+
+    @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_generate_chunk.py

@@ -0,0 +1,110 @@
+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_generate_chunk_object import InferenceGenerateChunkObject
+
+if TYPE_CHECKING:
+    from ..models.inference_generate_chunk_choice import InferenceGenerateChunkChoice
+
+
+T = TypeVar("T", bound="InferenceGenerateChunk")
+
+
+@_attrs_define
+class InferenceGenerateChunk:
+    """Streaming generation chunk (SSE event data)
+
+    Attributes:
+        id (str):
+        object_ (InferenceGenerateChunkObject):
+        created (int):
+        model (str):
+        choices (list[InferenceGenerateChunkChoice]):
+    """
+
+    id: str
+    object_: InferenceGenerateChunkObject
+    created: int
+    model: str
+    choices: list[InferenceGenerateChunkChoice]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        object_ = self.object_.value
+
+        created = self.created
+
+        model = self.model
+
+        choices = []
+        for choices_item_data in self.choices:
+            choices_item = choices_item_data.to_dict()
+            choices.append(choices_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "object": object_,
+                "created": created,
+                "model": model,
+                "choices": choices,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_generate_chunk_choice import InferenceGenerateChunkChoice
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        object_ = InferenceGenerateChunkObject(d.pop("object"))
+
+        created = d.pop("created")
+
+        model = d.pop("model")
+
+        choices = []
+        _choices = d.pop("choices")
+        for choices_item_data in _choices:
+            choices_item = InferenceGenerateChunkChoice.from_dict(choices_item_data)
+
+            choices.append(choices_item)
+
+        inference_generate_chunk = cls(
+            id=id,
+            object_=object_,
+            created=created,
+            model=model,
+            choices=choices,
+        )
+
+        inference_generate_chunk.additional_properties = d
+        return inference_generate_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_generate_chunk_choice.py

@@ -0,0 +1,94 @@
+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_finish_reason import InferenceFinishReason
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.inference_generate_delta import InferenceGenerateDelta
+
+
+T = TypeVar("T", bound="InferenceGenerateChunkChoice")
+
+
+@_attrs_define
+class InferenceGenerateChunkChoice:
+    """
+    Attributes:
+        index (int):
+        delta (InferenceGenerateDelta): Delta content for streaming
+        finish_reason (InferenceFinishReason | Unset): Reason why generation stopped
+    """
+
+    index: int
+    delta: InferenceGenerateDelta
+    finish_reason: InferenceFinishReason | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        index = self.index
+
+        delta = self.delta.to_dict()
+
+        finish_reason: str | Unset = UNSET
+        if not isinstance(self.finish_reason, Unset):
+            finish_reason = self.finish_reason.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "index": index,
+                "delta": delta,
+            }
+        )
+        if finish_reason is not UNSET:
+            field_dict["finish_reason"] = finish_reason
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_generate_delta import InferenceGenerateDelta
+
+        d = dict(src_dict)
+        index = d.pop("index")
+
+        delta = InferenceGenerateDelta.from_dict(d.pop("delta"))
+
+        _finish_reason = d.pop("finish_reason", UNSET)
+        finish_reason: InferenceFinishReason | Unset
+        if isinstance(_finish_reason, Unset):
+            finish_reason = UNSET
+        else:
+            finish_reason = InferenceFinishReason(_finish_reason)
+
+        inference_generate_chunk_choice = cls(
+            index=index,
+            delta=delta,
+            finish_reason=finish_reason,
+        )
+
+        inference_generate_chunk_choice.additional_properties = d
+        return inference_generate_chunk_choice
+
+    @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_generate_chunk_object.py

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