chunkr-ai 0.1.0a6__py3-none-any.whl → 0.1.0a8__py3-none-any.whl

chunkr_ai/types/chunk_processing.py

@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["ChunkProcessing", "Tokenizer", "TokenizerEnum", "TokenizerString"]
+
+
+class TokenizerEnum(BaseModel):
+    enum: Literal["Word", "Cl100kBase", "XlmRobertaBase", "BertBaseUncased"] = FieldInfo(alias="Enum")
+    """Use one of the predefined tokenizer types"""
+
+
+class TokenizerString(BaseModel):
+    string: str = FieldInfo(alias="String")
+    """
+    Use any Hugging Face tokenizer by specifying its model ID Examples:
+    "Qwen/Qwen-tokenizer", "facebook/bart-large"
+    """
+
+
+Tokenizer: TypeAlias = Union[TokenizerEnum, TokenizerString]
+
+
+class ChunkProcessing(BaseModel):
+    ignore_headers_and_footers: Optional[bool] = None
+    """DEPRECATED: use `segment_processing.ignore` instead"""
+
+    target_length: Optional[int] = None
+    """The target number of words in each chunk.
+
+    If 0, each chunk will contain a single segment.
+    """
+
+    tokenizer: Optional[Tokenizer] = None
+    """The tokenizer to use for the chunking process."""

chunkr_ai/types/chunk_processing_param.py

@@ -0,0 +1,42 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["ChunkProcessingParam", "Tokenizer", "TokenizerEnum", "TokenizerString"]
+
+
+class TokenizerEnum(TypedDict, total=False):
+    enum: Required[
+        Annotated[Literal["Word", "Cl100kBase", "XlmRobertaBase", "BertBaseUncased"], PropertyInfo(alias="Enum")]
+    ]
+    """Use one of the predefined tokenizer types"""
+
+
+class TokenizerString(TypedDict, total=False):
+    string: Required[Annotated[str, PropertyInfo(alias="String")]]
+    """
+    Use any Hugging Face tokenizer by specifying its model ID Examples:
+    "Qwen/Qwen-tokenizer", "facebook/bart-large"
+    """
+
+
+Tokenizer: TypeAlias = Union[TokenizerEnum, TokenizerString]
+
+
+class ChunkProcessingParam(TypedDict, total=False):
+    ignore_headers_and_footers: Optional[bool]
+    """DEPRECATED: use `segment_processing.ignore` instead"""
+
+    target_length: int
+    """The target number of words in each chunk.
+
+    If 0, each chunk will contain a single segment.
+    """
+
+    tokenizer: Tokenizer
+    """The tokenizer to use for the chunking process."""

chunkr_ai/types/extract_configuration.py

@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .parse_configuration import ParseConfiguration
+
+__all__ = ["ExtractConfiguration"]
+
+
+class ExtractConfiguration(BaseModel):
+    schema_: object = FieldInfo(alias="schema")
+    """The schema to be used for the extraction."""
+
+    parse_configuration: Optional[ParseConfiguration] = None
+    """
+    Optional configuration for the `parse` task. Can not be used if `file` is a
+    `task_id`.
+    """
+
+    system_prompt: Optional[str] = None
+    """The system prompt to be used for the extraction."""

chunkr_ai/types/extract_output_response.py

@@ -0,0 +1,62 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["ExtractOutputResponse"]
+
+
+class ExtractOutputResponse(BaseModel):
+    citations: object
+    """Mirror of `results`; leaves are `Vec<Citation>` for the corresponding field
+
+    Example:
+
+    ```json
+    {
+      "field_name": [
+        {
+          "citation_id": "abc1234",
+          "citation_type": "Segment",
+          "bboxes": [
+            {
+              "left": 10,
+              "top": 20,
+              "width": 100,
+              "height": 18
+            }
+          ],
+          "content": "Example content",
+          "segment_id": "seg_001",
+          "segment_type": "Text",
+          "page_number": 1,
+          "page_height": 297,
+          "page_width": 210,
+          "ss_ranges": ["A1:C10"],
+          "ss_sheet_name": "Sheet1"
+        }
+      ]
+    }
+    ```
+    """
+
+    metrics: object
+    """
+    Mirror of `results`; leaves contain a `Metrics` object for the corresponding
+    field
+
+    Example:
+
+    ```json
+    { "field_name": { "confidence": "High" } }
+    ```
+    """
+
+    results: object
+    """JSON data that matches the provided schema
+
+    Example:
+
+    ```json
+    { "field_name": "value" }
+    ```
+    """

chunkr_ai/types/file_create_params.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from typing import Optional
 from typing_extensions import Required, TypedDict
 
 from .._types import FileTypes
@@ -13,5 +14,5 @@ class FileCreateParams(TypedDict, total=False):
     file: Required[FileTypes]
     """The file to upload"""
 
-    file_metadata: Required[str]
+    file_metadata: Optional[str]
     """Arbitrary JSON metadata associated with the file."""

chunkr_ai/types/file_info.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+
+__all__ = ["FileInfo"]
+
+
+class FileInfo(BaseModel):
+    url: str
+    """The presigned URL/Base64 encoded URL of the input file."""
+
+    mime_type: Optional[str] = None
+    """The MIME type of the file."""
+
+    name: Optional[str] = None
+    """The name of the file."""
+
+    page_count: Optional[int] = None
+    """The number of pages in the file."""

chunkr_ai/types/generation_config.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["GenerationConfig"]
+
+
+class GenerationConfig(BaseModel):
+    crop_image: Optional[Literal["All", "Auto"]] = None
+    """Controls the cropping strategy for an item (e.g. segment, chunk, etc.)
+
+    - `All` crops all images in the item
+    - `Auto` crops images only if required for post-processing
+    """
+
+    description: Optional[bool] = None
+    """Generate LLM descriptions for this segment"""
+
+    extended_context: Optional[bool] = None
+    """Use the full page image as context for LLM generation"""
+
+    format: Optional[Literal["Html", "Markdown"]] = None
+    """The format for the `content` field of a segment."""
+
+    strategy: Optional[Literal["LLM", "Auto", "Ignore"]] = None
+    """The strategy for generating the `content` field of a segment."""

chunkr_ai/types/generation_config_param.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["GenerationConfigParam"]
+
+
+class GenerationConfigParam(TypedDict, total=False):
+    crop_image: Optional[Literal["All", "Auto"]]
+    """Controls the cropping strategy for an item (e.g. segment, chunk, etc.)
+
+    - `All` crops all images in the item
+    - `Auto` crops images only if required for post-processing
+    """
+
+    description: Optional[bool]
+    """Generate LLM descriptions for this segment"""
+
+    extended_context: Optional[bool]
+    """Use the full page image as context for LLM generation"""
+
+    format: Optional[Literal["Html", "Markdown"]]
+    """The format for the `content` field of a segment."""
+
+    strategy: Optional[Literal["LLM", "Auto", "Ignore"]]
+    """The strategy for generating the `content` field of a segment."""

chunkr_ai/types/llm_processing.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["LlmProcessing", "FallbackStrategy", "FallbackStrategyModel"]
+
+
+class FallbackStrategyModel(BaseModel):
+    model: str = FieldInfo(alias="Model")
+    """Use a specific model as fallback"""
+
+
+FallbackStrategy: TypeAlias = Union[Literal["None", "Default"], FallbackStrategyModel]
+
+
+class LlmProcessing(BaseModel):
+    fallback_strategy: Optional[FallbackStrategy] = None
+    """The fallback strategy to use for the LLMs in the task."""
+
+    llm_model_id: Optional[str] = None
+    """The ID of the model to use for the task.
+
+    If not provided, the default model will be used. Please check the documentation
+    for the model you want to use.
+    """
+
+    max_completion_tokens: Optional[int] = None
+    """The maximum number of tokens to generate."""
+
+    temperature: Optional[float] = None
+    """The temperature to use for the LLM."""

chunkr_ai/types/llm_processing_param.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["LlmProcessingParam", "FallbackStrategy", "FallbackStrategyModel"]
+
+
+class FallbackStrategyModel(TypedDict, total=False):
+    model: Required[Annotated[str, PropertyInfo(alias="Model")]]
+    """Use a specific model as fallback"""
+
+
+FallbackStrategy: TypeAlias = Union[Literal["None", "Default"], FallbackStrategyModel]
+
+
+class LlmProcessingParam(TypedDict, total=False):
+    fallback_strategy: FallbackStrategy
+    """The fallback strategy to use for the LLMs in the task."""
+
+    llm_model_id: Optional[str]
+    """The ID of the model to use for the task.
+
+    If not provided, the default model will be used. Please check the documentation
+    for the model you want to use.
+    """
+
+    max_completion_tokens: Optional[int]
+    """The maximum number of tokens to generate."""
+
+    temperature: float
+    """The temperature to use for the LLM."""

chunkr_ai/types/ocr_result.py

@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+from .bounding_box import BoundingBox
+
+__all__ = ["OcrResult"]
+
+
+class OcrResult(BaseModel):
+    bbox: BoundingBox
+    """Bounding box for an item. It is used for segments and OCR results."""
+
+    text: str
+    """The recognized text of the OCR result."""
+
+    cell_ref: Optional[str] = None
+    """
+    Excel-style cell reference (e.g., "A1" or "A1:B2") when OCR originates from a
+    spreadsheet cell
+    """
+
+    confidence: Optional[float] = None
+    """The confidence score of the recognized text."""
+
+    ocr_id: Optional[str] = None
+    """The unique identifier for the OCR result."""

chunkr_ai/types/page.py

@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+
+__all__ = ["Page"]
+
+
+class Page(BaseModel):
+    image: str
+    """The presigned URL of the page/sheet image."""
+
+    page_height: float
+    """The number of pages in the file."""
+
+    page_number: int
+    """The number of pages in the file."""
+
+    page_width: float
+    """The number of pages in the file."""
+
+    dpi: Optional[float] = None
+    """DPI of the page/sheet. All cropped images are scaled to this DPI."""
+
+    ss_sheet_name: Optional[str] = None
+    """The name of the sheet containing the page. Only used for Spreadsheets."""

chunkr_ai/types/parse_configuration.py

@@ -0,0 +1,64 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .llm_processing import LlmProcessing
+from .chunk_processing import ChunkProcessing
+from .segment_processing import SegmentProcessing
+
+__all__ = ["ParseConfiguration"]
+
+
+class ParseConfiguration(BaseModel):
+    chunk_processing: Optional[ChunkProcessing] = None
+    """Controls the setting for the chunking and post-processing of each chunk."""
+
+    error_handling: Optional[Literal["Fail", "Continue"]] = None
+    """Controls how errors are handled during processing:
+
+    - `Fail`: Stops processing and fails the task when any error occurs
+    - `Continue`: Attempts to continue processing despite non-critical errors (eg.
+      LLM refusals etc.)
+    """
+
+    llm_processing: Optional[LlmProcessing] = None
+    """Controls the LLM used for the task."""
+
+    ocr_strategy: Optional[Literal["All", "Auto"]] = None
+    """Controls the Optical Character Recognition (OCR) strategy.
+
+    - `All`: Processes all pages with OCR. (Latency penalty: ~0.5 seconds per page)
+    - `Auto`: Selectively applies OCR only to pages with missing or low-quality
+      text. When text layer is present the bounding boxes from the text layer are
+      used.
+    """
+
+    pipeline: Optional[Literal["Azure", "Chunkr"]] = None
+
+    segment_processing: Optional[SegmentProcessing] = None
+    """Configuration for how each document segment is processed and formatted.
+
+    Each segment has sensible defaults, but you can override specific settings:
+
+    - `format`: Output as `Html` or `Markdown`
+    - `strategy`: `Auto` (rule-based), `LLM` (AI-generated), or `Ignore` (skip)
+    - `crop_image`: Whether to crop images to segment bounds
+    - `extended_context`: Use full page as context for LLM processing
+    - `description`: Generate descriptions for segments
+
+    **Defaults per segment type:** Check the documentation for more details.
+
+    Only specify the fields you want to change - everything else uses the defaults.
+    """
+
+    segmentation_strategy: Optional[Literal["LayoutAnalysis", "Page"]] = None
+    """Controls the segmentation strategy:
+
+    - `LayoutAnalysis`: Analyzes pages for layout elements (e.g., `Table`,
+      `Picture`, `Formula`, etc.) using bounding boxes. Provides fine-grained
+      segmentation and better chunking.
+    - `Page`: Treats each page as a single segment. Faster processing, but without
+      layout element detection and only simple chunking.
+    """

chunkr_ai/types/parse_configuration_param.py

@@ -0,0 +1,65 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, TypedDict
+
+from .llm_processing_param import LlmProcessingParam
+from .chunk_processing_param import ChunkProcessingParam
+from .segment_processing_param import SegmentProcessingParam
+
+__all__ = ["ParseConfigurationParam"]
+
+
+class ParseConfigurationParam(TypedDict, total=False):
+    chunk_processing: ChunkProcessingParam
+    """Controls the setting for the chunking and post-processing of each chunk."""
+
+    error_handling: Literal["Fail", "Continue"]
+    """Controls how errors are handled during processing:
+
+    - `Fail`: Stops processing and fails the task when any error occurs
+    - `Continue`: Attempts to continue processing despite non-critical errors (eg.
+      LLM refusals etc.)
+    """
+
+    llm_processing: LlmProcessingParam
+    """Controls the LLM used for the task."""
+
+    ocr_strategy: Literal["All", "Auto"]
+    """Controls the Optical Character Recognition (OCR) strategy.
+
+    - `All`: Processes all pages with OCR. (Latency penalty: ~0.5 seconds per page)
+    - `Auto`: Selectively applies OCR only to pages with missing or low-quality
+      text. When text layer is present the bounding boxes from the text layer are
+      used.
+    """
+
+    pipeline: Literal["Azure", "Chunkr"]
+
+    segment_processing: Optional[SegmentProcessingParam]
+    """Configuration for how each document segment is processed and formatted.
+
+    Each segment has sensible defaults, but you can override specific settings:
+
+    - `format`: Output as `Html` or `Markdown`
+    - `strategy`: `Auto` (rule-based), `LLM` (AI-generated), or `Ignore` (skip)
+    - `crop_image`: Whether to crop images to segment bounds
+    - `extended_context`: Use full page as context for LLM processing
+    - `description`: Generate descriptions for segments
+
+    **Defaults per segment type:** Check the documentation for more details.
+
+    Only specify the fields you want to change - everything else uses the defaults.
+    """
+
+    segmentation_strategy: Literal["LayoutAnalysis", "Page"]
+    """Controls the segmentation strategy:
+
+    - `LayoutAnalysis`: Analyzes pages for layout elements (e.g., `Table`,
+      `Picture`, `Formula`, etc.) using bounding boxes. Provides fine-grained
+      segmentation and better chunking.
+    - `Page`: Treats each page as a single segment. Faster processing, but without
+      layout element detection and only simple chunking.
+    """

chunkr_ai/types/parse_output_response.py

@@ -0,0 +1,29 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from .page import Page
+from .chunk import Chunk
+from .._models import BaseModel
+
+__all__ = ["ParseOutputResponse"]
+
+
+class ParseOutputResponse(BaseModel):
+    chunks: List[Chunk]
+    """Collection of document chunks, where each chunk contains one or more segments"""
+
+    file_name: Optional[str] = None
+    """The name of the file. Deprecated use `file_info.name` instead."""
+
+    mime_type: Optional[str] = None
+    """The MIME type of the file. Deprecated use `file_info.mime_type` instead."""
+
+    page_count: Optional[int] = None
+    """The number of pages in the file. Deprecated use `file_info.page_count` instead."""
+
+    pages: Optional[List[Page]] = None
+    """The pages of the file. Includes the image and metadata for each page."""
+
+    pdf_url: Optional[str] = None
+    """The presigned URL of the PDF file."""

chunkr_ai/types/segment.py

@@ -0,0 +1,109 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from .cell import Cell
+from .._models import BaseModel
+from .ocr_result import OcrResult
+from .bounding_box import BoundingBox
+
+__all__ = ["Segment"]
+
+
+class Segment(BaseModel):
+    bbox: BoundingBox
+    """Bounding box for an item. It is used for segments and OCR results."""
+
+    page_height: float
+    """Height of the page/sheet containing the segment."""
+
+    page_number: int
+    """Page number/Sheet number of the segment."""
+
+    page_width: float
+    """Width of the page/sheet containing the segment."""
+
+    segment_id: str
+    """Unique identifier for the segment."""
+
+    segment_type: Literal[
+        "Caption",
+        "Footnote",
+        "Formula",
+        "ListItem",
+        "Page",
+        "PageFooter",
+        "PageHeader",
+        "Picture",
+        "SectionHeader",
+        "Table",
+        "Text",
+        "Title",
+    ]
+    """
+    All the possible types for a segment. Note: Different configurations will
+    produce different types. Please refer to the documentation for more information.
+    """
+
+    confidence: Optional[float] = None
+    """Confidence score of the layout analysis model"""
+
+    content: Optional[str] = None
+    """
+    Content of the segment, will be either HTML or Markdown, depending on format
+    chosen.
+    """
+
+    description: Optional[str] = None
+    """Description of the segment, generated by the LLM."""
+
+    embed: Optional[str] = None
+    """Embeddable content of the segment."""
+
+    image: Optional[str] = None
+    """Presigned URL to the image of the segment."""
+
+    ocr: Optional[List[OcrResult]] = None
+    """OCR results for the segment."""
+
+    segment_length: Optional[int] = None
+    """Length of the segment in tokens."""
+
+    ss_cells: Optional[List[Cell]] = None
+    """Cells of the segment. Only used for Spreadsheets."""
+
+    ss_header_bbox: Optional[BoundingBox] = None
+    """Bounding box of the header of the segment, if found.
+
+    Only used for Spreadsheets.
+    """
+
+    ss_header_ocr: Optional[List[OcrResult]] = None
+    """OCR results of the header of the segment, if found. Only used for Spreadsheets."""
+
+    ss_header_range: Optional[str] = None
+    """
+    Header range of the segment, if found. The header can have overlap with the
+    `segment.range` if the table contains the header, if the header is located in a
+    different sheet, the header range will have no overlap with the `segment.range`.
+    Only used for Spreadsheets.
+    """
+
+    ss_header_text: Optional[str] = None
+    """Text content of the header of the segment, if found.
+
+    Only used for Spreadsheets.
+    """
+
+    ss_range: Optional[str] = None
+    """Range of the segment in Excel notation (e.g., A1:B5).
+
+    Only used for Spreadsheets.
+    """
+
+    ss_sheet_name: Optional[str] = None
+    """Name of the sheet containing the segment. Only used for Spreadsheets."""
+
+    text: Optional[str] = None
+    """Text content of the segment. Calculated by the OCR results."""