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

antfly/client_generated/models/inference_recognize_object.py

@@ -0,0 +1,118 @@
+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_recognize_object_object import InferenceRecognizeObjectObject
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.inference_recognize_entity import InferenceRecognizeEntity
+    from ..models.inference_relation import InferenceRelation
+
+
+T = TypeVar("T", bound="InferenceRecognizeObject")
+
+
+@_attrs_define
+class InferenceRecognizeObject:
+    """
+    Attributes:
+        object_ (InferenceRecognizeObjectObject):
+        index (int): Original input text index.
+        entities (list[InferenceRecognizeEntity]): Entities recognized for this input text.
+        relations (list[InferenceRelation] | Unset): Relations recognized for this input text. Only present when using
+            a model with 'relations' capability (GLiNER multitask, REBEL).
+    """
+
+    object_: InferenceRecognizeObjectObject
+    index: int
+    entities: list[InferenceRecognizeEntity]
+    relations: list[InferenceRelation] | Unset = UNSET
+    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
+
+        entities = []
+        for entities_item_data in self.entities:
+            entities_item = entities_item_data.to_dict()
+            entities.append(entities_item)
+
+        relations: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.relations, Unset):
+            relations = []
+            for relations_item_data in self.relations:
+                relations_item = relations_item_data.to_dict()
+                relations.append(relations_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "object": object_,
+                "index": index,
+                "entities": entities,
+            }
+        )
+        if relations is not UNSET:
+            field_dict["relations"] = relations
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_recognize_entity import InferenceRecognizeEntity
+        from ..models.inference_relation import InferenceRelation
+
+        d = dict(src_dict)
+        object_ = InferenceRecognizeObjectObject(d.pop("object"))
+
+        index = d.pop("index")
+
+        entities = []
+        _entities = d.pop("entities")
+        for entities_item_data in _entities:
+            entities_item = InferenceRecognizeEntity.from_dict(entities_item_data)
+
+            entities.append(entities_item)
+
+        _relations = d.pop("relations", UNSET)
+        relations: list[InferenceRelation] | Unset = UNSET
+        if _relations is not UNSET:
+            relations = []
+            for relations_item_data in _relations:
+                relations_item = InferenceRelation.from_dict(relations_item_data)
+
+                relations.append(relations_item)
+
+        inference_recognize_object = cls(
+            object_=object_,
+            index=index,
+            entities=entities,
+            relations=relations,
+        )
+
+        inference_recognize_object.additional_properties = d
+        return inference_recognize_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_recognize_object_object.py

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

antfly/client_generated/models/inference_recognize_request.py

@@ -0,0 +1,129 @@
+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.inference_resolver_config import InferenceResolverConfig
+
+
+T = TypeVar("T", bound="InferenceRecognizeRequest")
+
+
+@_attrs_define
+class InferenceRecognizeRequest:
+    """
+    Attributes:
+        model (str): Name of recognizer model from models_dir/recognizers/ Example: dslim/bert-base-NER.
+        texts (list[str]): Texts to extract entities from Example: ['John Smith works at Google.', 'Apple Inc. is in
+            Cupertino.'].
+        labels (list[str] | Unset): Custom entity labels to extract (GLiNER models only).
+            When using a GLiNER model, you can specify any entity types to extract,
+            enabling zero-shot NER without model retraining.
+            If not provided, the model's default labels are used.
+             Example: ['person', 'company', 'product', 'date'].
+        relation_labels (list[str] | Unset): Relation types to extract (for models with 'relations' capability).
+            Only used when the model supports relation extraction (GLiNER multitask, REBEL).
+            Relation extraction runs only when this array is provided and non-empty.
+            GLiNER labels may be relation names (works_for), head-qualified
+            labels (person::works_for), or head/tail-qualified labels
+            (person::works_for::organization).
+             Example: ['founded', 'works_at', 'located_in'].
+        resolver (InferenceResolverConfig | Unset): Configuration for entity resolution. When present in a
+            RecognizeRequest,
+            the response entities and relations are deduplicated via entity resolution
+            (e.g., "Elon Musk" and "Musk" are merged into a single entity).
+    """
+
+    model: str
+    texts: list[str]
+    labels: list[str] | Unset = UNSET
+    relation_labels: list[str] | Unset = UNSET
+    resolver: InferenceResolverConfig | Unset = UNSET
+    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: list[str] | Unset = UNSET
+        if not isinstance(self.labels, Unset):
+            labels = self.labels
+
+        relation_labels: list[str] | Unset = UNSET
+        if not isinstance(self.relation_labels, Unset):
+            relation_labels = self.relation_labels
+
+        resolver: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.resolver, Unset):
+            resolver = self.resolver.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+                "texts": texts,
+            }
+        )
+        if labels is not UNSET:
+            field_dict["labels"] = labels
+        if relation_labels is not UNSET:
+            field_dict["relation_labels"] = relation_labels
+        if resolver is not UNSET:
+            field_dict["resolver"] = resolver
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_resolver_config import InferenceResolverConfig
+
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        texts = cast(list[str], d.pop("texts"))
+
+        labels = cast(list[str], d.pop("labels", UNSET))
+
+        relation_labels = cast(list[str], d.pop("relation_labels", UNSET))
+
+        _resolver = d.pop("resolver", UNSET)
+        resolver: InferenceResolverConfig | Unset
+        if isinstance(_resolver, Unset):
+            resolver = UNSET
+        else:
+            resolver = InferenceResolverConfig.from_dict(_resolver)
+
+        inference_recognize_request = cls(
+            model=model,
+            texts=texts,
+            labels=labels,
+            relation_labels=relation_labels,
+            resolver=resolver,
+        )
+
+        inference_recognize_request.additional_properties = d
+        return inference_recognize_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_recognize_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_recognize_response_object import InferenceRecognizeResponseObject
+
+if TYPE_CHECKING:
+    from ..models.inference_generate_usage import InferenceGenerateUsage
+    from ..models.inference_recognize_object import InferenceRecognizeObject
+
+
+T = TypeVar("T", bound="InferenceRecognizeResponse")
+
+
+@_attrs_define
+class InferenceRecognizeResponse:
+    """
+    Attributes:
+        object_ (InferenceRecognizeResponseObject): Object type, always "list"
+        data (list[InferenceRecognizeObject]): Recognition result objects, one per input text.
+        model (str): Name of model used for NER
+        usage (InferenceGenerateUsage):
+    """
+
+    object_: InferenceRecognizeResponseObject
+    data: list[InferenceRecognizeObject]
+    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_recognize_object import InferenceRecognizeObject
+
+        d = dict(src_dict)
+        object_ = InferenceRecognizeResponseObject(d.pop("object"))
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = InferenceRecognizeObject.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        model = d.pop("model")
+
+        usage = InferenceGenerateUsage.from_dict(d.pop("usage"))
+
+        inference_recognize_response = cls(
+            object_=object_,
+            data=data,
+            model=model,
+            usage=usage,
+        )
+
+        inference_recognize_response.additional_properties = d
+        return inference_recognize_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_recognize_response_object.py

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

antfly/client_generated/models/inference_relation.py

@@ -0,0 +1,91 @@
+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_recognize_entity import InferenceRecognizeEntity
+
+
+T = TypeVar("T", bound="InferenceRelation")
+
+
+@_attrs_define
+class InferenceRelation:
+    """
+    Attributes:
+        head (InferenceRecognizeEntity):
+        tail (InferenceRecognizeEntity):
+        label (str): The relationship type Example: founded.
+        score (float): Confidence score for the relation (0.0 to 1.0) Example: 0.95.
+    """
+
+    head: InferenceRecognizeEntity
+    tail: InferenceRecognizeEntity
+    label: str
+    score: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        head = self.head.to_dict()
+
+        tail = self.tail.to_dict()
+
+        label = self.label
+
+        score = self.score
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "head": head,
+                "tail": tail,
+                "label": label,
+                "score": score,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_recognize_entity import InferenceRecognizeEntity
+
+        d = dict(src_dict)
+        head = InferenceRecognizeEntity.from_dict(d.pop("head"))
+
+        tail = InferenceRecognizeEntity.from_dict(d.pop("tail"))
+
+        label = d.pop("label")
+
+        score = d.pop("score")
+
+        inference_relation = cls(
+            head=head,
+            tail=tail,
+            label=label,
+            score=score,
+        )
+
+        inference_relation.additional_properties = d
+        return inference_relation
+
+    @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_rerank_multimodal_document.py

@@ -0,0 +1,160 @@
+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.media_content_part import MediaContentPart
+    from ..models.text_content_part import TextContentPart
+
+
+T = TypeVar("T", bound="InferenceRerankMultimodalDocument")
+
+
+@_attrs_define
+class InferenceRerankMultimodalDocument:
+    """
+    Attributes:
+        content (list[ImageURLContentPart | MediaContentPart | TextContentPart] | str): Message content. Supports two
+            formats:
+            - Simple string: "Hello, how are you?"
+            - Array of content parts: [{"type": "text", "text": "Hello"}]
+        id (str | Unset): Optional caller-provided document identifier
+    """
+
+    content: list[ImageURLContentPart | MediaContentPart | TextContentPart] | str
+    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
+
+        content: list[dict[str, Any]] | str
+        if 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
+
+        id = self.id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "content": content,
+            }
+        )
+        if id is not UNSET:
+            field_dict["id"] = 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
+
+        d = dict(src_dict)
+
+        def _parse_content(data: object) -> list[ImageURLContentPart | MediaContentPart | TextContentPart] | str:
+            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, data)
+
+        content = _parse_content(d.pop("content"))
+
+        id = d.pop("id", UNSET)
+
+        inference_rerank_multimodal_document = cls(
+            content=content,
+            id=id,
+        )
+
+        inference_rerank_multimodal_document.additional_properties = d
+        return inference_rerank_multimodal_document
+
+    @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