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

antfly/client_generated/models/inference_read_object.py

@@ -0,0 +1,130 @@
+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_read_object_object import InferenceReadObjectObject
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.inference_read_result_fields import InferenceReadResultFields
+    from ..models.inference_text_region import InferenceTextRegion
+
+
+T = TypeVar("T", bound="InferenceReadObject")
+
+
+@_attrs_define
+class InferenceReadObject:
+    """
+    Attributes:
+        text (str): Extracted text from the image Example: Invoice Total: $123.45.
+        object_ (InferenceReadObjectObject):
+        index (int): Original input image index.
+        fields (InferenceReadResultFields | Unset): Structured fields extracted by document understanding models (Donut,
+            Florence-2).
+            Fields are flattened with dot notation for nested structures.
+            Only present for models that output structured data.
+             Example: {'menu.nm': 'Coffee', 'menu.price': '$3.50', 'total': '$123.45'}.
+        regions (list[InferenceTextRegion] | Unset): Individual text regions with bounding boxes and recognized text.
+            Populated by multi-stage OCR models (Surya, PaddleOCR).
+    """
+
+    text: str
+    object_: InferenceReadObjectObject
+    index: int
+    fields: InferenceReadResultFields | Unset = UNSET
+    regions: list[InferenceTextRegion] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        text = self.text
+
+        object_ = self.object_.value
+
+        index = self.index
+
+        fields: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.fields, Unset):
+            fields = self.fields.to_dict()
+
+        regions: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.regions, Unset):
+            regions = []
+            for regions_item_data in self.regions:
+                regions_item = regions_item_data.to_dict()
+                regions.append(regions_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "text": text,
+                "object": object_,
+                "index": index,
+            }
+        )
+        if fields is not UNSET:
+            field_dict["fields"] = fields
+        if regions is not UNSET:
+            field_dict["regions"] = regions
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_read_result_fields import InferenceReadResultFields
+        from ..models.inference_text_region import InferenceTextRegion
+
+        d = dict(src_dict)
+        text = d.pop("text")
+
+        object_ = InferenceReadObjectObject(d.pop("object"))
+
+        index = d.pop("index")
+
+        _fields = d.pop("fields", UNSET)
+        fields: InferenceReadResultFields | Unset
+        if isinstance(_fields, Unset):
+            fields = UNSET
+        else:
+            fields = InferenceReadResultFields.from_dict(_fields)
+
+        _regions = d.pop("regions", UNSET)
+        regions: list[InferenceTextRegion] | Unset = UNSET
+        if _regions is not UNSET:
+            regions = []
+            for regions_item_data in _regions:
+                regions_item = InferenceTextRegion.from_dict(regions_item_data)
+
+                regions.append(regions_item)
+
+        inference_read_object = cls(
+            text=text,
+            object_=object_,
+            index=index,
+            fields=fields,
+            regions=regions,
+        )
+
+        inference_read_object.additional_properties = d
+        return inference_read_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_read_object_object.py

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

antfly/client_generated/models/inference_read_request.py

@@ -0,0 +1,113 @@
+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_image_url import InferenceImageURL
+
+
+T = TypeVar("T", bound="InferenceReadRequest")
+
+
+@_attrs_define
+class InferenceReadRequest:
+    """
+    Attributes:
+        model (str): Name of reader model from models_dir/readers/ Example: microsoft/trocr-base-printed.
+        images (list[InferenceImageURL]): Images to read text from. Supports:
+            - Data URIs: `data:image/png;base64,...`
+            - URLs (if content_security allows)
+             Example: [{'url': 'data:image/png;base64,iVBORw0KGgo...'}].
+        prompt (str | Unset): Optional task prompt for document understanding models.
+            - TrOCR: Not used (pure OCR)
+            - Donut CORD: "<s_cord-v2>" for receipt parsing
+            - Donut DocVQA: "<s_docvqa><s_question>What is the total?</s_question><s_answer>"
+            - Florence-2: "<OCR>" for OCR, "<CAPTION>" for captioning
+            - Pix2Struct: "What type of document is this?"
+            - Moondream: "Describe this image."
+             Example: What type of document is this?.
+        max_tokens (int | Unset): Maximum tokens to generate Default: 256. Example: 256.
+    """
+
+    model: str
+    images: list[InferenceImageURL]
+    prompt: str | Unset = UNSET
+    max_tokens: int | Unset = 256
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model = self.model
+
+        images = []
+        for images_item_data in self.images:
+            images_item = images_item_data.to_dict()
+            images.append(images_item)
+
+        prompt = self.prompt
+
+        max_tokens = self.max_tokens
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "model": model,
+                "images": images,
+            }
+        )
+        if prompt is not UNSET:
+            field_dict["prompt"] = prompt
+        if max_tokens is not UNSET:
+            field_dict["max_tokens"] = max_tokens
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_image_url import InferenceImageURL
+
+        d = dict(src_dict)
+        model = d.pop("model")
+
+        images = []
+        _images = d.pop("images")
+        for images_item_data in _images:
+            images_item = InferenceImageURL.from_dict(images_item_data)
+
+            images.append(images_item)
+
+        prompt = d.pop("prompt", UNSET)
+
+        max_tokens = d.pop("max_tokens", UNSET)
+
+        inference_read_request = cls(
+            model=model,
+            images=images,
+            prompt=prompt,
+            max_tokens=max_tokens,
+        )
+
+        inference_read_request.additional_properties = d
+        return inference_read_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_read_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_read_response_object import InferenceReadResponseObject
+
+if TYPE_CHECKING:
+    from ..models.inference_generate_usage import InferenceGenerateUsage
+    from ..models.inference_read_object import InferenceReadObject
+
+
+T = TypeVar("T", bound="InferenceReadResponse")
+
+
+@_attrs_define
+class InferenceReadResponse:
+    """
+    Attributes:
+        object_ (InferenceReadResponseObject): Object type, always "list"
+        data (list[InferenceReadObject]): Read result objects, one per input image.
+        model (str): Name of model used for reading
+        usage (InferenceGenerateUsage):
+    """
+
+    object_: InferenceReadResponseObject
+    data: list[InferenceReadObject]
+    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_read_object import InferenceReadObject
+
+        d = dict(src_dict)
+        object_ = InferenceReadResponseObject(d.pop("object"))
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = InferenceReadObject.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        model = d.pop("model")
+
+        usage = InferenceGenerateUsage.from_dict(d.pop("usage"))
+
+        inference_read_response = cls(
+            object_=object_,
+            data=data,
+            model=model,
+            usage=usage,
+        )
+
+        inference_read_response.additional_properties = d
+        return inference_read_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_read_response_object.py

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

antfly/client_generated/models/inference_read_result.py

@@ -0,0 +1,113 @@
+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_read_result_fields import InferenceReadResultFields
+    from ..models.inference_text_region import InferenceTextRegion
+
+
+T = TypeVar("T", bound="InferenceReadResult")
+
+
+@_attrs_define
+class InferenceReadResult:
+    """
+    Attributes:
+        text (str): Extracted text from the image Example: Invoice Total: $123.45.
+        fields (InferenceReadResultFields | Unset): Structured fields extracted by document understanding models (Donut,
+            Florence-2).
+            Fields are flattened with dot notation for nested structures.
+            Only present for models that output structured data.
+             Example: {'menu.nm': 'Coffee', 'menu.price': '$3.50', 'total': '$123.45'}.
+        regions (list[InferenceTextRegion] | Unset): Individual text regions with bounding boxes and recognized text.
+            Populated by multi-stage OCR models (Surya, PaddleOCR).
+    """
+
+    text: str
+    fields: InferenceReadResultFields | Unset = UNSET
+    regions: list[InferenceTextRegion] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        text = self.text
+
+        fields: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.fields, Unset):
+            fields = self.fields.to_dict()
+
+        regions: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.regions, Unset):
+            regions = []
+            for regions_item_data in self.regions:
+                regions_item = regions_item_data.to_dict()
+                regions.append(regions_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "text": text,
+            }
+        )
+        if fields is not UNSET:
+            field_dict["fields"] = fields
+        if regions is not UNSET:
+            field_dict["regions"] = regions
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.inference_read_result_fields import InferenceReadResultFields
+        from ..models.inference_text_region import InferenceTextRegion
+
+        d = dict(src_dict)
+        text = d.pop("text")
+
+        _fields = d.pop("fields", UNSET)
+        fields: InferenceReadResultFields | Unset
+        if isinstance(_fields, Unset):
+            fields = UNSET
+        else:
+            fields = InferenceReadResultFields.from_dict(_fields)
+
+        _regions = d.pop("regions", UNSET)
+        regions: list[InferenceTextRegion] | Unset = UNSET
+        if _regions is not UNSET:
+            regions = []
+            for regions_item_data in _regions:
+                regions_item = InferenceTextRegion.from_dict(regions_item_data)
+
+                regions.append(regions_item)
+
+        inference_read_result = cls(
+            text=text,
+            fields=fields,
+            regions=regions,
+        )
+
+        inference_read_result.additional_properties = d
+        return inference_read_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

antfly/client_generated/models/inference_read_result_fields.py

@@ -0,0 +1,54 @@
+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="InferenceReadResultFields")
+
+
+@_attrs_define
+class InferenceReadResultFields:
+    """Structured fields extracted by document understanding models (Donut, Florence-2).
+    Fields are flattened with dot notation for nested structures.
+    Only present for models that output structured data.
+
+        Example:
+            {'menu.nm': 'Coffee', 'menu.price': '$3.50', 'total': '$123.45'}
+
+    """
+
+    additional_properties: dict[str, str] = _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_read_result_fields = cls()
+
+        inference_read_result_fields.additional_properties = d
+        return inference_read_result_fields
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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_entity.py

@@ -0,0 +1,93 @@
+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="InferenceRecognizeEntity")
+
+
+@_attrs_define
+class InferenceRecognizeEntity:
+    """
+    Attributes:
+        text (str): The entity text Example: John Smith.
+        label (str): Entity type (PER, ORG, LOC, MISC) Example: PER.
+        start (int): Character offset where entity begins
+        end (int): Character offset where entity ends (exclusive) Example: 10.
+        score (float): Confidence score (0.0 to 1.0) Example: 0.99.
+    """
+
+    text: str
+    label: str
+    start: int
+    end: int
+    score: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        text = self.text
+
+        label = self.label
+
+        start = self.start
+
+        end = self.end
+
+        score = self.score
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "text": text,
+                "label": label,
+                "start": start,
+                "end": end,
+                "score": score,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        text = d.pop("text")
+
+        label = d.pop("label")
+
+        start = d.pop("start")
+
+        end = d.pop("end")
+
+        score = d.pop("score")
+
+        inference_recognize_entity = cls(
+            text=text,
+            label=label,
+            start=start,
+            end=end,
+            score=score,
+        )
+
+        inference_recognize_entity.additional_properties = d
+        return inference_recognize_entity
+
+    @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