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

antfly/client_generated/models/extraction_input.py

@@ -0,0 +1,201 @@
+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.extraction_input_metadata import ExtractionInputMetadata
+    from ..models.extraction_token import ExtractionToken
+    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="ExtractionInput")
+
+
+@_attrs_define
+class ExtractionInput:
+    """
+    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):
+        tokens (list[ExtractionToken] | Unset):
+        metadata (ExtractionInputMetadata | Unset):
+    """
+
+    content: list[ImageURLContentPart | MediaContentPart | TextContentPart] | str
+    id: str | Unset = UNSET
+    tokens: list[ExtractionToken] | Unset = UNSET
+    metadata: ExtractionInputMetadata | 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
+
+        tokens: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.tokens, Unset):
+            tokens = []
+            for tokens_item_data in self.tokens:
+                tokens_item = tokens_item_data.to_dict()
+                tokens.append(tokens_item)
+
+        metadata: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.metadata, Unset):
+            metadata = self.metadata.to_dict()
+
+        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
+        if tokens is not UNSET:
+            field_dict["tokens"] = tokens
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.extraction_input_metadata import ExtractionInputMetadata
+        from ..models.extraction_token import ExtractionToken
+        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)
+
+        _tokens = d.pop("tokens", UNSET)
+        tokens: list[ExtractionToken] | Unset = UNSET
+        if _tokens is not UNSET:
+            tokens = []
+            for tokens_item_data in _tokens:
+                tokens_item = ExtractionToken.from_dict(tokens_item_data)
+
+                tokens.append(tokens_item)
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: ExtractionInputMetadata | Unset
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = ExtractionInputMetadata.from_dict(_metadata)
+
+        extraction_input = cls(
+            content=content,
+            id=id,
+            tokens=tokens,
+            metadata=metadata,
+        )
+
+        extraction_input.additional_properties = d
+        return extraction_input
+
+    @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/extraction_input_metadata.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="ExtractionInputMetadata")
+
+
+@_attrs_define
+class ExtractionInputMetadata:
+    """ """
+
+    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)
+        extraction_input_metadata = cls()
+
+        extraction_input_metadata.additional_properties = d
+        return extraction_input_metadata
+
+    @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/extraction_object.py

@@ -0,0 +1,152 @@
+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.extraction_classification import ExtractionClassification
+    from ..models.extraction_entity import ExtractionEntity
+    from ..models.extraction_object_structures import ExtractionObjectStructures
+    from ..models.extraction_relation import ExtractionRelation
+
+
+T = TypeVar("T", bound="ExtractionObject")
+
+
+@_attrs_define
+class ExtractionObject:
+    """
+    Attributes:
+        id (str | Unset):
+        entities (list[ExtractionEntity] | Unset):
+        relations (list[ExtractionRelation] | Unset):
+        classifications (list[ExtractionClassification] | Unset):
+        structures (ExtractionObjectStructures | Unset):
+    """
+
+    id: str | Unset = UNSET
+    entities: list[ExtractionEntity] | Unset = UNSET
+    relations: list[ExtractionRelation] | Unset = UNSET
+    classifications: list[ExtractionClassification] | Unset = UNSET
+    structures: ExtractionObjectStructures | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        entities: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.entities, Unset):
+            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)
+
+        classifications: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.classifications, Unset):
+            classifications = []
+            for classifications_item_data in self.classifications:
+                classifications_item = classifications_item_data.to_dict()
+                classifications.append(classifications_item)
+
+        structures: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.structures, Unset):
+            structures = self.structures.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if id is not UNSET:
+            field_dict["id"] = id
+        if entities is not UNSET:
+            field_dict["entities"] = entities
+        if relations is not UNSET:
+            field_dict["relations"] = relations
+        if classifications is not UNSET:
+            field_dict["classifications"] = classifications
+        if structures is not UNSET:
+            field_dict["structures"] = structures
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.extraction_classification import ExtractionClassification
+        from ..models.extraction_entity import ExtractionEntity
+        from ..models.extraction_object_structures import ExtractionObjectStructures
+        from ..models.extraction_relation import ExtractionRelation
+
+        d = dict(src_dict)
+        id = d.pop("id", UNSET)
+
+        _entities = d.pop("entities", UNSET)
+        entities: list[ExtractionEntity] | Unset = UNSET
+        if _entities is not UNSET:
+            entities = []
+            for entities_item_data in _entities:
+                entities_item = ExtractionEntity.from_dict(entities_item_data)
+
+                entities.append(entities_item)
+
+        _relations = d.pop("relations", UNSET)
+        relations: list[ExtractionRelation] | Unset = UNSET
+        if _relations is not UNSET:
+            relations = []
+            for relations_item_data in _relations:
+                relations_item = ExtractionRelation.from_dict(relations_item_data)
+
+                relations.append(relations_item)
+
+        _classifications = d.pop("classifications", UNSET)
+        classifications: list[ExtractionClassification] | Unset = UNSET
+        if _classifications is not UNSET:
+            classifications = []
+            for classifications_item_data in _classifications:
+                classifications_item = ExtractionClassification.from_dict(classifications_item_data)
+
+                classifications.append(classifications_item)
+
+        _structures = d.pop("structures", UNSET)
+        structures: ExtractionObjectStructures | Unset
+        if isinstance(_structures, Unset):
+            structures = UNSET
+        else:
+            structures = ExtractionObjectStructures.from_dict(_structures)
+
+        extraction_object = cls(
+            id=id,
+            entities=entities,
+            relations=relations,
+            classifications=classifications,
+            structures=structures,
+        )
+
+        extraction_object.additional_properties = d
+        return extraction_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/extraction_object_structures.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="ExtractionObjectStructures")
+
+
+@_attrs_define
+class ExtractionObjectStructures:
+    """ """
+
+    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)
+        extraction_object_structures = cls()
+
+        extraction_object_structures.additional_properties = d
+        return extraction_object_structures
+
+    @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/extraction_options.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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.extraction_reader_options import ExtractionReaderOptions
+
+
+T = TypeVar("T", bound="ExtractionOptions")
+
+
+@_attrs_define
+class ExtractionOptions:
+    """
+    Attributes:
+        threshold (float | Unset):
+        flat_ner (bool | Unset):
+        include_confidence (bool | Unset):
+        include_spans (bool | Unset):
+        reader (ExtractionReaderOptions | Unset):
+    """
+
+    threshold: float | Unset = UNSET
+    flat_ner: bool | Unset = UNSET
+    include_confidence: bool | Unset = UNSET
+    include_spans: bool | Unset = UNSET
+    reader: ExtractionReaderOptions | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        threshold = self.threshold
+
+        flat_ner = self.flat_ner
+
+        include_confidence = self.include_confidence
+
+        include_spans = self.include_spans
+
+        reader: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.reader, Unset):
+            reader = self.reader.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if threshold is not UNSET:
+            field_dict["threshold"] = threshold
+        if flat_ner is not UNSET:
+            field_dict["flat_ner"] = flat_ner
+        if include_confidence is not UNSET:
+            field_dict["include_confidence"] = include_confidence
+        if include_spans is not UNSET:
+            field_dict["include_spans"] = include_spans
+        if reader is not UNSET:
+            field_dict["reader"] = reader
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.extraction_reader_options import ExtractionReaderOptions
+
+        d = dict(src_dict)
+        threshold = d.pop("threshold", UNSET)
+
+        flat_ner = d.pop("flat_ner", UNSET)
+
+        include_confidence = d.pop("include_confidence", UNSET)
+
+        include_spans = d.pop("include_spans", UNSET)
+
+        _reader = d.pop("reader", UNSET)
+        reader: ExtractionReaderOptions | Unset
+        if isinstance(_reader, Unset):
+            reader = UNSET
+        else:
+            reader = ExtractionReaderOptions.from_dict(_reader)
+
+        extraction_options = cls(
+            threshold=threshold,
+            flat_ner=flat_ner,
+            include_confidence=include_confidence,
+            include_spans=include_spans,
+            reader=reader,
+        )
+
+        extraction_options.additional_properties = d
+        return extraction_options
+
+    @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/extraction_reader_options.py

@@ -0,0 +1,88 @@
+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="ExtractionReaderOptions")
+
+
+@_attrs_define
+class ExtractionReaderOptions:
+    """
+    Attributes:
+        provider (str | Unset):
+        model (str | Unset):
+        url (str | Unset):
+        api_url (str | Unset):
+    """
+
+    provider: str | Unset = UNSET
+    model: str | Unset = UNSET
+    url: str | Unset = UNSET
+    api_url: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        provider = self.provider
+
+        model = self.model
+
+        url = self.url
+
+        api_url = self.api_url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if provider is not UNSET:
+            field_dict["provider"] = provider
+        if model is not UNSET:
+            field_dict["model"] = model
+        if url is not UNSET:
+            field_dict["url"] = url
+        if api_url is not UNSET:
+            field_dict["api_url"] = api_url
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        provider = d.pop("provider", UNSET)
+
+        model = d.pop("model", UNSET)
+
+        url = d.pop("url", UNSET)
+
+        api_url = d.pop("api_url", UNSET)
+
+        extraction_reader_options = cls(
+            provider=provider,
+            model=model,
+            url=url,
+            api_url=api_url,
+        )
+
+        extraction_reader_options.additional_properties = d
+        return extraction_reader_options
+
+    @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