retab 0.0.68__py3-none-any.whl → 0.0.70__py3-none-any.whl

retab/resources/extractions/client.py

@@ -0,0 +1,288 @@
+import json
+from datetime import datetime
+from typing import Any, Dict, List, Literal
+
+from ..._resource import AsyncAPIResource, SyncAPIResource
+from ...types.standards import PreparedRequest
+from ...types.pagination import PaginatedList, PaginationOrder
+from ...types.extractions.types import HumanReviewStatus
+
+class ExtractionsMixin:
+    def prepare_list(
+        self,
+        before: str | None = None,
+        after: str | None = None,
+        limit: int = 10,
+        order: PaginationOrder = "desc",
+        origin_dot_type: str | None = None,
+        origin_dot_id: str | None = None,
+        from_date: datetime | None = None,
+        to_date: datetime | None = None, 
+        human_review_status: HumanReviewStatus | None = None,
+        metadata: Dict[str, str] | None = None,
+        **extra_params: Any,
+    ) -> PreparedRequest:
+        """Prepare a request to list extractions with pagination and filtering."""
+        params = {
+            "before": before,
+            "after": after,
+            "limit": limit,
+            "order": order,
+            "origin_dot_type": origin_dot_type,
+            "origin_dot_id": origin_dot_id,
+            "from_date": from_date.isoformat() if from_date else None,
+            "to_date": to_date.isoformat() if to_date else None,
+            "human_review_status": human_review_status,
+            # Note: metadata must be JSON-serialized as the backend expects a JSON string
+            "metadata": json.dumps(metadata) if metadata else None,
+        }
+        if extra_params:
+            params.update(extra_params)
+        # Remove None values
+        params = {k: v for k, v in params.items() if v is not None}
+        return PreparedRequest(method="GET", url="/v1/extractions", params=params)
+
+    def prepare_download(
+        self,
+        order: Literal["asc", "desc"] = "desc",
+        origin_dot_id: str | None = None,
+        from_date: datetime | None = None,
+        to_date: datetime | None = None,
+        human_review_status: HumanReviewStatus | None = None,
+        metadata: Dict[str, str] | None = None,
+        format: Literal["jsonl", "csv", "xlsx"] = "jsonl",
+        **extra_params: Any,
+    ) -> PreparedRequest:
+        """Prepare a request to download extractions in various formats."""
+        params = {
+            "order": order,
+            "origin_dot_id": origin_dot_id,
+            "from_date": from_date.isoformat() if from_date else None,
+            "to_date": to_date.isoformat() if to_date else None,
+            "human_review_status": human_review_status,
+            # Note: metadata must be JSON-serialized as the backend expects a JSON string
+            "metadata": json.dumps(metadata) if metadata else None,
+            "format": format,
+        }
+        if extra_params:
+            params.update(extra_params)
+        params = {k: v for k, v in params.items() if v is not None}
+        return PreparedRequest(method="GET", url="/v1/extractions/download", params=params)
+
+    def prepare_update(
+        self,
+        extraction_id: str,
+        predictions: dict[str, Any] | None = None,
+        human_review_status: HumanReviewStatus | None = None,
+        json_schema: dict[str, Any] | None = None,
+        inference_settings: dict[str, Any] | None = None,
+        **extra_body: Any,
+    ) -> PreparedRequest:
+        """Prepare a request to update an extraction."""
+        data: dict[str, Any] = {}
+        if predictions is not None:
+            data["predictions"] = predictions
+        if human_review_status is not None:
+            data["human_review_status"] = human_review_status
+        if json_schema is not None:
+            data["json_schema"] = json_schema
+        if inference_settings is not None:
+            data["inference_settings"] = inference_settings
+        if extra_body:
+            data.update(extra_body)
+        return PreparedRequest(method="PATCH", url=f"/v1/extractions/{extraction_id}", data=data)
+
+    def prepare_get(self, extraction_id: str) -> PreparedRequest:
+        """Prepare a request to get an extraction by ID."""
+        return PreparedRequest(method="GET", url=f"/v1/extractions/{extraction_id}")
+
+    def prepare_delete(self, extraction_id: str) -> PreparedRequest:
+        """Prepare a request to delete an extraction by ID."""
+        return PreparedRequest(method="DELETE", url=f"/v1/extractions/{extraction_id}")
+
+class Extractions(SyncAPIResource, ExtractionsMixin):
+    """Extractions API wrapper"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def list(
+        self,
+        before: str | None = None,
+        after: str | None = None,
+        limit: int = 10,
+        order: PaginationOrder = "desc",
+        origin_dot_type: str | None = None,
+        origin_dot_id: str | None = None,
+        from_date: datetime | None = None,
+        to_date: datetime | None = None,
+        human_review_status: HumanReviewStatus | None = None,
+        metadata: Dict[str, str] | None = None,
+        **extra_params: Any,
+    ) -> PaginatedList:
+        """List extractions with pagination and filtering."""
+        request = self.prepare_list(
+            before=before,
+            after=after,
+            limit=limit,
+            order=order,
+            origin_dot_type=origin_dot_type,
+            origin_dot_id=origin_dot_id,
+            from_date=from_date,
+            to_date=to_date,
+            human_review_status=human_review_status,
+            metadata=metadata,
+            **extra_params,
+        )
+        response = self._client._prepared_request(request)
+        return PaginatedList(**response)
+
+    
+    def download(
+        self,
+        order: Literal["asc", "desc"] = "desc",
+        origin_dot_id: str | None = None,
+        from_date: datetime | None = None,
+        to_date: datetime | None = None,
+        human_review_status: HumanReviewStatus | None = None,
+        metadata: Dict[str, str] | None = None,
+        format: Literal["jsonl", "csv", "xlsx"] = "jsonl",
+        **extra_params: Any,
+    ) -> dict[str, Any]:
+        """Download extractions in various formats. Returns download_url, filename, and expires_at."""
+        request = self.prepare_download(
+            order=order,
+            origin_dot_id=origin_dot_id,
+            from_date=from_date,
+            to_date=to_date,
+            human_review_status=human_review_status,
+            metadata=metadata,
+            format=format,
+            **extra_params,
+        )
+        return self._client._prepared_request(request)
+
+   
+    def update(
+        self,
+        extraction_id: str,
+        predictions: dict[str, Any] | None = None,
+        human_review_status: HumanReviewStatus | None = None,
+        json_schema: dict[str, Any] | None = None,
+        inference_settings: dict[str, Any] | None = None,
+        **extra_body: Any,
+    ) -> dict[str, Any]:
+        """Update an extraction."""
+        request = self.prepare_update(
+            extraction_id=extraction_id,
+            predictions=predictions,
+            human_review_status=human_review_status,
+            json_schema=json_schema,
+            inference_settings=inference_settings,
+            **extra_body,
+        )
+        response = self._client._prepared_request(request)
+        return response
+
+    def get(self, extraction_id: str) -> dict[str, Any]:
+        """Get an extraction by ID."""
+        request = self.prepare_get(extraction_id)
+        return self._client._prepared_request(request)
+
+    def delete(self, extraction_id: str) -> None:
+        """Delete an extraction by ID."""
+        request = self.prepare_delete(extraction_id)
+        self._client._prepared_request(request)
+
+
+class AsyncExtractions(AsyncAPIResource, ExtractionsMixin):
+    """Async Extractions API wrapper"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    async def list(
+        self,
+        before: str | None = None,
+        after: str | None = None,
+        limit: int = 10,
+        order: PaginationOrder = "desc",
+        origin_dot_type: str | None = None,
+        origin_dot_id: str | None = None,
+        from_date: datetime | None = None,
+        to_date: datetime | None = None,
+        human_review_status: HumanReviewStatus | None = None,
+        metadata: Dict[str, str] | None = None,
+        **extra_params: Any,
+    ) -> PaginatedList:
+        """List extractions with pagination and filtering."""
+        request = self.prepare_list(
+            before=before,
+            after=after,
+            limit=limit,
+            order=order,
+            origin_dot_type=origin_dot_type,
+            origin_dot_id=origin_dot_id,
+            from_date=from_date,
+            to_date=to_date,
+            human_review_status=human_review_status,
+            metadata=metadata,
+            **extra_params,
+        )
+        response = await self._client._prepared_request(request)
+        return PaginatedList(**response)
+
+    async def download(
+        self,
+        order: Literal["asc", "desc"] = "desc",
+        origin_dot_id: str | None = None,
+        from_date: datetime | None = None,
+        to_date: datetime | None = None,
+        human_review_status: HumanReviewStatus | None = None,
+        metadata: Dict[str, str] | None = None,
+        format: Literal["jsonl", "csv", "xlsx"] = "jsonl",
+        **extra_params: Any,
+    ) -> dict[str, Any]:
+        """Download extractions in various formats. Returns download_url, filename, and expires_at."""
+        request = self.prepare_download(
+            order=order,
+            origin_dot_id=origin_dot_id,
+            from_date=from_date,
+            to_date=to_date,
+            human_review_status=human_review_status,
+            metadata=metadata,
+            format=format,
+            **extra_params,
+        )
+        return await self._client._prepared_request(request)
+
+    async def update(
+        self,
+        extraction_id: str,
+        predictions: dict[str, Any] | None = None,
+        human_review_status: HumanReviewStatus | None = None,
+        json_schema: dict[str, Any] | None = None,
+        inference_settings: dict[str, Any] | None = None,
+        **extra_body: Any,
+    ) -> dict[str, Any]:
+        """Update an extraction."""
+        request = self.prepare_update(
+            extraction_id=extraction_id,
+            predictions=predictions,
+            human_review_status=human_review_status,
+            json_schema=json_schema,
+            inference_settings=inference_settings,
+            **extra_body,
+        )
+        response = await self._client._prepared_request(request)
+        return response
+
+    async def get(self, extraction_id: str) -> dict[str, Any]:
+        """Get an extraction by ID."""
+        request = self.prepare_get(extraction_id)
+        return await self._client._prepared_request(request)
+
+    async def delete(self, extraction_id: str) -> None:
+        """Delete an extraction by ID."""
+        request = self.prepare_delete(extraction_id)
+        await self._client._prepared_request(request)

retab/resources/projects/client.py

@@ -1,4 +1,5 @@
 import base64
+import json
 from io import IOBase
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Sequence
@@ -89,6 +90,8 @@ class ProjectsMixin:
         n_consensus: int | None = None,
         seed: int | None = None,
         store: bool = True,
+        metadata: Dict[str, str] | None = None,
+        extraction_id: str | None = None,
         **extra_form: Any,
     ) -> PreparedRequest:
         """Prepare a request to extract documents from a project.
@@ -104,7 +107,7 @@ class ProjectsMixin:
             n_consensus: Optional number of consensus extractions
             store: Whether to store the results
             seed: Optional seed for reproducibility
-            store: Whether to store the results
+            metadata: User-defined metadata for the extraction
 
         Returns:
             PreparedRequest: The prepared request
@@ -117,6 +120,7 @@ class ProjectsMixin:
             raise ValueError("Provide either 'document' (single) or 'documents' (multiple), not both")
 
         # Prepare form data parameters
+        # Note: metadata must be JSON-serialized since httpx multipart forms only accept primitive types
         form_data = {
             "model": model,
             "temperature": temperature,
@@ -124,6 +128,8 @@ class ProjectsMixin:
             "n_consensus": n_consensus,
             "seed": seed,
             "store": store,
+            "metadata": json.dumps(metadata) if metadata else None,
+            "extraction_id": extraction_id,
         }
         if extra_form:
             form_data.update(extra_form)

retab/resources/schemas.py

@@ -9,7 +9,6 @@ from .._resource import AsyncAPIResource, SyncAPIResource
 from ..utils.mime import prepare_mime_document_list
 from ..types.mime import MIMEData
 from ..types.schemas.generate import GenerateSchemaRequest
-from ..types.browser_canvas import BrowserCanvas
 from ..types.standards import PreparedRequest, FieldUnset
 
 
@@ -22,7 +21,6 @@ class SchemasMixin:
         temperature: float = FieldUnset,
         reasoning_effort: ChatCompletionReasoningEffort = FieldUnset,
         image_resolution_dpi: int = FieldUnset,
-        browser_canvas: BrowserCanvas = FieldUnset,
         **extra_body: Any,
     ) -> PreparedRequest:
         mime_documents = prepare_mime_document_list(documents)
@@ -40,8 +38,6 @@ class SchemasMixin:
             body["reasoning_effort"] = reasoning_effort
         if image_resolution_dpi is not FieldUnset:
             body["image_resolution_dpi"] = image_resolution_dpi
-        if browser_canvas is not FieldUnset:
-            body["browser_canvas"] = browser_canvas
         if extra_body:
             body.update(extra_body)
 
@@ -59,7 +55,6 @@ class Schemas(SyncAPIResource, SchemasMixin):
         temperature: float = FieldUnset,
         reasoning_effort: ChatCompletionReasoningEffort = FieldUnset,
         image_resolution_dpi: int = FieldUnset,
-        browser_canvas: BrowserCanvas = FieldUnset,
         **extra_body: Any,
     ) -> dict[str, Any]:
         """
@@ -84,7 +79,6 @@ class Schemas(SyncAPIResource, SchemasMixin):
             temperature=temperature,
             reasoning_effort=reasoning_effort,
             image_resolution_dpi=image_resolution_dpi,
-            browser_canvas=browser_canvas,
             **extra_body,
         )
         response = self._client._prepared_request(prepared_request)
@@ -100,7 +94,6 @@ class AsyncSchemas(AsyncAPIResource, SchemasMixin):
         temperature: float = FieldUnset,
         reasoning_effort: ChatCompletionReasoningEffort = FieldUnset,
         image_resolution_dpi: int = FieldUnset,
-        browser_canvas: BrowserCanvas = FieldUnset,
         **extra_body: Any,
     ) -> dict[str, Any]:
         """
@@ -125,7 +118,6 @@ class AsyncSchemas(AsyncAPIResource, SchemasMixin):
             temperature=temperature,
             reasoning_effort=reasoning_effort,
             image_resolution_dpi=image_resolution_dpi,
-            browser_canvas=browser_canvas,
             **extra_body,
         )
         response = await self._client._prepared_request(prepared_request)

retab/types/documents/create_messages.py

@@ -9,7 +9,6 @@ from pydantic import BaseModel, ConfigDict, Field, computed_field
 from ...utils.display import count_image_tokens, count_text_tokens
 from ..chat import ChatCompletionRetabMessage
 from ..mime import MIMEData
-from ..browser_canvas import BrowserCanvas
 MediaType = Literal["image/jpeg", "image/png", "image/gif", "image/webp"]
 
 
@@ -23,9 +22,6 @@ class DocumentCreateMessageRequest(BaseModel):
     model_config = ConfigDict(extra="ignore")
     document: MIMEData = Field(description="The document to load.")
     image_resolution_dpi: int = Field(default=192, description="Resolution of the image sent to the LLM")
-    browser_canvas: BrowserCanvas = Field(
-        default="A4", description="Sets the size of the browser canvas for rendering documents in browser-based processing. Choose a size that matches the document type."
-    )
     model: str = Field(default="gemini-2.5-flash", description="The model to use for the document.")
 
 class DocumentCreateInputRequest(DocumentCreateMessageRequest):
@@ -55,11 +51,12 @@ class DocumentMessage(BaseModel):
         for msg in self.messages:
             role = msg.get("role", "user")
             msg_tokens = 0
+            content = msg.get("content")
 
-            if isinstance(msg["content"], str):
-                msg_tokens = count_text_tokens(msg["content"])
-            elif isinstance(msg["content"], list):
-                for content_item in msg["content"]:
+            if isinstance(content, str):
+                msg_tokens = count_text_tokens(content)
+            elif isinstance(content, list):
+                for content_item in content:
                     if isinstance(content_item, str):
                         msg_tokens += count_text_tokens(content_item)
                     elif isinstance(content_item, dict):
@@ -104,11 +101,12 @@ class DocumentMessage(BaseModel):
         results: list[str | PIL.Image.Image] = []
 
         for msg in self.messages:
-            if isinstance(msg["content"], str):
-                results.append(msg["content"])
+            content = msg.get("content")
+            if isinstance(content, str):
+                results.append(content)
                 continue
-            assert isinstance(msg["content"], list), "content must be a list or a string"
-            for content_item in msg["content"]:
+            assert isinstance(content, list), "content must be a list or a string"
+            for content_item in content:
                 if isinstance(content_item, str):
                     results.append(content_item)
                 else:

retab/types/documents/extract.py

@@ -1,8 +1,7 @@
 import base64
-import datetime
 import json
 from typing import Any, Literal, Optional
-
+import datetime
 
 from openai.types.chat import ChatCompletionMessageParam
 from openai.types.chat.chat_completion import ChatCompletion
@@ -17,14 +16,13 @@ from openai.types.chat.parsed_chat_completion import ParsedChatCompletionMessage
 from pydantic import BaseModel, ConfigDict, Field, ValidationInfo, field_validator, model_validator
 from ..chat import ChatCompletionRetabMessage
 from ..mime import MIMEData
-from ..standards import ErrorDetail, StreamingBaseModel
+from ..standards import StreamingBaseModel
 from ...utils.json_schema import filter_auxiliary_fields_json, convert_basemodel_to_partial_basemodel, convert_json_schema_to_basemodel, unflatten_dict
 from ..modality import Modality
 
 class DocumentExtractRequest(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True, extra="ignore")
-    document: MIMEData = Field(default=None, description="Document to be analyzed", deprecated=True)  # type: ignore
-    documents: list[MIMEData] = Field(default=[], description="Documents to be analyzed (preferred over document)")
+    document: MIMEData = Field(..., description="Document to be analyzed")
     image_resolution_dpi: int = Field(default=192, description="Resolution of the image sent to the LLM", ge=96, le=300)
     model: str = Field(..., description="Model used for chat completion")
     json_schema: dict[str, Any] = Field(..., description="JSON schema format used to validate the output data.")
@@ -37,9 +35,10 @@ class DocumentExtractRequest(BaseModel):
     stream: bool = Field(default=False, description="If true, the extraction will be streamed to the user using the active WebSocket connection")
     seed: int | None = Field(default=None, description="Seed for the random number generator. If not provided, a random seed will be generated.", examples=[None])
     store: bool = Field(default=True, description="If true, the extraction will be stored in the database")
-    need_validation: bool = Field(default=False, description="If true, the extraction will be validated against the schema")
     modality: Modality = Field(default="native", description="The modality of the document to be analyzed")
     parallel_ocr_keys: Optional[dict[str, str]] = Field(default=None, description="If set, keys to be used for the extraction of long lists of data using Parallel OCR", examples=[{"properties": "ID", "products": "identity.id"}])
+    metadata: dict[str, str] = Field(default_factory=dict, description="User-defined metadata to associate with this extraction")
+    extraction_id: Optional[str] = Field(default=None, description="Extraction ID to use for this extraction. If not provided, a new ID will be generated.")
 
     # Add a model validator that rejects n_consensus > 1 if temperature is 0
     @field_validator("n_consensus")
@@ -48,28 +47,6 @@ class DocumentExtractRequest(BaseModel):
             raise ValueError("n_consensus greater than 1 but temperature is 0")
         return v
 
-    @model_validator(mode="before")
-    def validate_document_or_documents(cls, data: Any) -> Any:
-        # Handle both dict and model instance cases
-        if isinstance(data, dict):
-            if data.get("documents"):  # If documents is set, it has higher priority than document
-                data["document"] = data["documents"][0]
-            elif data.get("document"):
-                data["documents"] = [data["document"]]
-            else:
-                raise ValueError("document or documents must be provided")
-        else:
-            # Handle model instance case
-            document = getattr(data, "document", None)
-            documents = getattr(data, "documents", None)
-            if documents:
-                setattr(data, "document", documents[0])
-            elif document:
-                setattr(data, "documents", [document])
-            else:
-                raise ValueError("document or documents must be provided")
-        return data
-
 
 class ConsensusModel(BaseModel):
     model: str = Field(description="Model name")
@@ -79,31 +56,16 @@ class ConsensusModel(BaseModel):
     )
 
 
-# For location of fields in the document (OCR)
-class FieldLocation(BaseModel):
-    label: str = Field(..., description="The label of the field")
-    value: str = Field(..., description="The extracted value of the field")
-    quote: str = Field(..., description="The quote of the field (verbatim from the document)")
-    file_id: str | None = Field(default=None, description="The ID of the file")
-    page: int | None = Field(default=None, description="The page number of the field (1-indexed)")
-    bbox_normalized: tuple[float, float, float, float] | None = Field(default=None, description="The normalized bounding box of the field")
-    score: float | None = Field(default=None, description="The score of the field")
-    match_level: Literal["token", "line", "block", "token-windows"] | None = Field(default=None, description="The level of the match (token, line, block, token-windows)")
-
-
 class RetabParsedChoice(ParsedChoice):
     # Adaptable ParsedChoice that allows None for the finish_reason
     finish_reason: Literal["stop", "length", "tool_calls", "content_filter", "function_call"] | None = None  # type: ignore
-    field_locations: dict[str, FieldLocation] | None = Field(default=None, description="The locations of the fields in the document, if available")
     key_mapping: dict[str, Optional[str]] | None = Field(default=None, description="Mapping of consensus keys to original model keys")
 
 
 LikelihoodsSource = Literal["consensus", "log_probs"]
 
-
 class RetabParsedChatCompletion(ParsedChatCompletion):
     model_config = ConfigDict(arbitrary_types_allowed=True, extra="ignore")
-    
     extraction_id: str | None = None
     choices: list[RetabParsedChoice]  # type: ignore
     # Additional metadata fields
@@ -111,24 +73,8 @@ class RetabParsedChatCompletion(ParsedChatCompletion):
         default=None, description="Object defining the uncertainties of the fields extracted when using consensus. Follows the same structure as the extraction object."
     )
 
-    requires_human_review: bool = Field(default=False, description="If true, the extraction requires human review")
-    schema_validation_error: ErrorDetail | None = None
-    # Timestamps
-    request_at: datetime.datetime | None = Field(default=None, description="Timestamp of the request")
-    first_token_at: datetime.datetime | None = Field(default=None, description="Timestamp of the first token of the document. If non-streaming, set to last_token_at")
-    last_token_at: datetime.datetime | None = Field(default=None, description="Timestamp of the last token of the document")
-
- 
+    requires_human_review: bool = Field(default=False, description="Flag indicating if the extraction requires human review")
 
-
-class UiResponse(Response):
-    extraction_id: str | None = None
-    # Additional metadata fields (UIForm)
-    likelihoods: Optional[dict[str, Any]] = Field(
-        default=None, description="Object defining the uncertainties of the fields extracted when using consensus. Follows the same structure as the extraction object."
-    )
-    schema_validation_error: ErrorDetail | None = None
-    # Timestamps
     request_at: datetime.datetime | None = Field(default=None, description="Timestamp of the request")
     first_token_at: datetime.datetime | None = Field(default=None, description="Timestamp of the first token of the document. If non-streaming, set to last_token_at")
     last_token_at: datetime.datetime | None = Field(default=None, description="Timestamp of the last token of the document")
@@ -187,7 +133,6 @@ class LogExtractionRequest(BaseModel):
 
 
 class LogExtractionResponse(BaseModel):
-    extraction_id: str | None = None  # None only in case of error
     status: Literal["success", "error"]
     error_message: str | None = None
 
@@ -208,7 +153,6 @@ class RetabParsedChoiceDeltaChunk(ChoiceDeltaChunk):
     flat_likelihoods: dict[str, float] = {}
     flat_parsed: dict[str, Any] = {}
     flat_deleted_keys: list[str] = []
-    field_locations: dict[str, list[FieldLocation]] | None = Field(default=None, description="The locations of the fields in the document, if available")
     is_valid_json: bool = False
     key_mapping: dict[str, Optional[str]] | None = Field(default=None, description="Mapping of consensus keys to original model keys")
 
@@ -218,16 +162,13 @@ class RetabParsedChoiceChunk(ChoiceChunk):
 
 
 class RetabParsedChatCompletionChunk(StreamingBaseModel, ChatCompletionChunk):
-    extraction_id: str | None = None
     choices: list[RetabParsedChoiceChunk]  # type: ignore
-    schema_validation_error: ErrorDetail | None = None
-    # Timestamps
+
+    extraction_id: str | None = None
     request_at: datetime.datetime | None = Field(default=None, description="Timestamp of the request")
     first_token_at: datetime.datetime | None = Field(default=None, description="Timestamp of the first token of the document. If non-streaming, set to last_token_at")
     last_token_at: datetime.datetime | None = Field(default=None, description="Timestamp of the last token of the document")
 
-   
-
     def chunk_accumulator(self, previous_cumulated_chunk: "RetabParsedChatCompletionChunk | None" = None) -> "RetabParsedChatCompletionChunk":
         """
         Accumulate the chunk into the state, returning a new RetabParsedChatCompletionChunk with the accumulated content that could be yielded alone to generate the same state.
@@ -249,7 +190,6 @@ class RetabParsedChatCompletionChunk(StreamingBaseModel, ChatCompletionChunk):
         # Get the current chunk missing content, flat_deleted_keys and is_valid_json
         acc_flat_deleted_keys = [safe_get_delta(self, i).flat_deleted_keys for i in range(max_choices)]
         acc_is_valid_json = [safe_get_delta(self, i).is_valid_json for i in range(max_choices)]
-        acc_field_locations = [safe_get_delta(self, i).field_locations for i in range(max_choices)]  # This is only present in the last chunk.
         # Delete from previous_cumulated_chunk.choices[i].delta.flat_parsed the keys that are in safe_get_delta(self, i).flat_deleted_keys
         for i in range(max_choices):
             previous_delta = safe_get_delta(previous_cumulated_chunk, i)
@@ -263,12 +203,8 @@ class RetabParsedChatCompletionChunk(StreamingBaseModel, ChatCompletionChunk):
         acc_key_mapping = [safe_get_delta(previous_cumulated_chunk, i).key_mapping or safe_get_delta(self, i).key_mapping for i in range(max_choices)]
 
         acc_content = [(safe_get_delta(previous_cumulated_chunk, i).content or "") + (safe_get_delta(self, i).content or "") for i in range(max_choices)]
-        first_token_at = self.first_token_at
-        last_token_at = self.last_token_at
-        request_at = self.request_at
 
         return RetabParsedChatCompletionChunk(
-            extraction_id=self.extraction_id,
             id=self.id,
             created=self.created,
             model=self.model,
@@ -281,7 +217,6 @@ class RetabParsedChatCompletionChunk(StreamingBaseModel, ChatCompletionChunk):
                         flat_parsed=acc_flat_parsed[i],
                         flat_likelihoods=acc_flat_likelihoods[i],
                         flat_deleted_keys=acc_flat_deleted_keys[i],
-                        field_locations=acc_field_locations[i],
                         is_valid_json=acc_is_valid_json[i],
                         key_mapping=acc_key_mapping[i],
                     ),
@@ -289,10 +224,10 @@ class RetabParsedChatCompletionChunk(StreamingBaseModel, ChatCompletionChunk):
                 )
                 for i in range(max_choices)
             ],
-            schema_validation_error=self.schema_validation_error,
-            request_at=request_at,
-            first_token_at=first_token_at,
-            last_token_at=last_token_at,
+            extraction_id=self.extraction_id,
+            request_at=self.request_at,
+            first_token_at=self.first_token_at,
+            last_token_at=self.last_token_at,
         )
 
     def to_completion(
@@ -313,8 +248,11 @@ class RetabParsedChatCompletionChunk(StreamingBaseModel, ChatCompletionChunk):
         final_likelihoods = unflatten_dict(override_final_flat_likelihoods)
 
         return RetabParsedChatCompletion(
-            extraction_id=self.extraction_id,
             id=self.id,
+            extraction_id=self.extraction_id,
+            request_at=self.request_at,
+            first_token_at=self.first_token_at,
+            last_token_at=self.last_token_at,
             created=self.created,
             model=self.model,
             object="chat.completion",
@@ -334,9 +272,6 @@ class RetabParsedChatCompletionChunk(StreamingBaseModel, ChatCompletionChunk):
             ],
             likelihoods=final_likelihoods,
             usage=self.usage,
-            request_at=self.request_at,
-            first_token_at=self.first_token_at,
-            last_token_at=self.last_token_at,
         )
 
 

retab/types/documents/parse.py

@@ -2,7 +2,6 @@ from typing import Literal
 from pydantic import BaseModel, ConfigDict, Field
 
 from ..mime import MIMEData, BaseMIMEData
-from ..browser_canvas import BrowserCanvas
 
 TableParsingFormat = Literal["markdown", "yaml", "html", "json"]
 
@@ -22,7 +21,6 @@ class ParseRequest(BaseModel):
     model: str = Field(default="gemini-2.5-flash", description="Model to use for parsing")
     table_parsing_format: TableParsingFormat = Field(default="html", description="Format for parsing tables")
     image_resolution_dpi: int = Field(default=192, description="DPI for image processing", ge=96, le=300)
-    browser_canvas: BrowserCanvas = Field(default="A4", description="Canvas size for document rendering")
 
 
 class ParseResult(BaseModel):