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

antfly/client_generated/models/inference_chunk_response.py

@@ -0,0 +1,117 @@
+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_chunk_response_object import InferenceChunkResponseObject
+
+if TYPE_CHECKING:
+    from ..models.inference_chunk_object import InferenceChunkObject
+    from ..models.inference_generate_usage import InferenceGenerateUsage
+
+
+T = TypeVar("T", bound="InferenceChunkResponse")
+
+
+@_attrs_define
+class InferenceChunkResponse:
+    """
+    Example:
+        {'object': 'list', 'data': [{'object': 'chunk', 'index': 0, 'id': 0, 'text': 'This is the first chunk...',
+            'start_char': 0, 'end_char': 100, 'mime_type': 'text/plain'}, {'object': 'chunk', 'index': 1, 'id': 1, 'text':
+            'This is the second chunk...', 'start_char': 90, 'end_char': 190, 'mime_type': 'text/plain'}], 'model': 'fixed',
+            'usage': {'prompt_tokens': 12, 'completion_tokens': 0, 'total_tokens': 12}, 'cache_hit': False}
+
+    Attributes:
+        object_ (InferenceChunkResponseObject): Object type, always "list"
+        data (list[InferenceChunkObject]): Array of chunk objects
+        model (str): Chunking model actually used (may differ from requested if fallback occurred) Example: fixed.
+        usage (InferenceGenerateUsage):
+        cache_hit (bool): Whether result was served from cache
+    """
+
+    object_: InferenceChunkResponseObject
+    data: list[InferenceChunkObject]
+    model: str
+    usage: InferenceGenerateUsage
+    cache_hit: bool
+    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()
+
+        cache_hit = self.cache_hit
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "object": object_,
+                "data": data,
+                "model": model,
+                "usage": usage,
+                "cache_hit": cache_hit,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_chunk_object import InferenceChunkObject
+        from ..models.inference_generate_usage import InferenceGenerateUsage
+
+        d = dict(src_dict)
+        object_ = InferenceChunkResponseObject(d.pop("object"))
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = InferenceChunkObject.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        model = d.pop("model")
+
+        usage = InferenceGenerateUsage.from_dict(d.pop("usage"))
+
+        cache_hit = d.pop("cache_hit")
+
+        inference_chunk_response = cls(
+            object_=object_,
+            data=data,
+            model=model,
+            usage=usage,
+            cache_hit=cache_hit,
+        )
+
+        inference_chunk_response.additional_properties = d
+        return inference_chunk_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_chunk_response_object.py

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

antfly/client_generated/models/inference_classify_object.py

@@ -0,0 +1,93 @@
+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_classify_object_object import InferenceClassifyObjectObject
+
+if TYPE_CHECKING:
+    from ..models.inference_classify_result import InferenceClassifyResult
+
+
+T = TypeVar("T", bound="InferenceClassifyObject")
+
+
+@_attrs_define
+class InferenceClassifyObject:
+    """
+    Attributes:
+        object_ (InferenceClassifyObjectObject):
+        index (int): Original input text index.
+        classifications (list[InferenceClassifyResult]): Classification results for this input text.
+    """
+
+    object_: InferenceClassifyObjectObject
+    index: int
+    classifications: list[InferenceClassifyResult]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        object_ = self.object_.value
+
+        index = self.index
+
+        classifications = []
+        for classifications_item_data in self.classifications:
+            classifications_item = classifications_item_data.to_dict()
+            classifications.append(classifications_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "object": object_,
+                "index": index,
+                "classifications": classifications,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_classify_result import InferenceClassifyResult
+
+        d = dict(src_dict)
+        object_ = InferenceClassifyObjectObject(d.pop("object"))
+
+        index = d.pop("index")
+
+        classifications = []
+        _classifications = d.pop("classifications")
+        for classifications_item_data in _classifications:
+            classifications_item = InferenceClassifyResult.from_dict(classifications_item_data)
+
+            classifications.append(classifications_item)
+
+        inference_classify_object = cls(
+            object_=object_,
+            index=index,
+            classifications=classifications,
+        )
+
+        inference_classify_object.additional_properties = d
+        return inference_classify_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_classify_object_object.py

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

antfly/client_generated/models/inference_classify_request.py

@@ -0,0 +1,105 @@
+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="InferenceClassifyRequest")
+
+
+@_attrs_define
+class InferenceClassifyRequest:
+    """
+    Attributes:
+        model (str): Name of classifier model from models_dir/classifiers/ Example: MoritzLaurer/mDeBERTa-v3-base-mnli-
+            xnli.
+        texts (list[str]): Texts to classify Example: ['I love this product!', 'The service was terrible.'].
+        labels (list[str]): Candidate labels for zero-shot classification.
+            The model will predict which label(s) best describe each text.
+             Example: ['positive', 'negative', 'neutral'].
+        hypothesis_template (str | Unset): Custom hypothesis template for NLI-based classification.
+            Use "{}" as placeholder for the label.
+            Default: "This example is {}."
+             Example: This text expresses a {} sentiment..
+        multi_label (bool | Unset): If true, allows multiple labels per text (independent scoring).
+            If false (default), scores are normalized across labels.
+             Default: False.
+    """
+
+    model: str
+    texts: list[str]
+    labels: list[str]
+    hypothesis_template: str | Unset = UNSET
+    multi_label: bool | Unset = False
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        texts = self.texts
+
+        labels = self.labels
+
+        hypothesis_template = self.hypothesis_template
+
+        multi_label = self.multi_label
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+                "texts": texts,
+                "labels": labels,
+            }
+        )
+        if hypothesis_template is not UNSET:
+            field_dict["hypothesis_template"] = hypothesis_template
+        if multi_label is not UNSET:
+            field_dict["multi_label"] = multi_label
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        texts = cast(list[str], d.pop("texts"))
+
+        labels = cast(list[str], d.pop("labels"))
+
+        hypothesis_template = d.pop("hypothesis_template", UNSET)
+
+        multi_label = d.pop("multi_label", UNSET)
+
+        inference_classify_request = cls(
+            model=model,
+            texts=texts,
+            labels=labels,
+            hypothesis_template=hypothesis_template,
+            multi_label=multi_label,
+        )
+
+        inference_classify_request.additional_properties = d
+        return inference_classify_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

antfly/client_generated/models/inference_classify_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_classify_response_object import InferenceClassifyResponseObject
+
+if TYPE_CHECKING:
+    from ..models.inference_classify_object import InferenceClassifyObject
+    from ..models.inference_generate_usage import InferenceGenerateUsage
+
+
+T = TypeVar("T", bound="InferenceClassifyResponse")
+
+
+@_attrs_define
+class InferenceClassifyResponse:
+    """
+    Attributes:
+        object_ (InferenceClassifyResponseObject): Object type, always "list"
+        data (list[InferenceClassifyObject]): Classification result objects, one per input text.
+        model (str): Name of model used for classification
+        usage (InferenceGenerateUsage):
+    """
+
+    object_: InferenceClassifyResponseObject
+    data: list[InferenceClassifyObject]
+    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_classify_object import InferenceClassifyObject
+        from ..models.inference_generate_usage import InferenceGenerateUsage
+
+        d = dict(src_dict)
+        object_ = InferenceClassifyResponseObject(d.pop("object"))
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = InferenceClassifyObject.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        model = d.pop("model")
+
+        usage = InferenceGenerateUsage.from_dict(d.pop("usage"))
+
+        inference_classify_response = cls(
+            object_=object_,
+            data=data,
+            model=model,
+            usage=usage,
+        )
+
+        inference_classify_response.additional_properties = d
+        return inference_classify_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_classify_response_object.py

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

antfly/client_generated/models/inference_classify_result.py

@@ -0,0 +1,69 @@
+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="InferenceClassifyResult")
+
+
+@_attrs_define
+class InferenceClassifyResult:
+    """
+    Attributes:
+        label (str): The predicted class/category Example: positive.
+        score (float): Confidence score (0.0 to 1.0) Example: 0.95.
+    """
+
+    label: str
+    score: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        label = self.label
+
+        score = self.score
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "label": label,
+                "score": score,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        label = d.pop("label")
+
+        score = d.pop("score")
+
+        inference_classify_result = cls(
+            label=label,
+            score=score,
+        )
+
+        inference_classify_result.additional_properties = d
+        return inference_classify_result
+
+    @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