retab 0.0.41__py3-none-any.whl → 0.0.43__py3-none-any.whl

retab/resources/documents/extractions.py

@@ -10,7 +10,6 @@ from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionRea
 from openai.types.chat.parsed_chat_completion import ParsedChatCompletionMessage
 from openai.types.responses.response import Response
 from openai.types.responses.response_input_param import ResponseInputItemParam
-from pydantic_core import PydanticUndefined
 from pydantic import HttpUrl
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
@@ -23,7 +22,7 @@ from ...types.documents.extractions import DocumentExtractRequest, LogExtraction
 from ...types.browser_canvas import BrowserCanvas
 from ...types.modalities import Modality
 from ...types.schemas.object import Schema
-from ...types.standards import PreparedRequest
+from ...types.standards import PreparedRequest, FieldUnset
 
 
 def maybe_parse_to_pydantic(schema: Schema, response: RetabParsedChatCompletion, allow_partial: bool = False) -> RetabParsedChatCompletion:
@@ -44,14 +43,14 @@ class BaseExtractionsMixin:
         json_schema: dict[str, Any] | Path | str,
         document: Path | str | IOBase | HttpUrl | None = None,
         documents: list[Path | str | IOBase | HttpUrl] | None = None,
-        image_resolution_dpi: int = PydanticUndefined,  # type: ignore[assignment]
-        browser_canvas: BrowserCanvas = PydanticUndefined,  # type: ignore[assignment]
-        model: str = PydanticUndefined,  # type: ignore[assignment]
-        temperature: float = PydanticUndefined,  # type: ignore[assignment]
-        modality: Modality = PydanticUndefined,  # type: ignore[assignment]
-        reasoning_effort: ChatCompletionReasoningEffort = PydanticUndefined,  # type: ignore[assignment]
+        image_resolution_dpi: int = FieldUnset,
+        browser_canvas: BrowserCanvas = FieldUnset,
+        model: str = FieldUnset,
+        temperature: float = FieldUnset,
+        modality: Modality = FieldUnset,
+        reasoning_effort: ChatCompletionReasoningEffort = FieldUnset,
         stream: bool = False,
-        n_consensus: int = PydanticUndefined,  # type: ignore[assignment]
+        n_consensus: int = FieldUnset,
         store: bool = False,
         idempotency_key: str | None = None,
     ) -> PreparedRequest:
@@ -71,20 +70,30 @@ class BaseExtractionsMixin:
         else:
             raise ValueError("Must provide either 'document' or 'documents' parameter.")
 
+        # Build request dictionary with only provided fields
+        request_dict = {
+            'json_schema': json_schema,
+            'documents': processed_documents,
+            'stream': stream,
+            'store': store,
+        }
+        if model is not FieldUnset:
+            request_dict['model'] = model
+        if temperature is not FieldUnset:
+            request_dict['temperature'] = temperature
+        if modality is not FieldUnset:
+            request_dict['modality'] = modality
+        if reasoning_effort is not FieldUnset:
+            request_dict['reasoning_effort'] = reasoning_effort
+        if n_consensus is not FieldUnset:
+            request_dict['n_consensus'] = n_consensus
+        if image_resolution_dpi is not FieldUnset:
+            request_dict['image_resolution_dpi'] = image_resolution_dpi
+        if browser_canvas is not FieldUnset:
+            request_dict['browser_canvas'] = browser_canvas
+
         # Validate DocumentAPIRequest data (raises exception if invalid)
-        request = DocumentExtractRequest(
-            json_schema=json_schema,
-            documents=processed_documents,
-            model=model,
-            temperature=temperature,
-            stream=stream,
-            modality=modality,
-            store=store,
-            reasoning_effort=reasoning_effort,
-            n_consensus=n_consensus,
-            image_resolution_dpi=image_resolution_dpi,
-            browser_canvas=browser_canvas,
-        )
+        request = DocumentExtractRequest(**request_dict)
 
         return PreparedRequest(
             method="POST", url="/v1/documents/extractions", data=request.model_dump(mode="json", exclude_unset=True, exclude_defaults=True), idempotency_key=idempotency_key
@@ -144,12 +153,12 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
         model: str,
         document: Path | str | IOBase | HttpUrl | None = None,
         documents: list[Path | str | IOBase | HttpUrl] | None = None,
-        image_resolution_dpi: int = PydanticUndefined,  # type: ignore[assignment]
-        browser_canvas: BrowserCanvas = PydanticUndefined,  # type: ignore[assignment]
-        temperature: float = PydanticUndefined,  # type: ignore[assignment]
-        modality: Modality = PydanticUndefined,  # type: ignore[assignment]
-        reasoning_effort: ChatCompletionReasoningEffort = PydanticUndefined,  # type: ignore[assignment]
-        n_consensus: int = PydanticUndefined,  # type: ignore[assignment]
+        image_resolution_dpi: int = FieldUnset,
+        browser_canvas: BrowserCanvas = FieldUnset,
+        temperature: float = FieldUnset,
+        modality: Modality = FieldUnset,
+        reasoning_effort: ChatCompletionReasoningEffort = FieldUnset,
+        n_consensus: int = FieldUnset,
         idempotency_key: str | None = None,
         store: bool = False,
     ) -> RetabParsedChatCompletion:
@@ -204,12 +213,12 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
         model: str,
         document: Path | str | IOBase | HttpUrl | None = None,
         documents: list[Path | str | IOBase | HttpUrl] | None = None,
-        image_resolution_dpi: int = PydanticUndefined,  # type: ignore[assignment]
-        browser_canvas: BrowserCanvas = PydanticUndefined,  # type: ignore[assignment]
-        temperature: float = PydanticUndefined,  # type: ignore[assignment]
-        modality: Modality = PydanticUndefined,  # type: ignore[assignment]
-        reasoning_effort: ChatCompletionReasoningEffort = PydanticUndefined,  # type: ignore[assignment]
-        n_consensus: int = PydanticUndefined,  # type: ignore[assignment]
+        image_resolution_dpi: int = FieldUnset,
+        browser_canvas: BrowserCanvas = FieldUnset,
+        temperature: float = FieldUnset,
+        modality: Modality = FieldUnset,
+        reasoning_effort: ChatCompletionReasoningEffort = FieldUnset,
+        n_consensus: int = FieldUnset,
         idempotency_key: str | None = None,
         store: bool = False,
     ) -> Generator[RetabParsedChatCompletion, None, None]:
@@ -345,12 +354,12 @@ class AsyncExtractions(AsyncAPIResource, BaseExtractionsMixin):
         model: str,
         document: Path | str | IOBase | HttpUrl | None = None,
         documents: list[Path | str | IOBase | HttpUrl] | None = None,
-        image_resolution_dpi: int = PydanticUndefined,  # type: ignore[assignment]
-        browser_canvas: BrowserCanvas = PydanticUndefined,  # type: ignore[assignment]
-        temperature: float = PydanticUndefined,  # type: ignore[assignment]
-        modality: Modality = PydanticUndefined,  # type: ignore[assignment]
-        reasoning_effort: ChatCompletionReasoningEffort = PydanticUndefined,  # type: ignore[assignment]
-        n_consensus: int = PydanticUndefined,  # type: ignore[assignment]
+        image_resolution_dpi: int = FieldUnset,
+        browser_canvas: BrowserCanvas = FieldUnset,
+        temperature: float = FieldUnset,
+        modality: Modality = FieldUnset,
+        reasoning_effort: ChatCompletionReasoningEffort = FieldUnset,
+        n_consensus: int = FieldUnset,
         idempotency_key: str | None = None,
         store: bool = False,
     ) -> RetabParsedChatCompletion:
@@ -401,12 +410,12 @@ class AsyncExtractions(AsyncAPIResource, BaseExtractionsMixin):
         model: str,
         document: Path | str | IOBase | HttpUrl | None = None,
         documents: list[Path | str | IOBase | HttpUrl] | None = None,
-        image_resolution_dpi: int = PydanticUndefined,  # type: ignore[assignment]
-        browser_canvas: BrowserCanvas = PydanticUndefined,  # type: ignore[assignment]
-        temperature: float = PydanticUndefined,  # type: ignore[assignment]
-        modality: Modality = PydanticUndefined,  # type: ignore[assignment]
-        reasoning_effort: ChatCompletionReasoningEffort = PydanticUndefined,  # type: ignore[assignment]
-        n_consensus: int = PydanticUndefined,  # type: ignore[assignment]
+        image_resolution_dpi: int = FieldUnset,
+        browser_canvas: BrowserCanvas = FieldUnset,
+        temperature: float = FieldUnset,
+        modality: Modality = FieldUnset,
+        reasoning_effort: ChatCompletionReasoningEffort = FieldUnset,
+        n_consensus: int = FieldUnset,
         idempotency_key: str | None = None,
         store: bool = False,
     ) -> AsyncGenerator[RetabParsedChatCompletion, None]:

retab/resources/evaluations/client.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, List
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
-from ...types.evaluations import Evaluation, PatchEvaluationRequest, ListEvaluationParams, CreateEvaluation
+from ...types.evaluations import Evaluation, PatchEvaluationRequest, ListEvaluationParams, BaseEvaluation
 from ...types.inference_settings import InferenceSettings
 from ...types.standards import PreparedRequest, DeleteResponse, FieldUnset
 from .documents import Documents, AsyncDocuments
@@ -16,14 +16,18 @@ class EvaluationsMixin:
         project_id: str = FieldUnset,
         default_inference_settings: InferenceSettings = FieldUnset,
     ) -> PreparedRequest:
-        # Use CreateEvaluation model
-        eval_data = CreateEvaluation(
-            name=name,
-            json_schema=json_schema,
-            project_id=project_id,
-            default_inference_settings=default_inference_settings,
-        )
-        return PreparedRequest(method="POST", url="/v1/evaluations", data=eval_data.model_dump(exclude_none=True, mode="json"))
+        # Use BaseEvaluation model
+        eval_dict = {
+            "name": name,
+            "json_schema": json_schema,
+        }
+        if project_id is not FieldUnset:
+            eval_dict["project_id"] = project_id
+        if default_inference_settings is not FieldUnset:
+            eval_dict["default_inference_settings"] = default_inference_settings
+        
+        eval_data = BaseEvaluation(**eval_dict)
+        return PreparedRequest(method="POST", url="/v1/evaluations", data=eval_data.model_dump(exclude_unset=True, mode="json"))
 
     def prepare_get(self, evaluation_id: str) -> PreparedRequest:
         return PreparedRequest(method="GET", url=f"/v1/evaluations/{evaluation_id}")
@@ -42,12 +46,17 @@ class EvaluationsMixin:
         Only the provided fields will be updated. Fields set to None will be excluded from the update.
         """
         # Build a dictionary with only the provided fields
-        data = PatchEvaluationRequest(
-            name=name,
-            project_id=project_id,
-            json_schema=json_schema,
-            default_inference_settings=default_inference_settings,
-        ).model_dump(exclude_unset=True, mode="json")
+        update_dict = {}
+        if name is not FieldUnset:
+            update_dict["name"] = name
+        if project_id is not FieldUnset:
+            update_dict["project_id"] = project_id
+        if json_schema is not FieldUnset:
+            update_dict["json_schema"] = json_schema
+        if default_inference_settings is not FieldUnset:
+            update_dict["default_inference_settings"] = default_inference_settings
+        
+        data = PatchEvaluationRequest(**update_dict).model_dump(exclude_unset=True, mode="json")
 
         return PreparedRequest(method="PATCH", url=f"/v1/evaluations/{evaluation_id}", data=data)
 
@@ -56,11 +65,11 @@ class EvaluationsMixin:
         Prepare a request to list evaluations.
 
         Usage:
-        >>> client.evals.list(project_id="project_id")   # List all evaluations for a project
-        >>> client.evals.list()                          # List all evaluations (no project_id)
+        >>> client.evaluations.list(project_id="project_id")   # List all evaluations for a project
+        >>> client.evaluations.list()                          # List all evaluations (no project_id)
 
         This does not work:
-        >>> client.evals.list(project_id=None)
+        >>> client.evaluations.list(project_id=None)
 
         Args:
             project_id: The project ID to list evaluations for
@@ -68,7 +77,11 @@ class EvaluationsMixin:
         Returns:
             PreparedRequest: The prepared request
         """
-        params = ListEvaluationParams(project_id=project_id).model_dump(exclude_unset=True, exclude_defaults=True, mode="json")
+        params_dict = {}
+        if project_id is not FieldUnset:
+            params_dict["project_id"] = project_id
+        
+        params = ListEvaluationParams(**params_dict).model_dump(exclude_unset=True, exclude_defaults=True, mode="json")
         return PreparedRequest(method="GET", url="/v1/evaluations", params=params)
 
     def prepare_delete(self, id: str) -> PreparedRequest:

retab/resources/evaluations/documents.py

@@ -8,6 +8,7 @@ from pydantic import HttpUrl
 from ..._resource import AsyncAPIResource, SyncAPIResource
 from ...utils.mime import prepare_mime_document
 from ...types.evaluations import DocumentItem, EvaluationDocument, PatchEvaluationDocumentRequest
+from ...types.predictions import PredictionMetadata
 from ...types.mime import MIMEData
 from ...types.standards import PreparedRequest, DeleteResponse, FieldUnset
 from ...types.documents.extractions import RetabParsedChatCompletion
@@ -17,18 +18,18 @@ class DocumentsMixin:
     def prepare_get(self, evaluation_id: str, document_id: str) -> PreparedRequest:
         return PreparedRequest(method="GET", url=f"/v1/evaluations/{evaluation_id}/documents/{document_id}")
 
-    def prepare_create(self, evaluation_id: str, document: MIMEData, annotation: dict[str, Any]) -> PreparedRequest:
+    def prepare_create(self, evaluation_id: str, document: MIMEData, annotation: dict[str, Any], annotation_metadata: dict[str, Any] | None = None) -> PreparedRequest:
         # Serialize the MIMEData
-        document_item = DocumentItem(mime_data=document, annotation=annotation, annotation_metadata=None)
+        document_item = DocumentItem(mime_data=document, annotation=annotation, annotation_metadata=PredictionMetadata(**annotation_metadata) if annotation_metadata else None)
         return PreparedRequest(method="POST", url=f"/v1/evaluations/{evaluation_id}/documents", data=document_item.model_dump(mode="json"))
 
     def prepare_list(self, evaluation_id: str) -> PreparedRequest:
         return PreparedRequest(method="GET", url=f"/v1/evaluations/{evaluation_id}/documents")
 
-    def prepare_update(self, evaluation_id: str, document_id: str, annotation: dict[str, Any] = FieldUnset) -> PreparedRequest:
+    def prepare_update(self, evaluation_id: str, document_id: str, annotation: dict[str, Any]) -> PreparedRequest:
         update_request = PatchEvaluationDocumentRequest(annotation=annotation)
         return PreparedRequest(
-            method="PATCH", url=f"/v1/evaluations/{evaluation_id}/documents/{document_id}", data=update_request.model_dump(mode="json", exclude_unset=True, exclude_defaults=True)
+            method="PATCH", url=f"/v1/evaluations/{evaluation_id}/documents/{document_id}", data=update_request.model_dump(mode="json", exclude_unset=True)
         )
 
     def prepare_delete(self, evaluation_id: str, document_id: str) -> PreparedRequest:
@@ -41,7 +42,7 @@ class DocumentsMixin:
 class Documents(SyncAPIResource, DocumentsMixin):
     """Documents API wrapper for evaluations"""
 
-    def create(self, evaluation_id: str, document: Union[Path, str, IOBase, MIMEData, PIL.Image.Image, HttpUrl], annotation: Dict[str, Any]) -> EvaluationDocument:
+    def create(self, evaluation_id: str, document: Union[Path, str, IOBase, MIMEData, PIL.Image.Image, HttpUrl], annotation: Dict[str, Any], annotation_metadata: Dict[str, Any] | None = None) -> EvaluationDocument:
         """
         Create a document for an evaluation.
 
@@ -64,7 +65,7 @@ class Documents(SyncAPIResource, DocumentsMixin):
         mime_document: MIMEData = prepare_mime_document(document)
 
         # Let prepare_create handle the serialization
-        request = self.prepare_create(evaluation_id, mime_document, annotation)
+        request = self.prepare_create(evaluation_id, mime_document, annotation, annotation_metadata)
         response = self._client._prepared_request(request)
         return EvaluationDocument(**response)
 
@@ -101,7 +102,7 @@ class Documents(SyncAPIResource, DocumentsMixin):
         response = self._client._prepared_request(request)
         return EvaluationDocument(**response)
 
-    def update(self, evaluation_id: str, document_id: str, annotation: dict[str, Any] = FieldUnset) -> EvaluationDocument:
+    def update(self, evaluation_id: str, document_id: str, annotation: dict[str, Any]) -> EvaluationDocument:
         """
         Update a document.
 
@@ -146,7 +147,7 @@ class Documents(SyncAPIResource, DocumentsMixin):
 class AsyncDocuments(AsyncAPIResource, DocumentsMixin):
     """Async Documents API wrapper for evaluations"""
 
-    async def create(self, evaluation_id: str, document: Union[Path, str, IOBase, MIMEData, PIL.Image.Image, HttpUrl], annotation: Dict[str, Any]) -> EvaluationDocument:
+    async def create(self, evaluation_id: str, document: Union[Path, str, IOBase, MIMEData, PIL.Image.Image, HttpUrl], annotation: Dict[str, Any], annotation_metadata: Dict[str, Any] | None = None) -> EvaluationDocument:
         """
         Create a document for an evaluation.
 
@@ -159,7 +160,7 @@ class AsyncDocuments(AsyncAPIResource, DocumentsMixin):
                 - A PIL Image object
                 - A URL (HttpUrl)
             annotation: The ground truth for the document
-
+            annotation_metadata: The metadata of the annotation
         Returns:
             EvaluationDocument: The created document
         Raises:
@@ -169,7 +170,7 @@ class AsyncDocuments(AsyncAPIResource, DocumentsMixin):
         mime_document: MIMEData = prepare_mime_document(document)
 
         # Let prepare_create handle the serialization
-        request = self.prepare_create(evaluation_id, mime_document, annotation)
+        request = self.prepare_create(evaluation_id, mime_document, annotation, annotation_metadata)
         response = await self._client._prepared_request(request)
         return EvaluationDocument(**response)
 
@@ -189,7 +190,7 @@ class AsyncDocuments(AsyncAPIResource, DocumentsMixin):
         response = await self._client._prepared_request(request)
         return [EvaluationDocument(**item) for item in response.get("data", [])]
 
-    async def update(self, evaluation_id: str, document_id: str, annotation: dict[str, Any] = FieldUnset) -> EvaluationDocument:
+    async def update(self, evaluation_id: str, document_id: str, annotation: dict[str, Any]) -> EvaluationDocument:
         """
         Update a document.
 

retab/resources/evaluations/iterations.py

@@ -34,15 +34,23 @@ class IterationsMixin:
         browser_canvas: BrowserCanvas = FieldUnset,
         n_consensus: int = FieldUnset,
     ) -> PreparedRequest:
-        inference_settings = InferenceSettings(
-            model=model,
-            temperature=temperature,
-            modality=modality,
-            reasoning_effort=reasoning_effort,
-            image_resolution_dpi=image_resolution_dpi,
-            browser_canvas=browser_canvas,
-            n_consensus=n_consensus,
-        )
+        inference_dict = {}
+        if model is not FieldUnset:
+            inference_dict["model"] = model
+        if temperature is not FieldUnset:
+            inference_dict["temperature"] = temperature
+        if modality is not FieldUnset:
+            inference_dict["modality"] = modality
+        if reasoning_effort is not FieldUnset:
+            inference_dict["reasoning_effort"] = reasoning_effort
+        if image_resolution_dpi is not FieldUnset:
+            inference_dict["image_resolution_dpi"] = image_resolution_dpi
+        if browser_canvas is not FieldUnset:
+            inference_dict["browser_canvas"] = browser_canvas
+        if n_consensus is not FieldUnset:
+            inference_dict["n_consensus"] = n_consensus
+        
+        inference_settings = InferenceSettings(**inference_dict)
 
         request = CreateIterationRequest(inference_settings=inference_settings, json_schema=json_schema)
 
@@ -61,19 +69,29 @@ class IterationsMixin:
         browser_canvas: BrowserCanvas = FieldUnset,
         n_consensus: int = FieldUnset,
     ) -> PreparedRequest:
-        inference_settings = InferenceSettings(
-            model=model,
-            temperature=temperature,
-            modality=modality,
-            reasoning_effort=reasoning_effort,
-            image_resolution_dpi=image_resolution_dpi,
-            browser_canvas=browser_canvas,
-            n_consensus=n_consensus,
-        )
-        if not inference_settings.model_dump(exclude_unset=True, mode="json"):
-            inference_settings = FieldUnset
-
-        iteration_data = PatchIterationRequest(json_schema=json_schema, inference_settings=inference_settings)
+        inference_dict = {}
+        if model is not FieldUnset:
+            inference_dict["model"] = model
+        if temperature is not FieldUnset:
+            inference_dict["temperature"] = temperature
+        if modality is not FieldUnset:
+            inference_dict["modality"] = modality
+        if reasoning_effort is not FieldUnset:
+            inference_dict["reasoning_effort"] = reasoning_effort
+        if image_resolution_dpi is not FieldUnset:
+            inference_dict["image_resolution_dpi"] = image_resolution_dpi
+        if browser_canvas is not FieldUnset:
+            inference_dict["browser_canvas"] = browser_canvas
+        if n_consensus is not FieldUnset:
+            inference_dict["n_consensus"] = n_consensus
+        
+        iteration_dict = {}
+        if json_schema is not FieldUnset:
+            iteration_dict["json_schema"] = json_schema
+        if inference_dict:  # Only add inference_settings if we have at least one field
+            iteration_dict["inference_settings"] = InferenceSettings(**inference_dict)
+
+        iteration_data = PatchIterationRequest(**iteration_dict)
 
         return PreparedRequest(
             method="PATCH", url=f"/v1/evaluations/{evaluation_id}/iterations/{iteration_id}", data=iteration_data.model_dump(exclude_unset=True, exclude_defaults=True, mode="json")
@@ -136,14 +154,14 @@ class Iterations(SyncAPIResource, IterationsMixin):
     def create(
         self,
         evaluation_id: str,
-        model: str,
-        temperature: float = 0.0,
-        modality: Modality = "native",
-        json_schema: Optional[Dict[str, Any]] = None,
-        reasoning_effort: ChatCompletionReasoningEffort = "medium",
-        image_resolution_dpi: int = 96,
-        browser_canvas: BrowserCanvas = "A4",
-        n_consensus: int = 1,
+        model: str = FieldUnset,
+        temperature: float = FieldUnset,
+        modality: Modality = FieldUnset,
+        json_schema: Optional[Dict[str, Any]] = FieldUnset,
+        reasoning_effort: ChatCompletionReasoningEffort = FieldUnset,
+        image_resolution_dpi: int = FieldUnset,
+        browser_canvas: BrowserCanvas = FieldUnset,
+        n_consensus: int = FieldUnset,
     ) -> Iteration:
         """
         Create a new iteration for an evaluation.

retab/resources/jsonlUtils.py

@@ -14,9 +14,8 @@ from anthropic import Anthropic
 from openai import OpenAI
 from openai.types.chat.chat_completion_message_param import ChatCompletionMessageParam
 from pydantic import BaseModel
-from pydantic_core import PydanticUndefined
 from tqdm import tqdm
-
+from ..types.standards import FieldUnset
 from .._resource import AsyncAPIResource, SyncAPIResource
 from ..utils.ai_models import assert_valid_model_extraction, get_provider_for_model
 from ..utils.chat import convert_to_anthropic_format, convert_to_openai_format, separate_messages
@@ -139,8 +138,8 @@ class Datasets(SyncAPIResource, BaseDatasetsMixin):
         json_schema: dict[str, Any] | Path | str,
         document_annotation_pairs_paths: list[dict[str, Path | str]],
         dataset_path: Path | str,
-        image_resolution_dpi: int = PydanticUndefined,  # type: ignore[assignment]
-        browser_canvas: BrowserCanvas = PydanticUndefined,  # type: ignore[assignment]
+        image_resolution_dpi: int = FieldUnset,
+        browser_canvas: BrowserCanvas = FieldUnset,
         modality: Modality = "native",
     ) -> None:
         """Save document-annotation pairs to a JSONL training set.