orq-ai-sdk 4.2.0rc28__py3-none-any.whl → 4.3.0rc7__py3-none-any.whl

orq_ai_sdk/models/parseop.py

@@ -76,6 +76,33 @@ class FastChunkerStrategy(BaseModel):
     forward_fallback: Optional[bool] = False
     r"""Search forward if no delimiter found in backward search window"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "metadata",
+                "return_type",
+                "target_size",
+                "delimiters",
+                "pattern",
+                "prefix",
+                "consecutive",
+                "forward_fallback",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 ParseChunkingRequestChunkingRequestReturnType = Literal[
     "chunks",
@@ -133,6 +160,30 @@ class AgenticChunkerStrategy(BaseModel):
     min_characters_per_chunk: Optional[int] = 24
     r"""Minimum characters allowed per chunk"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "metadata",
+                "return_type",
+                "chunk_size",
+                "candidate_size",
+                "min_characters_per_chunk",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 ParseChunkingRequestChunkingReturnType = Literal[
     "chunks",
@@ -223,6 +274,33 @@ class SemanticChunkerStrategy(BaseModel):
     similarity_window: Optional[int] = 1
     r"""Window size for similarity comparison"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "metadata",
+                "return_type",
+                "chunk_size",
+                "threshold",
+                "dimensions",
+                "max_tokens",
+                "mode",
+                "similarity_window",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 ParseChunkingRequestReturnType = Literal[
     "chunks",
@@ -275,6 +353,30 @@ class RecursiveChunkerStrategy(BaseModel):
     min_characters_per_chunk: Optional[int] = 24
     r"""Minimum characters allowed per chunk"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "metadata",
+                "return_type",
+                "chunk_size",
+                "separators",
+                "min_characters_per_chunk",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 ChunkingRequestReturnType = Literal[
     "chunks",
@@ -327,6 +429,30 @@ class SentenceChunkerStrategy(BaseModel):
     min_sentences_per_chunk: Optional[int] = 1
     r"""Minimum number of sentences per chunk"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "metadata",
+                "return_type",
+                "chunk_size",
+                "chunk_overlap",
+                "min_sentences_per_chunk",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 ReturnType = Literal[
     "chunks",
@@ -374,6 +500,24 @@ class TokenChunkerStrategy(BaseModel):
     chunk_overlap: Optional[int] = 0
     r"""Number of tokens to overlap between chunks"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["metadata", "return_type", "chunk_size", "chunk_overlap"]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 ParseChunkingRequestTypedDict = TypeAliasType(
     "ParseChunkingRequestTypedDict",
@@ -418,30 +562,14 @@ class ParseMetadata(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["start_index", "end_index", "token_count"]
-        null_default_fields = []
-
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
 
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
+            if val != UNSET_SENTINEL:
                 m[k] = val
 
         return m
@@ -464,6 +592,22 @@ class Chunks(BaseModel):
 
     metadata: Optional[ParseMetadata] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["metadata"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class ParseResponseBodyTypedDict(TypedDict):
     r"""Text successfully chunked"""

orq_ai_sdk/models/partdoneevent.py

@@ -1,8 +1,9 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from orq_ai_sdk.types import BaseModel
+from orq_ai_sdk.types import BaseModel, UNSET_SENTINEL
 import pydantic
+from pydantic import model_serializer
 from typing import Any, Dict, Literal, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -39,7 +40,7 @@ class PartReasoningPart(BaseModel):
     r"""The reasoning or thought process behind the response. Used for chain-of-thought or extended thinking."""
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "reasoning_01kexrj7d7wzdn32p7gcdbjn0g"
+        "reasoning_01kg2rzq2dydmjdrwpfgrfzpy3"
     )
     r"""Unique identifier for the part. Format: reasoning_{ulid} (e.g., reasoning_01hxyz...)"""
 
@@ -49,6 +50,22 @@ class PartReasoningPart(BaseModel):
     signature: Optional[str] = None
     r"""Optional cryptographic signature to verify the authenticity and integrity of the reasoning content"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["_id", "metadata", "signature"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class PartDoneEventDataTypedDict(TypedDict):
     part_id: str

orq_ai_sdk/models/post_v2_router_ocrop.py

@@ -0,0 +1,408 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from orq_ai_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from orq_ai_sdk.utils import get_discriminator
+from pydantic import Discriminator, Tag, model_serializer
+from typing import List, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+PostV2RouterOcrDocumentType = Literal["image_url",]
+
+
+class ImageURL2TypedDict(TypedDict):
+    r"""URL of the image to process"""
+
+    url: str
+    detail: NotRequired[str]
+
+
+class ImageURL2(BaseModel):
+    r"""URL of the image to process"""
+
+    url: str
+
+    detail: Optional[str] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["detail"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+DocumentImageURLTypedDict = TypeAliasType(
+    "DocumentImageURLTypedDict", Union[ImageURL2TypedDict, str]
+)
+
+
+DocumentImageURL = TypeAliasType("DocumentImageURL", Union[ImageURL2, str])
+
+
+class Document2TypedDict(TypedDict):
+    type: PostV2RouterOcrDocumentType
+    image_url: DocumentImageURLTypedDict
+
+
+class Document2(BaseModel):
+    type: PostV2RouterOcrDocumentType
+
+    image_url: DocumentImageURL
+
+
+DocumentType = Literal["document_url",]
+
+
+class Document1TypedDict(TypedDict):
+    type: DocumentType
+    document_url: str
+    r"""URL of the document to process"""
+    document_name: NotRequired[str]
+    r"""The name of the document"""
+
+
+class Document1(BaseModel):
+    type: DocumentType
+
+    document_url: str
+    r"""URL of the document to process"""
+
+    document_name: Optional[str] = None
+    r"""The name of the document"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["document_name"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+DocumentTypedDict = TypeAliasType(
+    "DocumentTypedDict", Union[Document2TypedDict, Document1TypedDict]
+)
+r"""Document to run OCR on. Can be a DocumentURLChunk or ImageURLChunk."""
+
+
+Document = Annotated[
+    Union[
+        Annotated[Document1, Tag("document_url")],
+        Annotated[Document2, Tag("image_url")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+r"""Document to run OCR on. Can be a DocumentURLChunk or ImageURLChunk."""
+
+
+class OcrSettingsTypedDict(TypedDict):
+    r"""Optional settings for the OCR run"""
+
+    include_image_base64: NotRequired[Nullable[bool]]
+    r"""Whether to include image Base64 in the response. Null for default."""
+    max_images_to_include: NotRequired[int]
+    r"""Maximum number of images to extract. Null for no limit."""
+    image_min_size: NotRequired[int]
+    r"""Minimum height and width of image to extract. Null for no minimum."""
+
+
+class OcrSettings(BaseModel):
+    r"""Optional settings for the OCR run"""
+
+    include_image_base64: OptionalNullable[bool] = UNSET
+    r"""Whether to include image Base64 in the response. Null for default."""
+
+    max_images_to_include: Optional[int] = None
+    r"""Maximum number of images to extract. Null for no limit."""
+
+    image_min_size: Optional[int] = None
+    r"""Minimum height and width of image to extract. Null for no minimum."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["include_image_base64", "max_images_to_include", "image_min_size"]
+        )
+        nullable_fields = set(["include_image_base64"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+class PostV2RouterOcrRequestBodyTypedDict(TypedDict):
+    r"""input"""
+
+    model: str
+    r"""ID of the model to use for OCR."""
+    document: DocumentTypedDict
+    r"""Document to run OCR on. Can be a DocumentURLChunk or ImageURLChunk."""
+    pages: NotRequired[Nullable[List[int]]]
+    r"""Specific pages to process. Can be a single number, range, or list. Starts from 0. Null for all pages."""
+    ocr_settings: NotRequired[OcrSettingsTypedDict]
+    r"""Optional settings for the OCR run"""
+
+
+class PostV2RouterOcrRequestBody(BaseModel):
+    r"""input"""
+
+    model: str
+    r"""ID of the model to use for OCR."""
+
+    document: Document
+    r"""Document to run OCR on. Can be a DocumentURLChunk or ImageURLChunk."""
+
+    pages: OptionalNullable[List[int]] = UNSET
+    r"""Specific pages to process. Can be a single number, range, or list. Starts from 0. Null for all pages."""
+
+    ocr_settings: Optional[OcrSettings] = None
+    r"""Optional settings for the OCR run"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["pages", "ocr_settings"])
+        nullable_fields = set(["pages"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+class PostV2RouterOcrImagesTypedDict(TypedDict):
+    id: str
+    r"""The id of the image"""
+    image_base64: NotRequired[Nullable[str]]
+    r"""The base64 encoded image"""
+
+
+class PostV2RouterOcrImages(BaseModel):
+    id: str
+    r"""The id of the image"""
+
+    image_base64: OptionalNullable[str] = UNSET
+    r"""The base64 encoded image"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["image_base64"])
+        nullable_fields = set(["image_base64"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+class DimensionsTypedDict(TypedDict):
+    r"""The dimensions of the PDF Page's screenshot image"""
+
+    dpi: int
+    r"""Dots per inch of the page-image"""
+    height: int
+    r"""Height of the image in pixels"""
+    width: int
+    r"""Width of the image in pixels"""
+
+
+class Dimensions(BaseModel):
+    r"""The dimensions of the PDF Page's screenshot image"""
+
+    dpi: int
+    r"""Dots per inch of the page-image"""
+
+    height: int
+    r"""Height of the image in pixels"""
+
+    width: int
+    r"""Width of the image in pixels"""
+
+
+class PagesTypedDict(TypedDict):
+    index: float
+    r"""The page index in a pdf document starting from 0"""
+    markdown: str
+    r"""The markdown string response of the page"""
+    images: List[PostV2RouterOcrImagesTypedDict]
+    dimensions: NotRequired[Nullable[DimensionsTypedDict]]
+    r"""The dimensions of the PDF Page's screenshot image"""
+
+
+class Pages(BaseModel):
+    index: float
+    r"""The page index in a pdf document starting from 0"""
+
+    markdown: str
+    r"""The markdown string response of the page"""
+
+    images: List[PostV2RouterOcrImages]
+
+    dimensions: OptionalNullable[Dimensions] = UNSET
+    r"""The dimensions of the PDF Page's screenshot image"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["dimensions"])
+        nullable_fields = set(["dimensions"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+PostV2RouterOcrUsageType = Literal["tokens",]
+
+
+class Usage2TypedDict(TypedDict):
+    r"""The usage information for the OCR run counted as tokens processed"""
+
+    type: PostV2RouterOcrUsageType
+    tokens_processed: int
+    r"""The number of tokens processed"""
+
+
+class Usage2(BaseModel):
+    r"""The usage information for the OCR run counted as tokens processed"""
+
+    type: PostV2RouterOcrUsageType
+
+    tokens_processed: int
+    r"""The number of tokens processed"""
+
+
+UsageType = Literal["pages",]
+
+
+class Usage1TypedDict(TypedDict):
+    r"""The usage information for the OCR run counted as pages processed"""
+
+    type: UsageType
+    pages_processed: int
+    r"""The number of pages processed"""
+
+
+class Usage1(BaseModel):
+    r"""The usage information for the OCR run counted as pages processed"""
+
+    type: UsageType
+
+    pages_processed: int
+    r"""The number of pages processed"""
+
+
+PostV2RouterOcrUsageTypedDict = TypeAliasType(
+    "PostV2RouterOcrUsageTypedDict", Union[Usage1TypedDict, Usage2TypedDict]
+)
+
+
+PostV2RouterOcrUsage = Annotated[
+    Union[Annotated[Usage1, Tag("pages")], Annotated[Usage2, Tag("tokens")]],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+class PostV2RouterOcrResponseBodyTypedDict(TypedDict):
+    r"""Represents an OCR response from the API."""
+
+    model: str
+    r"""ID of the model used for OCR."""
+    pages: List[PagesTypedDict]
+    usage: PostV2RouterOcrUsageTypedDict
+
+
+class PostV2RouterOcrResponseBody(BaseModel):
+    r"""Represents an OCR response from the API."""
+
+    model: str
+    r"""ID of the model used for OCR."""
+
+    pages: List[Pages]
+
+    usage: PostV2RouterOcrUsage