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

antfly/client_generated/models/inference_rerank_multimodal_request.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_rerank_multimodal_document import InferenceRerankMultimodalDocument
+
+
+T = TypeVar("T", bound="InferenceRerankMultimodalRequest")
+
+
+@_attrs_define
+class InferenceRerankMultimodalRequest:
+    """
+    Attributes:
+        model (str): Name of multimodal reranking model from models_dir/rerankers/ Example: vidore/colqwen2-v1.0.
+        query (str): Text query for relevance scoring Example: invoice total due date.
+        documents (list[InferenceRerankMultimodalDocument]): Documents expressed as text and image content parts
+    """
+
+    model: str
+    query: str
+    documents: list[InferenceRerankMultimodalDocument]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        query = self.query
+
+        documents = []
+        for documents_item_data in self.documents:
+            documents_item = documents_item_data.to_dict()
+            documents.append(documents_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+                "query": query,
+                "documents": documents,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_rerank_multimodal_document import InferenceRerankMultimodalDocument
+
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        query = d.pop("query")
+
+        documents = []
+        _documents = d.pop("documents")
+        for documents_item_data in _documents:
+            documents_item = InferenceRerankMultimodalDocument.from_dict(documents_item_data)
+
+            documents.append(documents_item)
+
+        inference_rerank_multimodal_request = cls(
+            model=model,
+            query=query,
+            documents=documents,
+        )
+
+        inference_rerank_multimodal_request.additional_properties = d
+        return inference_rerank_multimodal_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_rerank_object.py

@@ -0,0 +1,79 @@
+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_rerank_object_object import InferenceRerankObjectObject
+
+T = TypeVar("T", bound="InferenceRerankObject")
+
+
+@_attrs_define
+class InferenceRerankObject:
+    """
+    Attributes:
+        object_ (InferenceRerankObjectObject):
+        index (int): Original prompt index.
+        score (float): Relevance score for this prompt.
+    """
+
+    object_: InferenceRerankObjectObject
+    index: int
+    score: float
+    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
+
+        score = self.score
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "object": object_,
+                "index": index,
+                "score": score,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        object_ = InferenceRerankObjectObject(d.pop("object"))
+
+        index = d.pop("index")
+
+        score = d.pop("score")
+
+        inference_rerank_object = cls(
+            object_=object_,
+            index=index,
+            score=score,
+        )
+
+        inference_rerank_object.additional_properties = d
+        return inference_rerank_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_rerank_object_object.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class InferenceRerankObjectObject(str, Enum):
+    RERANK_SCORE = "rerank.score"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/inference_rerank_request.py

@@ -0,0 +1,79 @@
+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="InferenceRerankRequest")
+
+
+@_attrs_define
+class InferenceRerankRequest:
+    """
+    Attributes:
+        model (str): Name of reranking model from models_dir/rerankers/ Example: BAAI/bge-reranker-v2-m3.
+        query (str): Search query for relevance scoring Example: machine learning applications.
+        prompts (list[str]): Pre-rendered document texts to rerank. The client is responsible for extracting
+            and rendering document fields/templates before calling this endpoint.
+             Example: ['Introduction to machine learning...', 'Deep learning fundamentals...'].
+    """
+
+    model: str
+    query: str
+    prompts: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        query = self.query
+
+        prompts = self.prompts
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+                "query": query,
+                "prompts": prompts,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        query = d.pop("query")
+
+        prompts = cast(list[str], d.pop("prompts"))
+
+        inference_rerank_request = cls(
+            model=model,
+            query=query,
+            prompts=prompts,
+        )
+
+        inference_rerank_request.additional_properties = d
+        return inference_rerank_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_rerank_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_rerank_response_object import InferenceRerankResponseObject
+
+if TYPE_CHECKING:
+    from ..models.inference_generate_usage import InferenceGenerateUsage
+    from ..models.inference_rerank_object import InferenceRerankObject
+
+
+T = TypeVar("T", bound="InferenceRerankResponse")
+
+
+@_attrs_define
+class InferenceRerankResponse:
+    """
+    Attributes:
+        object_ (InferenceRerankResponseObject): Object type, always "list"
+        data (list[InferenceRerankObject]): Rerank score objects, one per input prompt.
+        model (str): Name of model used for reranking
+        usage (InferenceGenerateUsage):
+    """
+
+    object_: InferenceRerankResponseObject
+    data: list[InferenceRerankObject]
+    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_rerank_object import InferenceRerankObject
+
+        d = dict(src_dict)
+        object_ = InferenceRerankResponseObject(d.pop("object"))
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = InferenceRerankObject.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        model = d.pop("model")
+
+        usage = InferenceGenerateUsage.from_dict(d.pop("usage"))
+
+        inference_rerank_response = cls(
+            object_=object_,
+            data=data,
+            model=model,
+            usage=usage,
+        )
+
+        inference_rerank_response.additional_properties = d
+        return inference_rerank_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_rerank_response_object.py

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

antfly/client_generated/models/inference_resolver_config.py

@@ -0,0 +1,110 @@
+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="InferenceResolverConfig")
+
+
+@_attrs_define
+class InferenceResolverConfig:
+    """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).
+
+        Attributes:
+            similarity_threshold (float | Unset): Jaro-Winkler similarity threshold for merging entities (0.0-1.0) Default:
+                0.85.
+            type_must_match (bool | Unset): Whether entity types must match for merging Default: True.
+            min_entity_confidence (float | Unset): Minimum confidence score for entities to be included Default: 0.0.
+            min_relation_confidence (float | Unset): Minimum confidence score for relations to be included Default: 0.0.
+            deduplicate_relations (bool | Unset): Whether to deduplicate relations after entity resolution Default: True.
+            track_provenance (bool | Unset): Whether to track mention provenance for resolved entities Default: True.
+    """
+
+    similarity_threshold: float | Unset = 0.85
+    type_must_match: bool | Unset = True
+    min_entity_confidence: float | Unset = 0.0
+    min_relation_confidence: float | Unset = 0.0
+    deduplicate_relations: bool | Unset = True
+    track_provenance: bool | Unset = True
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        similarity_threshold = self.similarity_threshold
+
+        type_must_match = self.type_must_match
+
+        min_entity_confidence = self.min_entity_confidence
+
+        min_relation_confidence = self.min_relation_confidence
+
+        deduplicate_relations = self.deduplicate_relations
+
+        track_provenance = self.track_provenance
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if similarity_threshold is not UNSET:
+            field_dict["similarity_threshold"] = similarity_threshold
+        if type_must_match is not UNSET:
+            field_dict["type_must_match"] = type_must_match
+        if min_entity_confidence is not UNSET:
+            field_dict["min_entity_confidence"] = min_entity_confidence
+        if min_relation_confidence is not UNSET:
+            field_dict["min_relation_confidence"] = min_relation_confidence
+        if deduplicate_relations is not UNSET:
+            field_dict["deduplicate_relations"] = deduplicate_relations
+        if track_provenance is not UNSET:
+            field_dict["track_provenance"] = track_provenance
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        similarity_threshold = d.pop("similarity_threshold", UNSET)
+
+        type_must_match = d.pop("type_must_match", UNSET)
+
+        min_entity_confidence = d.pop("min_entity_confidence", UNSET)
+
+        min_relation_confidence = d.pop("min_relation_confidence", UNSET)
+
+        deduplicate_relations = d.pop("deduplicate_relations", UNSET)
+
+        track_provenance = d.pop("track_provenance", UNSET)
+
+        inference_resolver_config = cls(
+            similarity_threshold=similarity_threshold,
+            type_must_match=type_must_match,
+            min_entity_confidence=min_entity_confidence,
+            min_relation_confidence=min_relation_confidence,
+            deduplicate_relations=deduplicate_relations,
+            track_provenance=track_provenance,
+        )
+
+        inference_resolver_config.additional_properties = d
+        return inference_resolver_config
+
+    @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_object.py

@@ -0,0 +1,79 @@
+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 ..models.inference_rewrite_object_object import InferenceRewriteObjectObject
+
+T = TypeVar("T", bound="InferenceRewriteObject")
+
+
+@_attrs_define
+class InferenceRewriteObject:
+    """
+    Attributes:
+        object_ (InferenceRewriteObjectObject):
+        index (int): Original input text index.
+        texts (list[str]): Rewritten texts for this input, one per beam.
+    """
+
+    object_: InferenceRewriteObjectObject
+    index: int
+    texts: list[str]
+    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
+
+        texts = self.texts
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "object": object_,
+                "index": index,
+                "texts": texts,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        object_ = InferenceRewriteObjectObject(d.pop("object"))
+
+        index = d.pop("index")
+
+        texts = cast(list[str], d.pop("texts"))
+
+        inference_rewrite_object = cls(
+            object_=object_,
+            index=index,
+            texts=texts,
+        )
+
+        inference_rewrite_object.additional_properties = d
+        return inference_rewrite_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_rewrite_object_object.py

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

antfly/client_generated/models/inference_rewrite_request.py

@@ -0,0 +1,69 @@
+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="InferenceRewriteRequest")
+
+
+@_attrs_define
+class InferenceRewriteRequest:
+    """
+    Attributes:
+        model (str): Name of Seq2Seq rewriter model from models_dir/rewriters/ Example: lmqg/flan-t5-small-squad-qg.
+        inputs (list[str]): Input texts to rewrite/transform Example: ['Translate to German: Hello, how are you?'].
+    """
+
+    model: str
+    inputs: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        inputs = self.inputs
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+                "inputs": inputs,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        inputs = cast(list[str], d.pop("inputs"))
+
+        inference_rewrite_request = cls(
+            model=model,
+            inputs=inputs,
+        )
+
+        inference_rewrite_request.additional_properties = d
+        return inference_rewrite_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