openparser-sdk 0.0.1__py3-none-any.whl

openparser/_generated/models/page_block.py

@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.page_block_kind import PageBlockKind
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.bounding_box import BoundingBox
+  from ..models.page_block_polygon_type_0_item import PageBlockPolygonType0Item
+
+
+
+
+
+T = TypeVar("T", bound="PageBlock")
+
+
+
+@_attrs_define
+class PageBlock:
+    """ Primary stable parse interface: one ordered page block in reading order. Optional core
+    fields are serialized as JSON `null` when absent.
+
+        Attributes:
+            index (int): Zero-based reading-order index, contiguous from 0.
+            page_number (int):
+            kind (PageBlockKind):
+            text (None | str | Unset):
+            table_html (None | str | Unset):
+            figure_uri (None | str | Unset):
+            bbox (BoundingBox | None | Unset):
+            polygon (list[PageBlockPolygonType0Item] | None | Unset):
+            confidence (float | None | Unset):
+            source_label (None | str | Unset):
+            region_id (None | str | Unset):
+            coordinate_width (int | None | Unset):
+            coordinate_height (int | None | Unset):
+     """
+
+    index: int
+    page_number: int
+    kind: PageBlockKind
+    text: None | str | Unset = UNSET
+    table_html: None | str | Unset = UNSET
+    figure_uri: None | str | Unset = UNSET
+    bbox: BoundingBox | None | Unset = UNSET
+    polygon: list[PageBlockPolygonType0Item] | None | Unset = UNSET
+    confidence: float | None | Unset = UNSET
+    source_label: None | str | Unset = UNSET
+    region_id: None | str | Unset = UNSET
+    coordinate_width: int | None | Unset = UNSET
+    coordinate_height: int | None | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.bounding_box import BoundingBox
+        from ..models.page_block_polygon_type_0_item import PageBlockPolygonType0Item
+        index = self.index
+
+        page_number = self.page_number
+
+        kind = self.kind.value
+
+        text: None | str | Unset
+        if isinstance(self.text, Unset):
+            text = UNSET
+        else:
+            text = self.text
+
+        table_html: None | str | Unset
+        if isinstance(self.table_html, Unset):
+            table_html = UNSET
+        else:
+            table_html = self.table_html
+
+        figure_uri: None | str | Unset
+        if isinstance(self.figure_uri, Unset):
+            figure_uri = UNSET
+        else:
+            figure_uri = self.figure_uri
+
+        bbox: dict[str, Any] | None | Unset
+        if isinstance(self.bbox, Unset):
+            bbox = UNSET
+        elif isinstance(self.bbox, BoundingBox):
+            bbox = self.bbox.to_dict()
+        else:
+            bbox = self.bbox
+
+        polygon: list[dict[str, Any]] | None | Unset
+        if isinstance(self.polygon, Unset):
+            polygon = UNSET
+        elif isinstance(self.polygon, list):
+            polygon = []
+            for polygon_type_0_item_data in self.polygon:
+                polygon_type_0_item = polygon_type_0_item_data.to_dict()
+                polygon.append(polygon_type_0_item)
+
+
+        else:
+            polygon = self.polygon
+
+        confidence: float | None | Unset
+        if isinstance(self.confidence, Unset):
+            confidence = UNSET
+        else:
+            confidence = self.confidence
+
+        source_label: None | str | Unset
+        if isinstance(self.source_label, Unset):
+            source_label = UNSET
+        else:
+            source_label = self.source_label
+
+        region_id: None | str | Unset
+        if isinstance(self.region_id, Unset):
+            region_id = UNSET
+        else:
+            region_id = self.region_id
+
+        coordinate_width: int | None | Unset
+        if isinstance(self.coordinate_width, Unset):
+            coordinate_width = UNSET
+        else:
+            coordinate_width = self.coordinate_width
+
+        coordinate_height: int | None | Unset
+        if isinstance(self.coordinate_height, Unset):
+            coordinate_height = UNSET
+        else:
+            coordinate_height = self.coordinate_height
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "index": index,
+            "page_number": page_number,
+            "kind": kind,
+        })
+        if text is not UNSET:
+            field_dict["text"] = text
+        if table_html is not UNSET:
+            field_dict["table_html"] = table_html
+        if figure_uri is not UNSET:
+            field_dict["figure_uri"] = figure_uri
+        if bbox is not UNSET:
+            field_dict["bbox"] = bbox
+        if polygon is not UNSET:
+            field_dict["polygon"] = polygon
+        if confidence is not UNSET:
+            field_dict["confidence"] = confidence
+        if source_label is not UNSET:
+            field_dict["source_label"] = source_label
+        if region_id is not UNSET:
+            field_dict["region_id"] = region_id
+        if coordinate_width is not UNSET:
+            field_dict["coordinate_width"] = coordinate_width
+        if coordinate_height is not UNSET:
+            field_dict["coordinate_height"] = coordinate_height
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.bounding_box import BoundingBox
+        from ..models.page_block_polygon_type_0_item import PageBlockPolygonType0Item
+        d = dict(src_dict)
+        index = d.pop("index")
+
+        page_number = d.pop("page_number")
+
+        kind = PageBlockKind(d.pop("kind"))
+
+
+
+
+        def _parse_text(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        text = _parse_text(d.pop("text", UNSET))
+
+
+        def _parse_table_html(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        table_html = _parse_table_html(d.pop("table_html", UNSET))
+
+
+        def _parse_figure_uri(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        figure_uri = _parse_figure_uri(d.pop("figure_uri", UNSET))
+
+
+        def _parse_bbox(data: object) -> BoundingBox | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                bbox_type_0 = BoundingBox.from_dict(data)
+
+
+
+                return bbox_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(BoundingBox | None | Unset, data)
+
+        bbox = _parse_bbox(d.pop("bbox", UNSET))
+
+
+        def _parse_polygon(data: object) -> list[PageBlockPolygonType0Item] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                polygon_type_0 = []
+                _polygon_type_0 = data
+                for polygon_type_0_item_data in (_polygon_type_0):
+                    polygon_type_0_item = PageBlockPolygonType0Item.from_dict(polygon_type_0_item_data)
+
+
+
+                    polygon_type_0.append(polygon_type_0_item)
+
+                return polygon_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[PageBlockPolygonType0Item] | None | Unset, data)
+
+        polygon = _parse_polygon(d.pop("polygon", UNSET))
+
+
+        def _parse_confidence(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        confidence = _parse_confidence(d.pop("confidence", UNSET))
+
+
+        def _parse_source_label(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        source_label = _parse_source_label(d.pop("source_label", UNSET))
+
+
+        def _parse_region_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        region_id = _parse_region_id(d.pop("region_id", UNSET))
+
+
+        def _parse_coordinate_width(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        coordinate_width = _parse_coordinate_width(d.pop("coordinate_width", UNSET))
+
+
+        def _parse_coordinate_height(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        coordinate_height = _parse_coordinate_height(d.pop("coordinate_height", UNSET))
+
+
+        page_block = cls(
+            index=index,
+            page_number=page_number,
+            kind=kind,
+            text=text,
+            table_html=table_html,
+            figure_uri=figure_uri,
+            bbox=bbox,
+            polygon=polygon,
+            confidence=confidence,
+            source_label=source_label,
+            region_id=region_id,
+            coordinate_width=coordinate_width,
+            coordinate_height=coordinate_height,
+        )
+
+        return page_block

openparser/_generated/models/page_block_kind.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class PageBlockKind(str, Enum):
+    FIGURE = "figure"
+    TABLE = "table"
+    TEXT = "text"
+
+    def __str__(self) -> str:
+        return str(self.value)

openparser/_generated/models/page_block_polygon_type_0_item.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+
+
+
+
+
+T = TypeVar("T", bound="PageBlockPolygonType0Item")
+
+
+
+@_attrs_define
+class PageBlockPolygonType0Item:
+    """
+        Attributes:
+            x (float):
+            y (float):
+     """
+
+    x: float
+    y: float
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        x = self.x
+
+        y = self.y
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "x": x,
+            "y": y,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        x = d.pop("x")
+
+        y = d.pop("y")
+
+        page_block_polygon_type_0_item = cls(
+            x=x,
+            y=y,
+        )
+
+        return page_block_polygon_type_0_item

openparser/_generated/models/parse_async_body.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+import json
+from .. import types
+
+from ..types import UNSET, Unset
+
+from ..types import File, FileTypes
+from ..types import UNSET, Unset
+from io import BytesIO
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.parse_request import ParseRequest
+
+
+
+
+
+T = TypeVar("T", bound="ParseAsyncBody")
+
+
+
+@_attrs_define
+class ParseAsyncBody:
+    """
+        Attributes:
+            request (ParseRequest):
+            file (File | Unset): Source document bytes (PDF, PNG, or JPEG). Required unless `request.file_id`
+                references an existing Eigenpal reusable file.
+     """
+
+    request: ParseRequest
+    file: File | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.parse_request import ParseRequest
+        request = self.request.to_dict()
+
+        file: FileTypes | Unset = UNSET
+        if not isinstance(self.file, Unset):
+            file = self.file.to_tuple()
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "request": request,
+        })
+        if file is not UNSET:
+            field_dict["file"] = file
+
+        return field_dict
+
+
+    def to_multipart(self) -> types.RequestFiles:
+        from ..models.parse_request import ParseRequest
+        files: types.RequestFiles = []
+
+        files.append(("request", (None, json.dumps( self.request.to_dict()).encode(), "application/json")))
+
+
+
+        if not isinstance(self.file, Unset):
+            files.append(("file", self.file.to_tuple()))
+
+
+
+
+        for prop_name, prop in self.additional_properties.items():
+            files.append((prop_name, (None, str(prop).encode(), "text/plain")))
+
+
+
+        return files
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.parse_request import ParseRequest
+        d = dict(src_dict)
+        request = ParseRequest.from_dict(d.pop("request"))
+
+
+
+
+        _file = d.pop("file", UNSET)
+        file: File | Unset
+        if isinstance(_file,  Unset):
+            file = UNSET
+        else:
+            file = File(
+             payload = BytesIO(_file)
+        )
+
+
+
+
+        parse_async_body = cls(
+            request=request,
+            file=file,
+        )
+
+
+        parse_async_body.additional_properties = d
+        return parse_async_body
+
+    @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

openparser/_generated/models/parse_batch_body.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+import json
+from .. import types
+
+from ..types import UNSET, Unset
+
+from ..types import File, FileTypes
+from ..types import UNSET, Unset
+from io import BytesIO
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.parse_batch_request import ParseBatchRequest
+
+
+
+
+
+T = TypeVar("T", bound="ParseBatchBody")
+
+
+
+@_attrs_define
+class ParseBatchBody:
+    """
+        Attributes:
+            request (ParseBatchRequest):
+            files (list[File] | Unset): Ordered uploaded files referenced by `file_index` in the batch request. Each file
+                is limited to 50 MiB and total multipart body content is limited to 100 MiB.
+                Omit when every batch item supplies `file_id` instead.
+     """
+
+    request: ParseBatchRequest
+    files: list[File] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.parse_batch_request import ParseBatchRequest
+        request = self.request.to_dict()
+
+        files: list[FileTypes] | Unset = UNSET
+        if not isinstance(self.files, Unset):
+            files = []
+            for files_item_data in self.files:
+                files_item = files_item_data.to_tuple()
+
+                files.append(files_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "request": request,
+        })
+        if files is not UNSET:
+            field_dict["files"] = files
+
+        return field_dict
+
+
+    def to_multipart(self) -> types.RequestFiles:
+        from ..models.parse_batch_request import ParseBatchRequest
+        files: types.RequestFiles = []
+
+        files.append(("request", (None, json.dumps( self.request.to_dict()).encode(), "application/json")))
+
+
+
+        if not isinstance(self.files, Unset):
+            for files_item_element in self.files:
+                files.append(("files", files_item_element.to_tuple()))
+
+
+
+
+
+        for prop_name, prop in self.additional_properties.items():
+            files.append((prop_name, (None, str(prop).encode(), "text/plain")))
+
+
+
+        return files
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.parse_batch_request import ParseBatchRequest
+        d = dict(src_dict)
+        request = ParseBatchRequest.from_dict(d.pop("request"))
+
+
+
+
+        _files = d.pop("files", UNSET)
+        files: list[File] | Unset = UNSET
+        if _files is not UNSET:
+            files = []
+            for files_item_data in _files:
+                files_item = File(
+                     payload = BytesIO(files_item_data)
+                )
+
+
+
+                files.append(files_item)
+
+
+        parse_batch_body = cls(
+            request=request,
+            files=files,
+        )
+
+
+        parse_batch_body.additional_properties = d
+        return parse_batch_body
+
+    @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