openparser-sdk 0.0.1__py3-none-any.whl

openparser/_generated/models/region.py

@@ -0,0 +1,224 @@
+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.region_type import RegionType
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.bounding_box import BoundingBox
+  from ..models.region_polygon_type_0_item import RegionPolygonType0Item
+
+
+
+
+
+T = TypeVar("T", bound="Region")
+
+
+
+@_attrs_define
+class Region:
+    """
+        Attributes:
+            id (str):
+            page_number (int):
+            type_ (RegionType):
+            bbox (BoundingBox): Axis-aligned integer page coordinates with exclusive right and bottom edges.
+            polygon (list[RegionPolygonType0Item] | None | Unset):
+            coordinate_width (int | None | Unset):
+            coordinate_height (int | None | Unset):
+            confidence (float | None | Unset):
+            source_label (None | str | Unset):
+     """
+
+    id: str
+    page_number: int
+    type_: RegionType
+    bbox: BoundingBox
+    polygon: list[RegionPolygonType0Item] | None | Unset = UNSET
+    coordinate_width: int | None | Unset = UNSET
+    coordinate_height: int | None | Unset = UNSET
+    confidence: float | None | Unset = UNSET
+    source_label: None | str | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.bounding_box import BoundingBox
+        from ..models.region_polygon_type_0_item import RegionPolygonType0Item
+        id = self.id
+
+        page_number = self.page_number
+
+        type_ = self.type_.value
+
+        bbox = self.bbox.to_dict()
+
+        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
+
+        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
+
+        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
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "id": id,
+            "page_number": page_number,
+            "type": type_,
+            "bbox": bbox,
+        })
+        if polygon is not UNSET:
+            field_dict["polygon"] = polygon
+        if coordinate_width is not UNSET:
+            field_dict["coordinate_width"] = coordinate_width
+        if coordinate_height is not UNSET:
+            field_dict["coordinate_height"] = coordinate_height
+        if confidence is not UNSET:
+            field_dict["confidence"] = confidence
+        if source_label is not UNSET:
+            field_dict["source_label"] = source_label
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.bounding_box import BoundingBox
+        from ..models.region_polygon_type_0_item import RegionPolygonType0Item
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        page_number = d.pop("page_number")
+
+        type_ = RegionType(d.pop("type"))
+
+
+
+
+        bbox = BoundingBox.from_dict(d.pop("bbox"))
+
+
+
+
+        def _parse_polygon(data: object) -> list[RegionPolygonType0Item] | 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 = RegionPolygonType0Item.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[RegionPolygonType0Item] | None | Unset, data)
+
+        polygon = _parse_polygon(d.pop("polygon", 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))
+
+
+        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))
+
+
+        region = cls(
+            id=id,
+            page_number=page_number,
+            type_=type_,
+            bbox=bbox,
+            polygon=polygon,
+            coordinate_width=coordinate_width,
+            coordinate_height=coordinate_height,
+            confidence=confidence,
+            source_label=source_label,
+        )
+
+        return region

openparser/_generated/models/region_content.py

@@ -0,0 +1,155 @@
+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.content_kind import ContentKind
+from ..types import UNSET, Unset
+from typing import cast
+
+
+
+
+
+
+T = TypeVar("T", bound="RegionContent")
+
+
+
+@_attrs_define
+class RegionContent:
+    """
+        Attributes:
+            region_id (str):
+            kind (ContentKind):
+            text (None | str | Unset):
+            table_html (None | str | Unset):
+            detected_state (bool | None | Unset):
+            confidence (float | None | Unset):
+     """
+
+    region_id: str
+    kind: ContentKind
+    text: None | str | Unset = UNSET
+    table_html: None | str | Unset = UNSET
+    detected_state: bool | None | Unset = UNSET
+    confidence: float | None | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        region_id = self.region_id
+
+        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
+
+        detected_state: bool | None | Unset
+        if isinstance(self.detected_state, Unset):
+            detected_state = UNSET
+        else:
+            detected_state = self.detected_state
+
+        confidence: float | None | Unset
+        if isinstance(self.confidence, Unset):
+            confidence = UNSET
+        else:
+            confidence = self.confidence
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "region_id": region_id,
+            "kind": kind,
+        })
+        if text is not UNSET:
+            field_dict["text"] = text
+        if table_html is not UNSET:
+            field_dict["table_html"] = table_html
+        if detected_state is not UNSET:
+            field_dict["detected_state"] = detected_state
+        if confidence is not UNSET:
+            field_dict["confidence"] = confidence
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        region_id = d.pop("region_id")
+
+        kind = ContentKind(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_detected_state(data: object) -> bool | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(bool | None | Unset, data)
+
+        detected_state = _parse_detected_state(d.pop("detected_state", 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))
+
+
+        region_content = cls(
+            region_id=region_id,
+            kind=kind,
+            text=text,
+            table_html=table_html,
+            detected_state=detected_state,
+            confidence=confidence,
+        )
+
+        return region_content

openparser/_generated/models/region_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="RegionPolygonType0Item")
+
+
+
+@_attrs_define
+class RegionPolygonType0Item:
+    """
+        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")
+
+        region_polygon_type_0_item = cls(
+            x=x,
+            y=y,
+        )
+
+        return region_polygon_type_0_item

openparser/_generated/models/region_type.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class RegionType(str, Enum):
+    BARCODE = "barcode"
+    CHECKBOX = "checkbox"
+    FIGURE = "figure"
+    FORMULA = "formula"
+    HEADER_FOOTER = "header_footer"
+    HEADING = "heading"
+    KEY_VALUE = "key_value"
+    SIGNATURE = "signature"
+    TABLE = "table"
+    TEXT = "text"
+
+    def __str__(self) -> str:
+        return str(self.value)

openparser/_generated/models/suggest_schema_request.py

@@ -0,0 +1,69 @@
+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 ..types import UNSET, Unset
+
+
+
+
+
+
+T = TypeVar("T", bound="SuggestSchemaRequest")
+
+
+
+@_attrs_define
+class SuggestSchemaRequest:
+    """ Suggest an extraction JSON Schema from a tenant-owned succeeded `parse` job.
+    Optional `hint` is caller guidance capped at 500 characters.
+
+        Attributes:
+            parse_job_id (str): Prefixed id (`opj_…`) of a succeeded `parse` job in the same tenant.
+            hint (str | Unset): Optional free-text guidance for the suggestion model (max 500 characters).
+     """
+
+    parse_job_id: str
+    hint: str | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        parse_job_id = self.parse_job_id
+
+        hint = self.hint
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "parse_job_id": parse_job_id,
+        })
+        if hint is not UNSET:
+            field_dict["hint"] = hint
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        parse_job_id = d.pop("parse_job_id")
+
+        hint = d.pop("hint", UNSET)
+
+        suggest_schema_request = cls(
+            parse_job_id=parse_job_id,
+            hint=hint,
+        )
+
+        return suggest_schema_request

openparser/_generated/models/suggest_schema_response.py

@@ -0,0 +1,74 @@
+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 typing import cast
+
+if TYPE_CHECKING:
+  from ..models.suggest_schema_response_schema import SuggestSchemaResponseSchema
+
+
+
+
+
+T = TypeVar("T", bound="SuggestSchemaResponse")
+
+
+
+@_attrs_define
+class SuggestSchemaResponse:
+    """ Suggested extraction schema returned directly without creating a durable job.
+
+        Attributes:
+            name (str): Short document-type label proposed by the model.
+            schema (SuggestSchemaResponseSchema): Canonical JSON Schema object ready for extract and manual editing.
+     """
+
+    name: str
+    schema: SuggestSchemaResponseSchema
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.suggest_schema_response_schema import SuggestSchemaResponseSchema
+        name = self.name
+
+        schema = self.schema.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "name": name,
+            "schema": schema,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.suggest_schema_response_schema import SuggestSchemaResponseSchema
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        schema = SuggestSchemaResponseSchema.from_dict(d.pop("schema"))
+
+
+
+
+        suggest_schema_response = cls(
+            name=name,
+            schema=schema,
+        )
+
+        return suggest_schema_response

openparser/_generated/models/suggest_schema_response_schema.py

@@ -0,0 +1,66 @@
+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="SuggestSchemaResponseSchema")
+
+
+
+@_attrs_define
+class SuggestSchemaResponseSchema:
+    """ Canonical JSON Schema object ready for extract and manual editing.
+
+     """
+
+    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)
+        suggest_schema_response_schema = cls(
+        )
+
+
+        suggest_schema_response_schema.additional_properties = d
+        return suggest_schema_response_schema
+
+    @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