openparser-sdk 0.0.1__py3-none-any.whl

openparser/_generated/models/extraction_grounding_result.py

@@ -0,0 +1,87 @@
+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_grounding_field import ExtractionGroundingField
+
+
+
+
+
+T = TypeVar("T", bound="ExtractionGroundingResult")
+
+
+
+@_attrs_define
+class ExtractionGroundingResult:
+    """ Optional terminal grounding envelope present only when `grounding: field` succeeded.
+
+        Attributes:
+            mode (Literal['field']):
+            fields (list[ExtractionGroundingField]):
+     """
+
+    mode: Literal['field']
+    fields: list[ExtractionGroundingField]
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.extraction_grounding_field import ExtractionGroundingField
+        mode = self.mode
+
+        fields = []
+        for fields_item_data in self.fields:
+            fields_item = fields_item_data.to_dict()
+            fields.append(fields_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "mode": mode,
+            "fields": fields,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.extraction_grounding_field import ExtractionGroundingField
+        d = dict(src_dict)
+        mode = cast(Literal['field'] , d.pop("mode"))
+        if mode != 'field':
+            raise ValueError(f"mode must match const 'field', got '{mode}'")
+
+        fields = []
+        _fields = d.pop("fields")
+        for fields_item_data in (_fields):
+            fields_item = ExtractionGroundingField.from_dict(fields_item_data)
+
+
+
+            fields.append(fields_item)
+
+
+        extraction_grounding_result = cls(
+            mode=mode,
+            fields=fields,
+        )
+
+        return extraction_grounding_result

openparser/_generated/models/extraction_pipeline.py

@@ -0,0 +1,201 @@
+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_grounding_mode import ExtractionGroundingMode
+from dateutil.parser import isoparse
+from typing import cast
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.extraction_pipeline_llm_options import ExtractionPipelineLlmOptions
+  from ..models.extraction_pipeline_ocr_options import ExtractionPipelineOcrOptions
+  from ..models.extraction_pipeline_schema import ExtractionPipelineSchema
+
+
+
+
+
+T = TypeVar("T", bound="ExtractionPipeline")
+
+
+
+@_attrs_define
+class ExtractionPipeline:
+    """ Public saved extraction pipeline resource.
+
+        Attributes:
+            id (str): Prefixed public id for a saved extraction pipeline (`oppl_…`).
+            name (str):
+            slug (None | str):
+            version (int):
+            ocr_model (str):
+            ocr_options (ExtractionPipelineOcrOptions):
+            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.
+            llm_options (ExtractionPipelineLlmOptions):
+            schema (ExtractionPipelineSchema): Persisted extraction schema with at least one root property. Normalized for
+                strict
+                structured outputs at save time.
+            repair_attempts (int):
+            grounding (ExtractionGroundingMode): Extraction grounding mode. `none` preserves ordinary extraction. `field`
+                requests
+                verified per-leaf source citations (citation v1 emits block-level citations only).
+            created_at (datetime.datetime):
+            updated_at (datetime.datetime):
+     """
+
+    id: str
+    name: str
+    slug: None | str
+    version: int
+    ocr_model: str
+    ocr_options: ExtractionPipelineOcrOptions
+    llm_model: str
+    llm_options: ExtractionPipelineLlmOptions
+    schema: ExtractionPipelineSchema
+    repair_attempts: int
+    grounding: ExtractionGroundingMode
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.extraction_pipeline_llm_options import ExtractionPipelineLlmOptions
+        from ..models.extraction_pipeline_ocr_options import ExtractionPipelineOcrOptions
+        from ..models.extraction_pipeline_schema import ExtractionPipelineSchema
+        id = self.id
+
+        name = self.name
+
+        slug: None | str
+        slug = self.slug
+
+        version = self.version
+
+        ocr_model = self.ocr_model
+
+        ocr_options = self.ocr_options.to_dict()
+
+        llm_model = self.llm_model
+
+        llm_options = self.llm_options.to_dict()
+
+        schema = self.schema.to_dict()
+
+        repair_attempts = self.repair_attempts
+
+        grounding = self.grounding.value
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "id": id,
+            "name": name,
+            "slug": slug,
+            "version": version,
+            "ocr_model": ocr_model,
+            "ocr_options": ocr_options,
+            "llm_model": llm_model,
+            "llm_options": llm_options,
+            "schema": schema,
+            "repair_attempts": repair_attempts,
+            "grounding": grounding,
+            "created_at": created_at,
+            "updated_at": updated_at,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.extraction_pipeline_llm_options import ExtractionPipelineLlmOptions
+        from ..models.extraction_pipeline_ocr_options import ExtractionPipelineOcrOptions
+        from ..models.extraction_pipeline_schema import ExtractionPipelineSchema
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        name = d.pop("name")
+
+        def _parse_slug(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        slug = _parse_slug(d.pop("slug"))
+
+
+        version = d.pop("version")
+
+        ocr_model = d.pop("ocr_model")
+
+        ocr_options = ExtractionPipelineOcrOptions.from_dict(d.pop("ocr_options"))
+
+
+
+
+        llm_model = d.pop("llm_model")
+
+        llm_options = ExtractionPipelineLlmOptions.from_dict(d.pop("llm_options"))
+
+
+
+
+        schema = ExtractionPipelineSchema.from_dict(d.pop("schema"))
+
+
+
+
+        repair_attempts = d.pop("repair_attempts")
+
+        grounding = ExtractionGroundingMode(d.pop("grounding"))
+
+
+
+
+        created_at = isoparse(d.pop("created_at"))
+
+
+
+
+        updated_at = isoparse(d.pop("updated_at"))
+
+
+
+
+        extraction_pipeline = cls(
+            id=id,
+            name=name,
+            slug=slug,
+            version=version,
+            ocr_model=ocr_model,
+            ocr_options=ocr_options,
+            llm_model=llm_model,
+            llm_options=llm_options,
+            schema=schema,
+            repair_attempts=repair_attempts,
+            grounding=grounding,
+            created_at=created_at,
+            updated_at=updated_at,
+        )
+
+        return extraction_pipeline

openparser/_generated/models/extraction_pipeline_list_response.py

@@ -0,0 +1,76 @@
+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.extraction_pipeline import ExtractionPipeline
+
+
+
+
+
+T = TypeVar("T", bound="ExtractionPipelineListResponse")
+
+
+
+@_attrs_define
+class ExtractionPipelineListResponse:
+    """ Active pipelines for the authenticated tenant.
+
+        Attributes:
+            items (list[ExtractionPipeline]):
+     """
+
+    items: list[ExtractionPipeline]
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.extraction_pipeline import ExtractionPipeline
+        items = []
+        for items_item_data in self.items:
+            items_item = items_item_data.to_dict()
+            items.append(items_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "items": items,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.extraction_pipeline import ExtractionPipeline
+        d = dict(src_dict)
+        items = []
+        _items = d.pop("items")
+        for items_item_data in (_items):
+            items_item = ExtractionPipeline.from_dict(items_item_data)
+
+
+
+            items.append(items_item)
+
+
+        extraction_pipeline_list_response = cls(
+            items=items,
+        )
+
+        return extraction_pipeline_list_response

openparser/_generated/models/extraction_pipeline_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.extraction_pipeline_llm_options_reasoning_effort_type_0_type_1 import ExtractionPipelineLlmOptionsReasoningEffortType0Type1
+from typing import cast
+from typing import Literal, cast
+
+
+
+
+
+
+T = TypeVar("T", bound="ExtractionPipelineLlmOptions")
+
+
+
+@_attrs_define
+class ExtractionPipelineLlmOptions:
+    """
+        Attributes:
+            reasoning_effort (ExtractionPipelineLlmOptionsReasoningEffortType0Type1 | Literal['auto'] | None):
+     """
+
+    reasoning_effort: ExtractionPipelineLlmOptionsReasoningEffortType0Type1 | Literal['auto'] | None
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        reasoning_effort: Literal['auto'] | None | str
+        if isinstance(self.reasoning_effort, ExtractionPipelineLlmOptionsReasoningEffortType0Type1):
+            reasoning_effort = self.reasoning_effort.value
+        else:
+            reasoning_effort = self.reasoning_effort
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "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) -> ExtractionPipelineLlmOptionsReasoningEffortType0Type1 | Literal['auto'] | None:
+            if data is None:
+                return data
+            reasoning_effort_type_0_type_0 = cast(Literal['auto'] , data)
+            if reasoning_effort_type_0_type_0 != 'auto':
+                raise ValueError(f"reasoning_effort_type_0_type_0 must match const 'auto', got '{reasoning_effort_type_0_type_0}'")
+            return reasoning_effort_type_0_type_0
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                reasoning_effort_type_0_type_1 = ExtractionPipelineLlmOptionsReasoningEffortType0Type1(data)
+
+
+
+                return reasoning_effort_type_0_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(ExtractionPipelineLlmOptionsReasoningEffortType0Type1 | Literal['auto'] | None, data)
+
+        reasoning_effort = _parse_reasoning_effort(d.pop("reasoning_effort"))
+
+
+        extraction_pipeline_llm_options = cls(
+            reasoning_effort=reasoning_effort,
+        )
+
+        return extraction_pipeline_llm_options

openparser/_generated/models/extraction_pipeline_llm_options_reasoning_effort_type_0_type_1.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+class ExtractionPipelineLlmOptionsReasoningEffortType0Type1(str, Enum):
+    HIGH = "high"
+    LOW = "low"
+    MAX = "max"
+    MEDIUM = "medium"
+    MINIMAL = "minimal"
+    NONE = "none"
+    XHIGH = "xhigh"
+
+    def __str__(self) -> str:
+        return str(self.value)

openparser/_generated/models/extraction_pipeline_ocr_options.py

@@ -0,0 +1,73 @@
+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="ExtractionPipelineOcrOptions")
+
+
+
+@_attrs_define
+class ExtractionPipelineOcrOptions:
+    """
+        Attributes:
+            image_block_ocr (bool):
+            chart_recognition (bool):
+            merge_layout_blocks (bool):
+     """
+
+    image_block_ocr: bool
+    chart_recognition: bool
+    merge_layout_blocks: bool
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        image_block_ocr = self.image_block_ocr
+
+        chart_recognition = self.chart_recognition
+
+        merge_layout_blocks = self.merge_layout_blocks
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "image_block_ocr": image_block_ocr,
+            "chart_recognition": chart_recognition,
+            "merge_layout_blocks": merge_layout_blocks,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        image_block_ocr = d.pop("image_block_ocr")
+
+        chart_recognition = d.pop("chart_recognition")
+
+        merge_layout_blocks = d.pop("merge_layout_blocks")
+
+        extraction_pipeline_ocr_options = cls(
+            image_block_ocr=image_block_ocr,
+            chart_recognition=chart_recognition,
+            merge_layout_blocks=merge_layout_blocks,
+        )
+
+        return extraction_pipeline_ocr_options

openparser/_generated/models/extraction_pipeline_schema.py

@@ -0,0 +1,67 @@
+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="ExtractionPipelineSchema")
+
+
+
+@_attrs_define
+class ExtractionPipelineSchema:
+    """ Persisted extraction schema with at least one root property. Normalized for strict
+    structured outputs at save time.
+
+     """
+
+    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)
+        extraction_pipeline_schema = cls(
+        )
+
+
+        extraction_pipeline_schema.additional_properties = d
+        return extraction_pipeline_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