openparser-sdk 0.0.1__py3-none-any.whl

openparser/_generated/models/extraction_attempt.py

@@ -0,0 +1,122 @@
+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.extraction_attempt_kind import ExtractionAttemptKind
+from ..models.extraction_attempt_status import ExtractionAttemptStatus
+from ..types import UNSET, Unset
+
+
+
+
+
+
+T = TypeVar("T", bound="ExtractionAttempt")
+
+
+
+@_attrs_define
+class ExtractionAttempt:
+    """
+        Attributes:
+            index (int): Zero-based attempt index in execution order.
+            kind (ExtractionAttemptKind):
+            llm_model (str): OpenRouter model slug from the compatible OCR extraction catalog
+                (`GET /models/llm`). Unknown or deprecated values return `422 unsupported_llm_model`.
+                Ordinary extract may use any currently compatible model; field grounding requires a
+                certified model.
+                 Example: openai/gpt-5.6-terra.
+            status (ExtractionAttemptStatus):
+            input_tokens (int | Unset):
+            output_tokens (int | Unset):
+            cost_usd (float | Unset): Customer retail USD for this attempt (OpenRouter provider cost converted to the
+                rates customers are charged). Distinct from the OCR page charge.
+     """
+
+    index: int
+    kind: ExtractionAttemptKind
+    llm_model: str
+    status: ExtractionAttemptStatus
+    input_tokens: int | Unset = UNSET
+    output_tokens: int | Unset = UNSET
+    cost_usd: float | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        index = self.index
+
+        kind = self.kind.value
+
+        llm_model = self.llm_model
+
+        status = self.status.value
+
+        input_tokens = self.input_tokens
+
+        output_tokens = self.output_tokens
+
+        cost_usd = self.cost_usd
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "index": index,
+            "kind": kind,
+            "llm_model": llm_model,
+            "status": status,
+        })
+        if input_tokens is not UNSET:
+            field_dict["input_tokens"] = input_tokens
+        if output_tokens is not UNSET:
+            field_dict["output_tokens"] = output_tokens
+        if cost_usd is not UNSET:
+            field_dict["cost_usd"] = cost_usd
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        index = d.pop("index")
+
+        kind = ExtractionAttemptKind(d.pop("kind"))
+
+
+
+
+        llm_model = d.pop("llm_model")
+
+        status = ExtractionAttemptStatus(d.pop("status"))
+
+
+
+
+        input_tokens = d.pop("input_tokens", UNSET)
+
+        output_tokens = d.pop("output_tokens", UNSET)
+
+        cost_usd = d.pop("cost_usd", UNSET)
+
+        extraction_attempt = cls(
+            index=index,
+            kind=kind,
+            llm_model=llm_model,
+            status=status,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            cost_usd=cost_usd,
+        )
+
+        return extraction_attempt

openparser/_generated/models/extraction_attempt_kind.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class ExtractionAttemptKind(str, Enum):
+    PRIMARY = "primary"
+    REPAIR = "repair"
+
+    def __str__(self) -> str:
+        return str(self.value)

openparser/_generated/models/extraction_attempt_status.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class ExtractionAttemptStatus(str, Enum):
+    FAILED = "failed"
+    INDETERMINATE = "indeterminate"
+    SUCCEEDED = "succeeded"
+
+    def __str__(self) -> str:
+        return str(self.value)

openparser/_generated/models/extraction_chunk.py

@@ -0,0 +1,184 @@
+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
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.chunk_provenance_span import ChunkProvenanceSpan
+
+
+
+
+
+T = TypeVar("T", bound="ExtractionChunk")
+
+
+
+@_attrs_define
+class ExtractionChunk:
+    """ Canonical extraction chunk. `id` and `content_sha256` are lowercase SHA-256 hashes;
+    `content_sha256` hashes `text`. Page numbers are sorted and unique. When present,
+    `page_start` and `page_end` equal the minimum and maximum `page_numbers`. Region IDs and
+    provenance spans must match the parent document's regions.
+
+        Attributes:
+            id (str):
+            index (int):
+            document_id (str):
+            text (str):
+            content_sha256 (str):
+            page_numbers (list[int]):
+            region_ids (list[str]):
+            provenance_spans (list[ChunkProvenanceSpan]):
+            page_start (int | None | Unset):
+            page_end (int | None | Unset):
+     """
+
+    id: str
+    index: int
+    document_id: str
+    text: str
+    content_sha256: str
+    page_numbers: list[int]
+    region_ids: list[str]
+    provenance_spans: list[ChunkProvenanceSpan]
+    page_start: int | None | Unset = UNSET
+    page_end: int | None | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.chunk_provenance_span import ChunkProvenanceSpan
+        id = self.id
+
+        index = self.index
+
+        document_id = self.document_id
+
+        text = self.text
+
+        content_sha256 = self.content_sha256
+
+        page_numbers = self.page_numbers
+
+
+
+        region_ids = self.region_ids
+
+
+
+        provenance_spans = []
+        for provenance_spans_item_data in self.provenance_spans:
+            provenance_spans_item = provenance_spans_item_data.to_dict()
+            provenance_spans.append(provenance_spans_item)
+
+
+
+        page_start: int | None | Unset
+        if isinstance(self.page_start, Unset):
+            page_start = UNSET
+        else:
+            page_start = self.page_start
+
+        page_end: int | None | Unset
+        if isinstance(self.page_end, Unset):
+            page_end = UNSET
+        else:
+            page_end = self.page_end
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "id": id,
+            "index": index,
+            "document_id": document_id,
+            "text": text,
+            "content_sha256": content_sha256,
+            "page_numbers": page_numbers,
+            "region_ids": region_ids,
+            "provenance_spans": provenance_spans,
+        })
+        if page_start is not UNSET:
+            field_dict["page_start"] = page_start
+        if page_end is not UNSET:
+            field_dict["page_end"] = page_end
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.chunk_provenance_span import ChunkProvenanceSpan
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        index = d.pop("index")
+
+        document_id = d.pop("document_id")
+
+        text = d.pop("text")
+
+        content_sha256 = d.pop("content_sha256")
+
+        page_numbers = cast(list[int], d.pop("page_numbers"))
+
+
+        region_ids = cast(list[str], d.pop("region_ids"))
+
+
+        provenance_spans = []
+        _provenance_spans = d.pop("provenance_spans")
+        for provenance_spans_item_data in (_provenance_spans):
+            provenance_spans_item = ChunkProvenanceSpan.from_dict(provenance_spans_item_data)
+
+
+
+            provenance_spans.append(provenance_spans_item)
+
+
+        def _parse_page_start(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        page_start = _parse_page_start(d.pop("page_start", UNSET))
+
+
+        def _parse_page_end(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        page_end = _parse_page_end(d.pop("page_end", UNSET))
+
+
+        extraction_chunk = cls(
+            id=id,
+            index=index,
+            document_id=document_id,
+            text=text,
+            content_sha256=content_sha256,
+            page_numbers=page_numbers,
+            region_ids=region_ids,
+            provenance_spans=provenance_spans,
+            page_start=page_start,
+            page_end=page_end,
+        )
+
+        return extraction_chunk

openparser/_generated/models/extraction_citation.py

@@ -0,0 +1,169 @@
+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.extraction_citation_granularity import ExtractionCitationGranularity
+from ..models.extraction_citation_source_type import ExtractionCitationSourceType
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.bounding_box import BoundingBox
+
+
+
+
+
+T = TypeVar("T", bound="ExtractionCitation")
+
+
+
+@_attrs_define
+class ExtractionCitation:
+    """ Verified provenance for one extracted leaf citation. Geometry comes from the parse, never the model.
+
+        Attributes:
+            block_index (int):
+            page_number (int):
+            bbox (BoundingBox): Axis-aligned integer page coordinates with exclusive right and bottom edges.
+            source_type (ExtractionCitationSourceType):
+            granularity (ExtractionCitationGranularity): Citation geometry granularity. Citation v1 emits only `block`;
+                `region` is reserved
+                for a later narrowing release.
+            region_id (str | Unset):
+            coordinate_width (int | None | Unset):
+            coordinate_height (int | None | Unset):
+            confidence (float | Unset):
+     """
+
+    block_index: int
+    page_number: int
+    bbox: BoundingBox
+    source_type: ExtractionCitationSourceType
+    granularity: ExtractionCitationGranularity
+    region_id: str | Unset = UNSET
+    coordinate_width: int | None | Unset = UNSET
+    coordinate_height: int | None | Unset = UNSET
+    confidence: float | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.bounding_box import BoundingBox
+        block_index = self.block_index
+
+        page_number = self.page_number
+
+        bbox = self.bbox.to_dict()
+
+        source_type = self.source_type.value
+
+        granularity = self.granularity.value
+
+        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
+
+        confidence = self.confidence
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "block_index": block_index,
+            "page_number": page_number,
+            "bbox": bbox,
+            "source_type": source_type,
+            "granularity": granularity,
+        })
+        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
+        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:
+        from ..models.bounding_box import BoundingBox
+        d = dict(src_dict)
+        block_index = d.pop("block_index")
+
+        page_number = d.pop("page_number")
+
+        bbox = BoundingBox.from_dict(d.pop("bbox"))
+
+
+
+
+        source_type = ExtractionCitationSourceType(d.pop("source_type"))
+
+
+
+
+        granularity = ExtractionCitationGranularity(d.pop("granularity"))
+
+
+
+
+        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))
+
+
+        confidence = d.pop("confidence", UNSET)
+
+        extraction_citation = cls(
+            block_index=block_index,
+            page_number=page_number,
+            bbox=bbox,
+            source_type=source_type,
+            granularity=granularity,
+            region_id=region_id,
+            coordinate_width=coordinate_width,
+            coordinate_height=coordinate_height,
+            confidence=confidence,
+        )
+
+        return extraction_citation

openparser/_generated/models/extraction_citation_granularity.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class ExtractionCitationGranularity(str, Enum):
+    BLOCK = "block"
+    REGION = "region"
+
+    def __str__(self) -> str:
+        return str(self.value)

openparser/_generated/models/extraction_citation_source_type.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class ExtractionCitationSourceType(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/extraction_grounding_field.py

@@ -0,0 +1,102 @@
+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
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.extraction_citation import ExtractionCitation
+
+
+
+
+
+T = TypeVar("T", bound="ExtractionGroundingField")
+
+
+
+@_attrs_define
+class ExtractionGroundingField:
+    """ Grounding metadata for one leaf in the unwrapped extraction output. `path` uses
+    dot-separated property segments and decimal array-index segments, for example
+    `line_items.0.amount`.
+
+        Attributes:
+            path (str): Dot-separated path from the output root. Array positions are decimal segments.
+                Property names containing dots are outside the field-grounding schema subset.
+            citations (list[ExtractionCitation]):
+            dropped_source_ids (list[str] | Unset):
+     """
+
+    path: str
+    citations: list[ExtractionCitation]
+    dropped_source_ids: list[str] | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.extraction_citation import ExtractionCitation
+        path = self.path
+
+        citations = []
+        for citations_item_data in self.citations:
+            citations_item = citations_item_data.to_dict()
+            citations.append(citations_item)
+
+
+
+        dropped_source_ids: list[str] | Unset = UNSET
+        if not isinstance(self.dropped_source_ids, Unset):
+            dropped_source_ids = self.dropped_source_ids
+
+
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "path": path,
+            "citations": citations,
+        })
+        if dropped_source_ids is not UNSET:
+            field_dict["dropped_source_ids"] = dropped_source_ids
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.extraction_citation import ExtractionCitation
+        d = dict(src_dict)
+        path = d.pop("path")
+
+        citations = []
+        _citations = d.pop("citations")
+        for citations_item_data in (_citations):
+            citations_item = ExtractionCitation.from_dict(citations_item_data)
+
+
+
+            citations.append(citations_item)
+
+
+        dropped_source_ids = cast(list[str], d.pop("dropped_source_ids", UNSET))
+
+
+        extraction_grounding_field = cls(
+            path=path,
+            citations=citations,
+            dropped_source_ids=dropped_source_ids,
+        )
+
+        return extraction_grounding_field

openparser/_generated/models/extraction_grounding_mode.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class ExtractionGroundingMode(str, Enum):
+    FIELD = "field"
+    NONE = "none"
+
+    def __str__(self) -> str:
+        return str(self.value)