openparser-sdk 0.0.1__py3-none-any.whl

openparser/_generated/models/parse_sync_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="ParseSyncBody")
+
+
+
+@_attrs_define
+class ParseSyncBody:
+    """
+        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_sync_body = cls(
+            request=request,
+            file=file,
+        )
+
+
+        parse_sync_body.additional_properties = d
+        return parse_sync_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/parsed_document.py

@@ -0,0 +1,187 @@
+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
+from typing import Literal, cast
+
+if TYPE_CHECKING:
+  from ..models.extraction_chunk import ExtractionChunk
+  from ..models.page_block import PageBlock
+  from ..models.region import Region
+  from ..models.region_content import RegionContent
+
+
+
+
+
+T = TypeVar("T", bound="ParsedDocument")
+
+
+
+@_attrs_define
+class ParsedDocument:
+    """ Versioned OpenParser `openparser@1` document representation. `blocks` is the primary
+    stable interface; `regions`, `contents`, and `chunks` preserve provider-neutral geometry,
+    confidence, labels, provenance, and extraction views. Compatible optional fields may be
+    added within version 1; breaking representation changes create a new output-format version.
+
+        Attributes:
+            output_format (Literal['openparser@1']):
+            document_id (str):
+            page_count (int): Authoritative successfully parsed page count from the HPS/parse result. Customer
+                page billing uses this value only when a successful terminal result is published.
+            markdown (str): Derived markdown rendered from ordered blocks.
+            blocks (list[PageBlock]):
+            regions (list[Region]):
+            contents (list[RegionContent]):
+            chunks (list[ExtractionChunk]):
+     """
+
+    output_format: Literal['openparser@1']
+    document_id: str
+    page_count: int
+    markdown: str
+    blocks: list[PageBlock]
+    regions: list[Region]
+    contents: list[RegionContent]
+    chunks: list[ExtractionChunk]
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.extraction_chunk import ExtractionChunk
+        from ..models.page_block import PageBlock
+        from ..models.region import Region
+        from ..models.region_content import RegionContent
+        output_format = self.output_format
+
+        document_id = self.document_id
+
+        page_count = self.page_count
+
+        markdown = self.markdown
+
+        blocks = []
+        for blocks_item_data in self.blocks:
+            blocks_item = blocks_item_data.to_dict()
+            blocks.append(blocks_item)
+
+
+
+        regions = []
+        for regions_item_data in self.regions:
+            regions_item = regions_item_data.to_dict()
+            regions.append(regions_item)
+
+
+
+        contents = []
+        for contents_item_data in self.contents:
+            contents_item = contents_item_data.to_dict()
+            contents.append(contents_item)
+
+
+
+        chunks = []
+        for chunks_item_data in self.chunks:
+            chunks_item = chunks_item_data.to_dict()
+            chunks.append(chunks_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "output_format": output_format,
+            "document_id": document_id,
+            "page_count": page_count,
+            "markdown": markdown,
+            "blocks": blocks,
+            "regions": regions,
+            "contents": contents,
+            "chunks": chunks,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.extraction_chunk import ExtractionChunk
+        from ..models.page_block import PageBlock
+        from ..models.region import Region
+        from ..models.region_content import RegionContent
+        d = dict(src_dict)
+        output_format = cast(Literal['openparser@1'] , d.pop("output_format"))
+        if output_format != 'openparser@1':
+            raise ValueError(f"output_format must match const 'openparser@1', got '{output_format}'")
+
+        document_id = d.pop("document_id")
+
+        page_count = d.pop("page_count")
+
+        markdown = d.pop("markdown")
+
+        blocks = []
+        _blocks = d.pop("blocks")
+        for blocks_item_data in (_blocks):
+            blocks_item = PageBlock.from_dict(blocks_item_data)
+
+
+
+            blocks.append(blocks_item)
+
+
+        regions = []
+        _regions = d.pop("regions")
+        for regions_item_data in (_regions):
+            regions_item = Region.from_dict(regions_item_data)
+
+
+
+            regions.append(regions_item)
+
+
+        contents = []
+        _contents = d.pop("contents")
+        for contents_item_data in (_contents):
+            contents_item = RegionContent.from_dict(contents_item_data)
+
+
+
+            contents.append(contents_item)
+
+
+        chunks = []
+        _chunks = d.pop("chunks")
+        for chunks_item_data in (_chunks):
+            chunks_item = ExtractionChunk.from_dict(chunks_item_data)
+
+
+
+            chunks.append(chunks_item)
+
+
+        parsed_document = cls(
+            output_format=output_format,
+            document_id=document_id,
+            page_count=page_count,
+            markdown=markdown,
+            blocks=blocks,
+            regions=regions,
+            contents=contents,
+            chunks=chunks,
+        )
+
+        return parsed_document

openparser/_generated/models/public_file.py

@@ -0,0 +1,117 @@
+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 dateutil.parser import isoparse
+from typing import cast
+import datetime
+
+
+
+
+
+
+T = TypeVar("T", bound="PublicFile")
+
+
+
+@_attrs_define
+class PublicFile:
+    """
+        Attributes:
+            id (str):
+            filename (str):
+            content_type (None | str):
+            size (int | None):
+            purpose (None):
+            created_at (datetime.datetime):
+     """
+
+    id: str
+    filename: str
+    content_type: None | str
+    size: int | None
+    purpose: None
+    created_at: datetime.datetime
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        filename = self.filename
+
+        content_type: None | str
+        content_type = self.content_type
+
+        size: int | None
+        size = self.size
+
+        purpose = self.purpose
+
+        created_at = self.created_at.isoformat()
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "id": id,
+            "filename": filename,
+            "contentType": content_type,
+            "size": size,
+            "purpose": purpose,
+            "createdAt": created_at,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        filename = d.pop("filename")
+
+        def _parse_content_type(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        content_type = _parse_content_type(d.pop("contentType"))
+
+
+        def _parse_size(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        size = _parse_size(d.pop("size"))
+
+
+        purpose = d.pop("purpose")
+
+        created_at = isoparse(d.pop("createdAt"))
+
+
+
+
+        public_file = cls(
+            id=id,
+            filename=filename,
+            content_type=content_type,
+            size=size,
+            purpose=purpose,
+            created_at=created_at,
+        )
+
+        return public_file

openparser/_generated/models/raw_parse_result.py

@@ -0,0 +1,110 @@
+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
+from typing import Literal, cast
+
+if TYPE_CHECKING:
+  from ..models.paddle_raw_profile import PaddleRawProfile
+  from ..models.raw_parse_result_result import RawParseResultResult
+
+
+
+
+
+T = TypeVar("T", bound="RawParseResult")
+
+
+
+@_attrs_define
+class RawParseResult:
+    """
+        Attributes:
+            output_format (Literal['raw']):
+            provider (Literal['paddle']):
+            model (Literal['paddleocr-vl-1.6']):
+            profile (PaddleRawProfile):
+            result (RawParseResultResult):
+     """
+
+    output_format: Literal['raw']
+    provider: Literal['paddle']
+    model: Literal['paddleocr-vl-1.6']
+    profile: PaddleRawProfile
+    result: RawParseResultResult
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.paddle_raw_profile import PaddleRawProfile
+        from ..models.raw_parse_result_result import RawParseResultResult
+        output_format = self.output_format
+
+        provider = self.provider
+
+        model = self.model
+
+        profile = self.profile.to_dict()
+
+        result = self.result.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "output_format": output_format,
+            "provider": provider,
+            "model": model,
+            "profile": profile,
+            "result": result,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.paddle_raw_profile import PaddleRawProfile
+        from ..models.raw_parse_result_result import RawParseResultResult
+        d = dict(src_dict)
+        output_format = cast(Literal['raw'] , d.pop("output_format"))
+        if output_format != 'raw':
+            raise ValueError(f"output_format must match const 'raw', got '{output_format}'")
+
+        provider = cast(Literal['paddle'] , d.pop("provider"))
+        if provider != 'paddle':
+            raise ValueError(f"provider must match const 'paddle', got '{provider}'")
+
+        model = cast(Literal['paddleocr-vl-1.6'] , d.pop("model"))
+        if model != 'paddleocr-vl-1.6':
+            raise ValueError(f"model must match const 'paddleocr-vl-1.6', got '{model}'")
+
+        profile = PaddleRawProfile.from_dict(d.pop("profile"))
+
+
+
+
+        result = RawParseResultResult.from_dict(d.pop("result"))
+
+
+
+
+        raw_parse_result = cls(
+            output_format=output_format,
+            provider=provider,
+            model=model,
+            profile=profile,
+            result=result,
+        )
+
+        return raw_parse_result

openparser/_generated/models/raw_parse_result_result.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="RawParseResultResult")
+
+
+
+@_attrs_define
+class RawParseResultResult:
+    """
+     """
+
+    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)
+        raw_parse_result_result = cls(
+        )
+
+
+        raw_parse_result_result.additional_properties = d
+        return raw_parse_result_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