openparser-sdk 0.0.1__py3-none-any.whl

openparser/_generated/models/job_summary.py

@@ -0,0 +1,264 @@
+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.job_operation import JobOperation
+from ..models.job_status import JobStatus
+from ..models.ocr_output_format import OcrOutputFormat
+from ..types import UNSET, Unset
+from dateutil.parser import isoparse
+from typing import cast
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.job_failure import JobFailure
+
+
+
+
+
+T = TypeVar("T", bound="JobSummary")
+
+
+
+@_attrs_define
+class JobSummary:
+    """ Lightweight list row for `GET /jobs`. Omits result bodies, idempotency keys,
+    storage object keys, and provider cost fields.
+
+        Attributes:
+            id (str): Prefixed public id for an OCR job (`opj_…`). Example: opj_V1StGXR8_Z5jdHi6B-myT.
+            operation (JobOperation):
+            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):
+            page_count (int):
+            created_at (datetime.datetime):
+            updated_at (datetime.datetime):
+            has_result (bool): True when `GET /jobs/{id}` includes a terminal `result`.
+            url (str): Path-absolute job resource URL (for example `/jobs/{id}`).
+            pipeline_id (None | str): Snapshot of the saved extraction pipeline id at admit time, or `null` for parse jobs,
+                inline extract config, and other non-pipeline work.
+            pipeline_version (int | None): Snapshot of the saved extraction pipeline version at admit time, or `null` when
+                `pipeline_id` is `null`.
+            ocr_model (None | str | Unset):
+            llm_model (None | str | Unset):
+            error (JobFailure | Unset):
+            has_source (bool | Unset):
+     """
+
+    id: str
+    operation: JobOperation
+    status: JobStatus
+    output_format: OcrOutputFormat
+    page_count: int
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    has_result: bool
+    url: str
+    pipeline_id: None | str
+    pipeline_version: int | None
+    ocr_model: None | str | Unset = UNSET
+    llm_model: None | str | Unset = UNSET
+    error: JobFailure | Unset = UNSET
+    has_source: bool | Unset = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.job_failure import JobFailure
+        id = self.id
+
+        operation = self.operation.value
+
+        status = self.status.value
+
+        output_format = self.output_format.value
+
+        page_count = self.page_count
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        has_result = self.has_result
+
+        url = self.url
+
+        pipeline_id: None | str
+        pipeline_id = self.pipeline_id
+
+        pipeline_version: int | None
+        pipeline_version = self.pipeline_version
+
+        ocr_model: None | str | Unset
+        if isinstance(self.ocr_model, Unset):
+            ocr_model = UNSET
+        else:
+            ocr_model = self.ocr_model
+
+        llm_model: None | str | Unset
+        if isinstance(self.llm_model, Unset):
+            llm_model = UNSET
+        else:
+            llm_model = self.llm_model
+
+        error: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.error, Unset):
+            error = self.error.to_dict()
+
+        has_source = self.has_source
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "id": id,
+            "operation": operation,
+            "status": status,
+            "output_format": output_format,
+            "page_count": page_count,
+            "created_at": created_at,
+            "updated_at": updated_at,
+            "has_result": has_result,
+            "url": url,
+            "pipeline_id": pipeline_id,
+            "pipeline_version": pipeline_version,
+        })
+        if ocr_model is not UNSET:
+            field_dict["ocr_model"] = ocr_model
+        if llm_model is not UNSET:
+            field_dict["llm_model"] = llm_model
+        if error is not UNSET:
+            field_dict["error"] = error
+        if has_source is not UNSET:
+            field_dict["has_source"] = has_source
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.job_failure import JobFailure
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        operation = JobOperation(d.pop("operation"))
+
+
+
+
+        status = JobStatus(d.pop("status"))
+
+
+
+
+        output_format = OcrOutputFormat(d.pop("output_format"))
+
+
+
+
+        page_count = d.pop("page_count")
+
+        created_at = isoparse(d.pop("created_at"))
+
+
+
+
+        updated_at = isoparse(d.pop("updated_at"))
+
+
+
+
+        has_result = d.pop("has_result")
+
+        url = d.pop("url")
+
+        def _parse_pipeline_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        pipeline_id = _parse_pipeline_id(d.pop("pipeline_id"))
+
+
+        def _parse_pipeline_version(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        pipeline_version = _parse_pipeline_version(d.pop("pipeline_version"))
+
+
+        def _parse_ocr_model(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        ocr_model = _parse_ocr_model(d.pop("ocr_model", UNSET))
+
+
+        def _parse_llm_model(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        llm_model = _parse_llm_model(d.pop("llm_model", UNSET))
+
+
+        _error = d.pop("error", UNSET)
+        error: JobFailure | Unset
+        if isinstance(_error,  Unset):
+            error = UNSET
+        else:
+            error = JobFailure.from_dict(_error)
+
+
+
+
+        has_source = d.pop("has_source", UNSET)
+
+        job_summary = cls(
+            id=id,
+            operation=operation,
+            status=status,
+            output_format=output_format,
+            page_count=page_count,
+            created_at=created_at,
+            updated_at=updated_at,
+            has_result=has_result,
+            url=url,
+            pipeline_id=pipeline_id,
+            pipeline_version=pipeline_version,
+            ocr_model=ocr_model,
+            llm_model=llm_model,
+            error=error,
+            has_source=has_source,
+        )
+
+        return job_summary

openparser/_generated/models/json_schema_object.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="JsonSchemaObject")
+
+
+
+@_attrs_define
+class JsonSchemaObject:
+    """ Supported JSON Schema object describing the requested extraction output.
+
+     """
+
+    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)
+        json_schema_object = cls(
+        )
+
+
+        json_schema_object.additional_properties = d
+        return json_schema_object
+
+    @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/list_llm_models_mode.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class ListLlmModelsMode(str, Enum):
+    SEARCH = "search"
+    SUGGESTED = "suggested"
+
+    def __str__(self) -> str:
+        return str(self.value)

openparser/_generated/models/ocr_llm_model_catalog_entry.py

@@ -0,0 +1,257 @@
+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.ocr_llm_model_catalog_entry_recommendation import OcrLlmModelCatalogEntryRecommendation
+from dateutil.parser import isoparse
+from typing import cast
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.ocr_llm_model_catalog_entry_pricing import OcrLlmModelCatalogEntryPricing
+  from ..models.ocr_llm_model_catalog_entry_reasoning_type_0 import OcrLlmModelCatalogEntryReasoningType0
+
+
+
+
+
+T = TypeVar("T", bound="OcrLlmModelCatalogEntry")
+
+
+
+@_attrs_define
+class OcrLlmModelCatalogEntry:
+    """ One compatible extraction LLM. `recommendation` is `suggested` or `compatible`.
+    `certified_grounding` / `certified_suggest` (and compatibility aliases
+    `supports_grounding` / `supports_suggest`) gate heavier schemas. `pricing` is customer retail USD per 1M tokens
+    (`basis: customer_retail`) — the rates customers are charged, not raw provider list cost.
+
+        Attributes:
+            id (str):
+            label (str):
+            provider (str):
+            created_at (datetime.datetime | None):
+            context_length (int | None):
+            recommendation (OcrLlmModelCatalogEntryRecommendation):
+            is_default (bool):
+            certified_grounding (bool):
+            certified_suggest (bool):
+            supports_grounding (bool):
+            supports_suggest (bool):
+            pricing_known (bool):
+            reasoning (None | OcrLlmModelCatalogEntryReasoningType0):
+            deprecated_at (datetime.datetime | None):
+            pricing (OcrLlmModelCatalogEntryPricing):
+     """
+
+    id: str
+    label: str
+    provider: str
+    created_at: datetime.datetime | None
+    context_length: int | None
+    recommendation: OcrLlmModelCatalogEntryRecommendation
+    is_default: bool
+    certified_grounding: bool
+    certified_suggest: bool
+    supports_grounding: bool
+    supports_suggest: bool
+    pricing_known: bool
+    reasoning: None | OcrLlmModelCatalogEntryReasoningType0
+    deprecated_at: datetime.datetime | None
+    pricing: OcrLlmModelCatalogEntryPricing
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.ocr_llm_model_catalog_entry_pricing import OcrLlmModelCatalogEntryPricing
+        from ..models.ocr_llm_model_catalog_entry_reasoning_type_0 import OcrLlmModelCatalogEntryReasoningType0
+        id = self.id
+
+        label = self.label
+
+        provider = self.provider
+
+        created_at: None | str
+        if isinstance(self.created_at, datetime.datetime):
+            created_at = self.created_at.isoformat()
+        else:
+            created_at = self.created_at
+
+        context_length: int | None
+        context_length = self.context_length
+
+        recommendation = self.recommendation.value
+
+        is_default = self.is_default
+
+        certified_grounding = self.certified_grounding
+
+        certified_suggest = self.certified_suggest
+
+        supports_grounding = self.supports_grounding
+
+        supports_suggest = self.supports_suggest
+
+        pricing_known = self.pricing_known
+
+        reasoning: dict[str, Any] | None
+        if isinstance(self.reasoning, OcrLlmModelCatalogEntryReasoningType0):
+            reasoning = self.reasoning.to_dict()
+        else:
+            reasoning = self.reasoning
+
+        deprecated_at: None | str
+        if isinstance(self.deprecated_at, datetime.datetime):
+            deprecated_at = self.deprecated_at.isoformat()
+        else:
+            deprecated_at = self.deprecated_at
+
+        pricing = self.pricing.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "id": id,
+            "label": label,
+            "provider": provider,
+            "created_at": created_at,
+            "context_length": context_length,
+            "recommendation": recommendation,
+            "is_default": is_default,
+            "certified_grounding": certified_grounding,
+            "certified_suggest": certified_suggest,
+            "supports_grounding": supports_grounding,
+            "supports_suggest": supports_suggest,
+            "pricing_known": pricing_known,
+            "reasoning": reasoning,
+            "deprecated_at": deprecated_at,
+            "pricing": pricing,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.ocr_llm_model_catalog_entry_pricing import OcrLlmModelCatalogEntryPricing
+        from ..models.ocr_llm_model_catalog_entry_reasoning_type_0 import OcrLlmModelCatalogEntryReasoningType0
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        label = d.pop("label")
+
+        provider = d.pop("provider")
+
+        def _parse_created_at(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                created_at_type_0 = isoparse(data)
+
+
+
+                return created_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        created_at = _parse_created_at(d.pop("created_at"))
+
+
+        def _parse_context_length(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        context_length = _parse_context_length(d.pop("context_length"))
+
+
+        recommendation = OcrLlmModelCatalogEntryRecommendation(d.pop("recommendation"))
+
+
+
+
+        is_default = d.pop("is_default")
+
+        certified_grounding = d.pop("certified_grounding")
+
+        certified_suggest = d.pop("certified_suggest")
+
+        supports_grounding = d.pop("supports_grounding")
+
+        supports_suggest = d.pop("supports_suggest")
+
+        pricing_known = d.pop("pricing_known")
+
+        def _parse_reasoning(data: object) -> None | OcrLlmModelCatalogEntryReasoningType0:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                reasoning_type_0 = OcrLlmModelCatalogEntryReasoningType0.from_dict(data)
+
+
+
+                return reasoning_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | OcrLlmModelCatalogEntryReasoningType0, data)
+
+        reasoning = _parse_reasoning(d.pop("reasoning"))
+
+
+        def _parse_deprecated_at(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                deprecated_at_type_0 = isoparse(data)
+
+
+
+                return deprecated_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        deprecated_at = _parse_deprecated_at(d.pop("deprecated_at"))
+
+
+        pricing = OcrLlmModelCatalogEntryPricing.from_dict(d.pop("pricing"))
+
+
+
+
+        ocr_llm_model_catalog_entry = cls(
+            id=id,
+            label=label,
+            provider=provider,
+            created_at=created_at,
+            context_length=context_length,
+            recommendation=recommendation,
+            is_default=is_default,
+            certified_grounding=certified_grounding,
+            certified_suggest=certified_suggest,
+            supports_grounding=supports_grounding,
+            supports_suggest=supports_suggest,
+            pricing_known=pricing_known,
+            reasoning=reasoning,
+            deprecated_at=deprecated_at,
+            pricing=pricing,
+        )
+
+        return ocr_llm_model_catalog_entry

openparser/_generated/models/ocr_llm_model_catalog_entry_pricing.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 Literal, cast
+
+
+
+
+
+
+T = TypeVar("T", bound="OcrLlmModelCatalogEntryPricing")
+
+
+
+@_attrs_define
+class OcrLlmModelCatalogEntryPricing:
+    """
+        Attributes:
+            prompt_usd_per_1m (float):
+            completion_usd_per_1m (float):
+            basis (Literal['customer_retail']):
+     """
+
+    prompt_usd_per_1m: float
+    completion_usd_per_1m: float
+    basis: Literal['customer_retail']
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        prompt_usd_per_1m = self.prompt_usd_per_1m
+
+        completion_usd_per_1m = self.completion_usd_per_1m
+
+        basis = self.basis
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "prompt_usd_per_1m": prompt_usd_per_1m,
+            "completion_usd_per_1m": completion_usd_per_1m,
+            "basis": basis,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        prompt_usd_per_1m = d.pop("prompt_usd_per_1m")
+
+        completion_usd_per_1m = d.pop("completion_usd_per_1m")
+
+        basis = cast(Literal['customer_retail'] , d.pop("basis"))
+        if basis != 'customer_retail':
+            raise ValueError(f"basis must match const 'customer_retail', got '{basis}'")
+
+        ocr_llm_model_catalog_entry_pricing = cls(
+            prompt_usd_per_1m=prompt_usd_per_1m,
+            completion_usd_per_1m=completion_usd_per_1m,
+            basis=basis,
+        )
+
+        return ocr_llm_model_catalog_entry_pricing