openparser-sdk 0.0.1__py3-none-any.whl

openparser/_generated/models/batch_job_accepted.py

@@ -0,0 +1,139 @@
+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.batch_job_accepted_operation import BatchJobAcceptedOperation
+from ..models.job_status import JobStatus
+from ..models.ocr_output_format import OcrOutputFormat
+from dateutil.parser import isoparse
+from typing import cast
+import datetime
+
+
+
+
+
+
+T = TypeVar("T", bound="BatchJobAccepted")
+
+
+
+@_attrs_define
+class BatchJobAccepted:
+    """
+        Attributes:
+            id (str): Prefixed public id for an OCR job (`opj_…`). Example: opj_V1StGXR8_Z5jdHi6B-myT.
+            operation (BatchJobAcceptedOperation):
+            status (JobStatus): Durable job status. For batch parent jobs, status is derived from children after each
+                child transition:
+                1. If any child is non-terminal, the parent remains `queued` only while every child is
+                   queued; it becomes `running` once any child is running or terminal.
+                2. When every child is terminal and any child is `indeterminate`, the parent is
+                   `indeterminate`.
+                3. When every child is terminal, none are `indeterminate`, and any child is `failed`:
+                   the parent is `failed` if zero children succeeded, otherwise `succeeded` (mixed
+                   success/failure closes as parent `succeeded` while preserving failed children in
+                   summaries).
+                4. When every child is `succeeded`, the parent is `succeeded`.
+
+                Partial failures are always retained on child summaries; parent status does not drop
+                failed children from results.
+            output_format (OcrOutputFormat):
+            created_at (datetime.datetime):
+            updated_at (datetime.datetime):
+            child_count (int):
+     """
+
+    id: str
+    operation: BatchJobAcceptedOperation
+    status: JobStatus
+    output_format: OcrOutputFormat
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    child_count: int
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        operation = self.operation.value
+
+        status = self.status.value
+
+        output_format = self.output_format.value
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        child_count = self.child_count
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "id": id,
+            "operation": operation,
+            "status": status,
+            "output_format": output_format,
+            "created_at": created_at,
+            "updated_at": updated_at,
+            "child_count": child_count,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        operation = BatchJobAcceptedOperation(d.pop("operation"))
+
+
+
+
+        status = JobStatus(d.pop("status"))
+
+
+
+
+        output_format = OcrOutputFormat(d.pop("output_format"))
+
+
+
+
+        created_at = isoparse(d.pop("created_at"))
+
+
+
+
+        updated_at = isoparse(d.pop("updated_at"))
+
+
+
+
+        child_count = d.pop("child_count")
+
+        batch_job_accepted = cls(
+            id=id,
+            operation=operation,
+            status=status,
+            output_format=output_format,
+            created_at=created_at,
+            updated_at=updated_at,
+            child_count=child_count,
+        )
+
+        return batch_job_accepted

openparser/_generated/models/batch_job_accepted_operation.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class BatchJobAcceptedOperation(str, Enum):
+    EXTRACT_BATCH = "extract_batch"
+    PARSE_BATCH = "parse_batch"
+
+    def __str__(self) -> str:
+        return str(self.value)

openparser/_generated/models/batch_summary_counts.py

@@ -0,0 +1,97 @@
+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="BatchSummaryCounts")
+
+
+
+@_attrs_define
+class BatchSummaryCounts:
+    """
+        Attributes:
+            total (int):
+            queued (int):
+            running (int):
+            succeeded (int):
+            failed (int):
+            indeterminate (int):
+     """
+
+    total: int
+    queued: int
+    running: int
+    succeeded: int
+    failed: int
+    indeterminate: int
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        total = self.total
+
+        queued = self.queued
+
+        running = self.running
+
+        succeeded = self.succeeded
+
+        failed = self.failed
+
+        indeterminate = self.indeterminate
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "total": total,
+            "queued": queued,
+            "running": running,
+            "succeeded": succeeded,
+            "failed": failed,
+            "indeterminate": indeterminate,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        total = d.pop("total")
+
+        queued = d.pop("queued")
+
+        running = d.pop("running")
+
+        succeeded = d.pop("succeeded")
+
+        failed = d.pop("failed")
+
+        indeterminate = d.pop("indeterminate")
+
+        batch_summary_counts = cls(
+            total=total,
+            queued=queued,
+            running=running,
+            succeeded=succeeded,
+            failed=failed,
+            indeterminate=indeterminate,
+        )
+
+        return batch_summary_counts

openparser/_generated/models/bounding_box.py

@@ -0,0 +1,82 @@
+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="BoundingBox")
+
+
+
+@_attrs_define
+class BoundingBox:
+    """ Axis-aligned integer page coordinates with exclusive right and bottom edges.
+
+        Attributes:
+            left (int):
+            top (int):
+            right (int):
+            bottom (int):
+     """
+
+    left: int
+    top: int
+    right: int
+    bottom: int
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        left = self.left
+
+        top = self.top
+
+        right = self.right
+
+        bottom = self.bottom
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "left": left,
+            "top": top,
+            "right": right,
+            "bottom": bottom,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        left = d.pop("left")
+
+        top = d.pop("top")
+
+        right = d.pop("right")
+
+        bottom = d.pop("bottom")
+
+        bounding_box = cls(
+            left=left,
+            top=top,
+            right=right,
+            bottom=bottom,
+        )
+
+        return bounding_box

openparser/_generated/models/chunk_provenance_span.py

@@ -0,0 +1,97 @@
+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.bounding_box import BoundingBox
+
+
+
+
+
+T = TypeVar("T", bound="ChunkProvenanceSpan")
+
+
+
+@_attrs_define
+class ChunkProvenanceSpan:
+    """
+        Attributes:
+            start_char (int):
+            end_char (int):
+            page_number (int):
+            bbox (BoundingBox): Axis-aligned integer page coordinates with exclusive right and bottom edges.
+            region_id (str):
+     """
+
+    start_char: int
+    end_char: int
+    page_number: int
+    bbox: BoundingBox
+    region_id: str
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.bounding_box import BoundingBox
+        start_char = self.start_char
+
+        end_char = self.end_char
+
+        page_number = self.page_number
+
+        bbox = self.bbox.to_dict()
+
+        region_id = self.region_id
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "start_char": start_char,
+            "end_char": end_char,
+            "page_number": page_number,
+            "bbox": bbox,
+            "region_id": region_id,
+        })
+
+        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)
+        start_char = d.pop("start_char")
+
+        end_char = d.pop("end_char")
+
+        page_number = d.pop("page_number")
+
+        bbox = BoundingBox.from_dict(d.pop("bbox"))
+
+
+
+
+        region_id = d.pop("region_id")
+
+        chunk_provenance_span = cls(
+            start_char=start_char,
+            end_char=end_char,
+            page_number=page_number,
+            bbox=bbox,
+            region_id=region_id,
+        )
+
+        return chunk_provenance_span

openparser/_generated/models/content_kind.py

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

openparser/_generated/models/create_extraction_pipeline_request.py

@@ -0,0 +1,177 @@
+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.create_extraction_pipeline_request_grounding import CreateExtractionPipelineRequestGrounding
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.create_extraction_pipeline_request_llm_options import CreateExtractionPipelineRequestLlmOptions
+  from ..models.create_extraction_pipeline_request_ocr_options import CreateExtractionPipelineRequestOcrOptions
+  from ..models.create_extraction_pipeline_request_schema import CreateExtractionPipelineRequestSchema
+
+
+
+
+
+T = TypeVar("T", bound="CreateExtractionPipelineRequest")
+
+
+
+@_attrs_define
+class CreateExtractionPipelineRequest:
+    """ Create a tenant-scoped saved extraction configuration.
+
+        Attributes:
+            name (str):
+            ocr_model (str):
+            llm_model (str):
+            schema (CreateExtractionPipelineRequestSchema): JSON Schema object describing fields to extract. Root must be an
+                object schema with
+                explicit `properties` and at least one named property. Admission applies the same
+                strict structured-output normalization as extract.
+            slug (str | Unset):
+            ocr_options (CreateExtractionPipelineRequestOcrOptions | Unset):
+            llm_options (CreateExtractionPipelineRequestLlmOptions | Unset):
+            repair_attempts (int | Unset):
+            grounding (CreateExtractionPipelineRequestGrounding | Unset):
+     """
+
+    name: str
+    ocr_model: str
+    llm_model: str
+    schema: CreateExtractionPipelineRequestSchema
+    slug: str | Unset = UNSET
+    ocr_options: CreateExtractionPipelineRequestOcrOptions | Unset = UNSET
+    llm_options: CreateExtractionPipelineRequestLlmOptions | Unset = UNSET
+    repair_attempts: int | Unset = UNSET
+    grounding: CreateExtractionPipelineRequestGrounding | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.create_extraction_pipeline_request_llm_options import CreateExtractionPipelineRequestLlmOptions
+        from ..models.create_extraction_pipeline_request_ocr_options import CreateExtractionPipelineRequestOcrOptions
+        from ..models.create_extraction_pipeline_request_schema import CreateExtractionPipelineRequestSchema
+        name = self.name
+
+        ocr_model = self.ocr_model
+
+        llm_model = self.llm_model
+
+        schema = self.schema.to_dict()
+
+        slug = self.slug
+
+        ocr_options: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.ocr_options, Unset):
+            ocr_options = self.ocr_options.to_dict()
+
+        llm_options: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.llm_options, Unset):
+            llm_options = self.llm_options.to_dict()
+
+        repair_attempts = self.repair_attempts
+
+        grounding: str | Unset = UNSET
+        if not isinstance(self.grounding, Unset):
+            grounding = self.grounding.value
+
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "name": name,
+            "ocr_model": ocr_model,
+            "llm_model": llm_model,
+            "schema": schema,
+        })
+        if slug is not UNSET:
+            field_dict["slug"] = slug
+        if ocr_options is not UNSET:
+            field_dict["ocr_options"] = ocr_options
+        if llm_options is not UNSET:
+            field_dict["llm_options"] = llm_options
+        if repair_attempts is not UNSET:
+            field_dict["repair_attempts"] = repair_attempts
+        if grounding is not UNSET:
+            field_dict["grounding"] = grounding
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.create_extraction_pipeline_request_llm_options import CreateExtractionPipelineRequestLlmOptions
+        from ..models.create_extraction_pipeline_request_ocr_options import CreateExtractionPipelineRequestOcrOptions
+        from ..models.create_extraction_pipeline_request_schema import CreateExtractionPipelineRequestSchema
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        ocr_model = d.pop("ocr_model")
+
+        llm_model = d.pop("llm_model")
+
+        schema = CreateExtractionPipelineRequestSchema.from_dict(d.pop("schema"))
+
+
+
+
+        slug = d.pop("slug", UNSET)
+
+        _ocr_options = d.pop("ocr_options", UNSET)
+        ocr_options: CreateExtractionPipelineRequestOcrOptions | Unset
+        if isinstance(_ocr_options,  Unset):
+            ocr_options = UNSET
+        else:
+            ocr_options = CreateExtractionPipelineRequestOcrOptions.from_dict(_ocr_options)
+
+
+
+
+        _llm_options = d.pop("llm_options", UNSET)
+        llm_options: CreateExtractionPipelineRequestLlmOptions | Unset
+        if isinstance(_llm_options,  Unset):
+            llm_options = UNSET
+        else:
+            llm_options = CreateExtractionPipelineRequestLlmOptions.from_dict(_llm_options)
+
+
+
+
+        repair_attempts = d.pop("repair_attempts", UNSET)
+
+        _grounding = d.pop("grounding", UNSET)
+        grounding: CreateExtractionPipelineRequestGrounding | Unset
+        if isinstance(_grounding,  Unset):
+            grounding = UNSET
+        else:
+            grounding = CreateExtractionPipelineRequestGrounding(_grounding)
+
+
+
+
+        create_extraction_pipeline_request = cls(
+            name=name,
+            ocr_model=ocr_model,
+            llm_model=llm_model,
+            schema=schema,
+            slug=slug,
+            ocr_options=ocr_options,
+            llm_options=llm_options,
+            repair_attempts=repair_attempts,
+            grounding=grounding,
+        )
+
+        return create_extraction_pipeline_request

openparser/_generated/models/create_extraction_pipeline_request_grounding.py

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

openparser/_generated/models/create_extraction_pipeline_request_llm_options.py

@@ -0,0 +1,84 @@
+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.create_extraction_pipeline_request_llm_options_reasoning_effort_type_1 import CreateExtractionPipelineRequestLlmOptionsReasoningEffortType1
+from ..types import UNSET, Unset
+from typing import cast
+from typing import Literal, cast
+
+
+
+
+
+
+T = TypeVar("T", bound="CreateExtractionPipelineRequestLlmOptions")
+
+
+
+@_attrs_define
+class CreateExtractionPipelineRequestLlmOptions:
+    """
+        Attributes:
+            reasoning_effort (CreateExtractionPipelineRequestLlmOptionsReasoningEffortType1 | Literal['auto'] | Unset):
+     """
+
+    reasoning_effort: CreateExtractionPipelineRequestLlmOptionsReasoningEffortType1 | Literal['auto'] | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        reasoning_effort: Literal['auto'] | str | Unset
+        if isinstance(self.reasoning_effort, Unset):
+            reasoning_effort = UNSET
+        elif isinstance(self.reasoning_effort, CreateExtractionPipelineRequestLlmOptionsReasoningEffortType1):
+            reasoning_effort = self.reasoning_effort.value
+        else:
+            reasoning_effort = self.reasoning_effort
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+        })
+        if reasoning_effort is not UNSET:
+            field_dict["reasoning_effort"] = reasoning_effort
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        def _parse_reasoning_effort(data: object) -> CreateExtractionPipelineRequestLlmOptionsReasoningEffortType1 | Literal['auto'] | Unset:
+            if isinstance(data, Unset):
+                return data
+            reasoning_effort_type_0 = cast(Literal['auto'] , data)
+            if reasoning_effort_type_0 != 'auto':
+                raise ValueError(f"reasoning_effort_type_0 must match const 'auto', got '{reasoning_effort_type_0}'")
+            return reasoning_effort_type_0
+            if not isinstance(data, str):
+                raise TypeError()
+            reasoning_effort_type_1 = CreateExtractionPipelineRequestLlmOptionsReasoningEffortType1(data)
+
+
+
+            return reasoning_effort_type_1
+
+        reasoning_effort = _parse_reasoning_effort(d.pop("reasoning_effort", UNSET))
+
+
+        create_extraction_pipeline_request_llm_options = cls(
+            reasoning_effort=reasoning_effort,
+        )
+
+        return create_extraction_pipeline_request_llm_options