retab 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

{uiform → retab}/resources/documents/extractions.py

@@ -2,7 +2,7 @@ import base64
 import json
 from io import IOBase
 from pathlib import Path
-from typing import Any, AsyncGenerator, Generator, Literal, Optional
+from typing import Any, AsyncGenerator, Generator
 
 from anthropic.types.message_param import MessageParam
 from openai.types.chat import ChatCompletionMessageParam
@@ -10,6 +10,7 @@ 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
@@ -19,6 +20,7 @@ from ..._utils.mime import MIMEData, prepare_mime_document
 from ..._utils.stream_context_managers import as_async_context_manager, as_context_manager
 from ...types.chat import ChatCompletionUiformMessage
 from ...types.documents.extractions import DocumentExtractRequest, LogExtractionRequest, UiParsedChatCompletion, UiParsedChatCompletionChunk, UiParsedChoice
+from ...types.browser_canvas import BrowserCanvas
 from ...types.modalities import Modality
 from ...types.schemas.object import Schema
 from ...types.standards import PreparedRequest
@@ -31,7 +33,7 @@ def maybe_parse_to_pydantic(schema: Schema, response: UiParsedChatCompletion, al
                 response.choices[0].message.parsed = schema._partial_pydantic_model.model_validate(filter_auxiliary_fields_json(response.choices[0].message.content))
             else:
                 response.choices[0].message.parsed = schema.pydantic_model.model_validate(filter_auxiliary_fields_json(response.choices[0].message.content))
-        except Exception as e:
+        except Exception:
             pass
     return response
 
@@ -40,15 +42,16 @@ class BaseExtractionsMixin:
     def prepare_extraction(
         self,
         json_schema: dict[str, Any] | Path | str,
-        document: Path | str | IOBase | HttpUrl | None,
-        image_resolution_dpi: int | None,
-        browser_canvas: Literal['A3', 'A4', 'A5'] | None,
-        model: str,
-        temperature: float,
-        modality: Modality,
-        reasoning_effort: ChatCompletionReasoningEffort,
-        stream: bool,
-        n_consensus: int = 1,
+        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]
+        stream: bool = False,
+        n_consensus: int = PydanticUndefined,  # type: ignore[assignment]
         store: bool = False,
         idempotency_key: str | None = None,
     ) -> PreparedRequest:
@@ -56,26 +59,36 @@ class BaseExtractionsMixin:
 
         json_schema = load_json_schema(json_schema)
 
-        data = {
-            "json_schema": json_schema,
-            "document": prepare_mime_document(document).model_dump() if document is not None else None,
-            "model": model,
-            "temperature": temperature,
-            "stream": stream,
-            "modality": modality,
-            "store": store,
-            "reasoning_effort": reasoning_effort,
-            "n_consensus": n_consensus,
-        }
-        if image_resolution_dpi:
-            data["image_resolution_dpi"] = image_resolution_dpi
-        if browser_canvas:
-            data["browser_canvas"] = browser_canvas
+        # Handle both single document and multiple documents
+        if document is not None and documents is not None:
+            raise ValueError("Cannot provide both 'document' and 'documents' parameters. Use either one.")
+
+        # Convert single document to documents list for consistency
+        if document is not None:
+            processed_documents = [prepare_mime_document(document)]
+        elif documents is not None:
+            processed_documents = [prepare_mime_document(doc) for doc in documents]
+        else:
+            raise ValueError("Must provide either 'document' or 'documents' parameter.")
 
         # Validate DocumentAPIRequest data (raises exception if invalid)
-        document_extract_request = DocumentExtractRequest.model_validate(data)
+        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,
+        )
 
-        return PreparedRequest(method="POST", url="/v1/documents/extractions", data=document_extract_request.model_dump(), idempotency_key=idempotency_key)
+        return PreparedRequest(
+            method="POST", url="/v1/documents/extractions", data=request.model_dump(mode="json", exclude_unset=True, exclude_defaults=True), idempotency_key=idempotency_key
+        )
 
     def prepare_log_extraction(
         self,
@@ -99,12 +112,14 @@ class BaseExtractionsMixin:
                 # url is a base64 encoded string with the mime type and the content. For the dummy one we will send a .txt file with the text "No document provided"
                 url="data:text/plain;base64," + base64.b64encode(b"No document provided").decode("utf-8"),
             )
+        else:
+            mime_document = prepare_mime_document(document)
 
         return PreparedRequest(
             method="POST",
             url="/v1/documents/log_extraction",
             data=LogExtractionRequest(
-                document=prepare_mime_document(document) if document else mime_document,
+                document=mime_document,
                 messages=messages,
                 openai_messages=openai_messages,
                 anthropic_messages=anthropic_messages,
@@ -115,7 +130,7 @@ class BaseExtractionsMixin:
                 json_schema=json_schema,
                 model=model,
                 temperature=temperature,
-            ).model_dump(mode="json", by_alias=True),  # by_alias is necessary to enable serialization/deserialization ('schema' was being converted to 'schema_')
+            ).model_dump(mode="json"),
             raise_for_status=True,
         )
 
@@ -127,23 +142,27 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
         self,
         json_schema: dict[str, Any] | Path | str,
         model: str,
-        document: Path | str | IOBase | HttpUrl | None,
-        image_resolution_dpi: int | None = None,
-        browser_canvas: Literal['A3', 'A4', 'A5'] | None = None,
-        temperature: float = 0,
-        modality: Modality = "native",
-        reasoning_effort: ChatCompletionReasoningEffort = "medium",
-        n_consensus: int = 1,
+        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]
         idempotency_key: str | None = None,
         store: bool = False,
     ) -> UiParsedChatCompletion:
         """
-        Process a document using the UiForm API.
+        Process one or more documents using the UiForm API.
 
         Args:
             json_schema: JSON schema defining the expected data structure
-            document: Single document (as MIMEData) to process
             model: The AI model to use for processing
+            document: Single document to process (use either this or documents, not both)
+            documents: List of documents to process (use either this or document, not both)
+            image_resolution_dpi: Optional image resolution DPI
+            browser_canvas: Optional browser canvas size
             temperature: Model temperature setting (0-1)
             modality: Modality of the document (e.g., native)
             reasoning_effort: The effort level for the model to reason about the input data.
@@ -151,16 +170,27 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
             idempotency_key: Idempotency key for request
             store: Whether to store the document in the UiForm database
         Returns:
-            DocumentAPIResponse
+            UiParsedChatCompletion: Parsed response from the API
         Raises:
-            HTTPException if the request fails
+            ValueError: If neither document nor documents is provided, or if both are provided
+            HTTPException: If the request fails
         """
 
-        assert document is not None, "Either document or messages must be provided"
-
         # Validate DocumentAPIRequest data (raises exception if invalid)
         request = self.prepare_extraction(
-            json_schema, document, image_resolution_dpi, browser_canvas, model, temperature, modality, reasoning_effort, False, n_consensus=n_consensus, store=store, idempotency_key=idempotency_key
+            json_schema=json_schema,
+            document=document,
+            documents=documents,
+            image_resolution_dpi=image_resolution_dpi,
+            browser_canvas=browser_canvas,
+            model=model,
+            temperature=temperature,
+            modality=modality,
+            reasoning_effort=reasoning_effort,
+            stream=False,
+            n_consensus=n_consensus,
+            store=store,
+            idempotency_key=idempotency_key,
         )
         response = self._client._prepared_request(request)
 
@@ -172,25 +202,27 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
         self,
         json_schema: dict[str, Any] | Path | str,
         model: str,
-        document: Path | str | IOBase | HttpUrl | None,
-        image_resolution_dpi: int | None = None,
-        browser_canvas: Literal['A3', 'A4', 'A5'] | None = None,
-        temperature: float = 0,
-        modality: Modality = "native",
-        reasoning_effort: ChatCompletionReasoningEffort = "medium",
-        n_consensus: int = 1,
+        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]
         idempotency_key: str | None = None,
         store: bool = False,
     ) -> Generator[UiParsedChatCompletion, None, None]:
         """
-        Process a document using the UiForm API with streaming enabled.
+        Process one or more documents using the UiForm API with streaming enabled.
 
         Args:
             json_schema: JSON schema defining the expected data structure
-            document: Single document (as MIMEData) to process
+            model: The AI model to use for processing
+            document: Single document to process (use either this or documents, not both)
+            documents: List of documents to process (use either this or document, not both)
             image_resolution_dpi: Optional image resolution DPI.
             browser_canvas: Optional browser canvas size.
-            model: The AI model to use for processing
             temperature: Model temperature setting (0-1)
             modality: Modality of the document (e.g., native)
             reasoning_effort: The effort level for the model to reason about the input data.
@@ -199,18 +231,37 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
             store: Whether to store the document in the UiForm database
 
         Returns:
-            Generator[DocumentExtractResponse]: Stream of parsed responses
+            Generator[UiParsedChatCompletion]: Stream of parsed responses
         Raises:
-            HTTPException if the request fails
+            ValueError: If neither document nor documents is provided, or if both are provided
+            HTTPException: If the request fails
         Usage:
         ```python
-        with uiform.documents.extractions.stream(json_schema, document, model, temperature, reasoning_effort, modality) as stream:
+        # Single document
+        with uiform.documents.extractions.stream(json_schema, model, document=document) as stream:
+            for response in stream:
+                print(response)
+
+        # Multiple documents
+        with uiform.documents.extractions.stream(json_schema, model, documents=[doc1, doc2]) as stream:
             for response in stream:
                 print(response)
         ```
         """
         request = self.prepare_extraction(
-            json_schema, document, image_resolution_dpi, browser_canvas, model, temperature, modality, reasoning_effort, True, n_consensus=n_consensus, store=store, idempotency_key=idempotency_key
+            json_schema=json_schema,
+            document=document,
+            documents=documents,
+            image_resolution_dpi=image_resolution_dpi,
+            browser_canvas=browser_canvas,
+            model=model,
+            temperature=temperature,
+            modality=modality,
+            reasoning_effort=reasoning_effort,
+            stream=True,
+            n_consensus=n_consensus,
+            store=store,
+            idempotency_key=idempotency_key,
         )
         schema = Schema(json_schema=load_json_schema(json_schema))
 
@@ -270,10 +321,10 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
         openai_responses_output: Response | None = None,
     ) -> None:
         request = self.prepare_log_extraction(
-            document,
-            json_schema,
-            model,
-            temperature,
+            document=document,
+            json_schema=json_schema,
+            model=model,
+            temperature=temperature,
             completion=completion,
             messages=messages,
             openai_messages=openai_messages,
@@ -292,25 +343,27 @@ class AsyncExtractions(AsyncAPIResource, BaseExtractionsMixin):
         self,
         json_schema: dict[str, Any] | Path | str,
         model: str,
-        document: Path | str | IOBase | HttpUrl | None,
-        image_resolution_dpi: int | None = None,
-        browser_canvas: Literal['A3', 'A4', 'A5'] | None = None,
-        temperature: float = 0,
-        modality: Modality = "native",
-        reasoning_effort: ChatCompletionReasoningEffort = "medium",
-        n_consensus: int = 1,
+        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]
         idempotency_key: str | None = None,
         store: bool = False,
     ) -> UiParsedChatCompletion:
         """
-        Extract structured data from a document asynchronously.
+        Extract structured data from one or more documents asynchronously.
 
         Args:
             json_schema: JSON schema defining the expected data structure.
-            document: Path, string, or file-like object representing the document.
+            model: The AI model to use.
+            document: Single document to process (use either this or documents, not both)
+            documents: List of documents to process (use either this or document, not both)
             image_resolution_dpi: Optional image resolution DPI.
             browser_canvas: Optional browser canvas size.
-            model: The AI model to use.
             temperature: Model temperature setting (0-1).
             modality: Modality of the document (e.g., native).
             reasoning_effort: The effort level for the model to reason about the input data.
@@ -318,10 +371,24 @@ class AsyncExtractions(AsyncAPIResource, BaseExtractionsMixin):
             idempotency_key: Idempotency key for request
             store: Whether to store the document in the UiForm database
         Returns:
-            DocumentExtractResponse: Parsed response from the API.
+            UiParsedChatCompletion: Parsed response from the API.
+        Raises:
+            ValueError: If neither document nor documents is provided, or if both are provided
         """
         request = self.prepare_extraction(
-            json_schema, document, image_resolution_dpi, browser_canvas, model, temperature, modality, reasoning_effort, False, n_consensus=n_consensus, store=store, idempotency_key=idempotency_key
+            json_schema=json_schema,
+            document=document,
+            documents=documents,
+            image_resolution_dpi=image_resolution_dpi,
+            browser_canvas=browser_canvas,
+            model=model,
+            temperature=temperature,
+            modality=modality,
+            reasoning_effort=reasoning_effort,
+            stream=False,
+            n_consensus=n_consensus,
+            store=store,
+            idempotency_key=idempotency_key,
         )
         response = await self._client._prepared_request(request)
         schema = Schema(json_schema=load_json_schema(json_schema))
@@ -332,23 +399,27 @@ class AsyncExtractions(AsyncAPIResource, BaseExtractionsMixin):
         self,
         json_schema: dict[str, Any] | Path | str,
         model: str,
-        document: Path | str | IOBase | HttpUrl | None,
-        image_resolution_dpi: int | None = None,
-        browser_canvas: Literal['A3', 'A4', 'A5'] | None = None,
-        temperature: float = 0,
-        modality: Modality = "native",
-        reasoning_effort: ChatCompletionReasoningEffort = "medium",
-        n_consensus: int = 1,
+        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]
         idempotency_key: str | None = None,
         store: bool = False,
     ) -> AsyncGenerator[UiParsedChatCompletion, None]:
         """
-        Extract structured data from a document asynchronously with streaming.
+        Extract structured data from one or more documents asynchronously with streaming.
 
         Args:
             json_schema: JSON schema defining the expected data structure.
-            document: Path, string, or file-like object representing the document.
             model: The AI model to use.
+            document: Single document to process (use either this or documents, not both)
+            documents: List of documents to process (use either this or document, not both)
+            image_resolution_dpi: Optional image resolution DPI.
+            browser_canvas: Optional browser canvas size.
             temperature: Model temperature setting (0-1).
             modality: Modality of the document (e.g., native).
             reasoning_effort: The effort level for the model to reason about the input data.
@@ -356,17 +427,37 @@ class AsyncExtractions(AsyncAPIResource, BaseExtractionsMixin):
             idempotency_key: Idempotency key for request
             store: Whether to store the document in the UiForm database
         Returns:
-            AsyncGenerator[DocumentExtractResponse, None]: Stream of parsed responses.
+            AsyncGenerator[UiParsedChatCompletion, None]: Stream of parsed responses.
+        Raises:
+            ValueError: If neither document nor documents is provided, or if both are provided
 
         Usage:
         ```python
-        async with uiform.documents.extractions.stream(json_schema, document, model, temperature, reasoning_effort, modality) as stream:
+        # Single document
+        async with uiform.documents.extractions.stream(json_schema, model, document=document) as stream:
+            async for response in stream:
+                print(response)
+
+        # Multiple documents
+        async with uiform.documents.extractions.stream(json_schema, model, documents=[doc1, doc2]) as stream:
             async for response in stream:
                 print(response)
         ```
         """
         request = self.prepare_extraction(
-            json_schema, document, image_resolution_dpi, browser_canvas, model, temperature, modality, reasoning_effort, True, n_consensus=n_consensus, store=store, idempotency_key=idempotency_key
+            json_schema=json_schema,
+            document=document,
+            documents=documents,
+            image_resolution_dpi=image_resolution_dpi,
+            browser_canvas=browser_canvas,
+            model=model,
+            temperature=temperature,
+            modality=modality,
+            reasoning_effort=reasoning_effort,
+            stream=True,
+            n_consensus=n_consensus,
+            store=store,
+            idempotency_key=idempotency_key,
         )
         schema = Schema(json_schema=load_json_schema(json_schema))
         ui_parsed_chat_completion_cum_chunk: UiParsedChatCompletionChunk | None = None
@@ -426,10 +517,10 @@ class AsyncExtractions(AsyncAPIResource, BaseExtractionsMixin):
         openai_responses_output: Response | None = None,
     ) -> None:
         request = self.prepare_log_extraction(
-            document,
-            json_schema,
-            model,
-            temperature,
+            document=document,
+            json_schema=json_schema,
+            model=model,
+            temperature=temperature,
             completion=completion,
             messages=messages,
             openai_messages=openai_messages,

{uiform → retab}/resources/evals.py

@@ -1,32 +1,28 @@
-from typing import Any, Dict, List, Optional, TypedDict, Union, Literal
 from io import IOBase
 from pathlib import Path
+from typing import Any, Dict, List, Optional, TypedDict, Union
 
 import PIL.Image
+from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
 from pydantic import HttpUrl
 
 from .._resource import AsyncAPIResource, SyncAPIResource
-from ..types.standards import PreparedRequest
+from .._utils.mime import prepare_mime_document
 from ..types.evals import (
+    CreateIterationRequest,
+    DistancesResult,
+    DocumentItem,
     Evaluation,
     EvaluationDocument,
     Iteration,
-    DistancesResult,
-    PredictionData,
-    AddIterationFromJsonlRequest,
-    DocumentItem,
     UpdateEvaluationDocumentRequest,
-    PredictionMetadata,
-    CreateIterationRequest,
+    UpdateEvaluationRequest,
 )
-from ..types.jobs.base import InferenceSettings
-
+from ..types.inference_settings import InferenceSettings
 from ..types.mime import MIMEData
-from .._utils.mime import prepare_mime_document
 from ..types.modalities import Modality
-from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
-
-from tqdm import tqdm
+from ..types.browser_canvas import BrowserCanvas
+from ..types.standards import PreparedRequest
 
 
 class DeleteResponse(TypedDict):
@@ -82,21 +78,17 @@ class EvalsMixin:
         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
-        update_data = {}
-        if name is not None:
-            update_data["name"] = name
-        if project_id is not None:
-            update_data["project_id"] = project_id
-        if json_schema is not None:
-            update_data["json_schema"] = json_schema
-        if documents is not None:
-            update_data["documents"] = [doc.model_dump(exclude_none=True, mode="json") for doc in documents]
-        if iterations is not None:
-            update_data["iterations"] = [iter.model_dump(exclude_none=True, mode="json") for iter in iterations]
-        if default_inference_settings is not None:
-            update_data["default_inference_settings"] = default_inference_settings.model_dump(exclude_none=True, mode="json")
-
-        return PreparedRequest(method="PATCH", url=f"/v1/evals/{evaluation_id}", data=update_data)
+
+        update_request = UpdateEvaluationRequest(
+            name=name,
+            project_id=project_id,
+            json_schema=json_schema,
+            documents=documents,
+            iterations=iterations,
+            default_inference_settings=default_inference_settings,
+        )
+
+        return PreparedRequest(method="PATCH", url=f"/v1/evals/{evaluation_id}", data=update_request.model_dump(exclude_none=True, mode="json"))
 
     def prepare_list(self, project_id: Optional[str] = None) -> PreparedRequest:
         params = {}
@@ -114,9 +106,7 @@ class DocumentsMixin:
 
     def prepare_create(self, evaluation_id: str, document: MIMEData, annotation: Dict[str, Any]) -> PreparedRequest:
         # Serialize the MIMEData
-
         document_item = DocumentItem(mime_data=document, annotation=annotation, annotation_metadata=None)
-
         return PreparedRequest(method="POST", url=f"/v1/evals/{evaluation_id}/documents", data=document_item.model_dump(mode="json"))
 
     def prepare_list(self, evaluation_id: str, filename: Optional[str] = None) -> PreparedRequest:
@@ -127,7 +117,6 @@ class DocumentsMixin:
 
     def prepare_update(self, evaluation_id: str, document_id: str, annotation: Dict[str, Any]) -> PreparedRequest:
         update_request = UpdateEvaluationDocumentRequest(annotation=annotation, annotation_metadata=None)
-
         return PreparedRequest(method="PUT", url=f"/v1/evals/{evaluation_id}/documents/{document_id}", data=update_request.model_dump(mode="json", exclude_none=True))
 
     def prepare_delete(self, evaluation_id: str, document_id: str) -> PreparedRequest:
@@ -153,10 +142,10 @@ class IterationsMixin:
         modality: Modality = "native",
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
         image_resolution_dpi: int = 96,
-        browser_canvas: Literal['A3', 'A4', 'A5'] = 'A4',
+        browser_canvas: BrowserCanvas = "A4",
         n_consensus: int = 1,
     ) -> PreparedRequest:
-        props = InferenceSettings(
+        inference_settings = InferenceSettings(
             model=model,
             temperature=temperature,
             modality=modality,
@@ -166,18 +155,30 @@ class IterationsMixin:
             n_consensus=n_consensus,
         )
 
-        perform_iteration_request = CreateIterationRequest(inference_settings=props, json_schema=json_schema)
+        request = CreateIterationRequest(inference_settings=inference_settings, json_schema=json_schema)
 
-        return PreparedRequest(method="POST", url=f"/v1/evals/{evaluation_id}/iterations/create", data=perform_iteration_request.model_dump(exclude_none=True, mode="json"))
+        return PreparedRequest(method="POST", url=f"/v1/evals/{evaluation_id}/iterations/create", data=request.model_dump(exclude_none=True, mode="json"))
 
     def prepare_update(
-        self, iteration_id: str, json_schema: Dict[str, Any], model: str, temperature: float = 0.0, image_resolution_dpi: int = 96, browser_canvas: Literal['A3', 'A4', 'A5'] = 'A4'
+        self,
+        iteration_id: str,
+        json_schema: Dict[str, Any],
+        model: str,
+        temperature: float = 0.0,
+        modality: Modality = "native",
+        reasoning_effort: ChatCompletionReasoningEffort = "medium",
+        image_resolution_dpi: int = 96,
+        browser_canvas: BrowserCanvas = "A4",
+        n_consensus: int = 1,
     ) -> 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,
         )
 
         iteration_data = Iteration(id=iteration_id, json_schema=json_schema, inference_settings=inference_settings, predictions=[])
@@ -261,7 +262,13 @@ class Evals(SyncAPIResource, EvalsMixin):
             HTTPException if the request fails
         """
         request = self.prepare_update(
-            evaluation_id=evaluation_id, name=name, project_id=project_id, json_schema=json_schema, documents=documents, iterations=iterations, default_inference_settings=default_inference_settings
+            evaluation_id=evaluation_id,
+            name=name,
+            project_id=project_id,
+            json_schema=json_schema,
+            documents=documents,
+            iterations=iterations,
+            default_inference_settings=default_inference_settings,
         )
         response = self._client._prepared_request(request)
         return Evaluation(**response)
@@ -429,7 +436,7 @@ class Iterations(SyncAPIResource, IterationsMixin):
         json_schema: Optional[Dict[str, Any]] = None,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
         image_resolution_dpi: int = 96,
-        browser_canvas: Literal['A3', 'A4', 'A5'] = 'A4',
+        browser_canvas: BrowserCanvas = "A4",
         n_consensus: int = 1,
     ) -> Iteration:
         """
@@ -445,7 +452,7 @@ class Iterations(SyncAPIResource, IterationsMixin):
             image_resolution_dpi: The DPI of the image. Defaults to 96.
             browser_canvas: The canvas size of the browser. Must be one of:
                 - "A3" (11.7in x 16.54in)
-                - "A4" (8.27in x 11.7in) 
+                - "A4" (8.27in x 11.7in)
                 - "A5" (5.83in x 8.27in)
                 Defaults to "A4".
             n_consensus: Number of consensus iterations to perform
@@ -572,7 +579,13 @@ class AsyncEvals(AsyncAPIResource, EvalsMixin):
             HTTPException if the request fails
         """
         request = self.prepare_update(
-            evaluation_id=evaluation_id, name=name, project_id=project_id, json_schema=json_schema, documents=documents, iterations=iterations, default_inference_settings=default_inference_settings
+            evaluation_id=evaluation_id,
+            name=name,
+            project_id=project_id,
+            json_schema=json_schema,
+            documents=documents,
+            iterations=iterations,
+            default_inference_settings=default_inference_settings,
         )
         response = await self._client._prepared_request(request)
         return Evaluation(**response)
@@ -739,7 +752,7 @@ class AsyncIterations(AsyncAPIResource, IterationsMixin):
         json_schema: Optional[Dict[str, Any]] = None,
         reasoning_effort: ChatCompletionReasoningEffort = "medium",
         image_resolution_dpi: int = 96,
-        browser_canvas: Literal['A3', 'A4', 'A5'] = 'A4',
+        browser_canvas: BrowserCanvas = "A4",
         n_consensus: int = 1,
     ) -> Iteration:
         """
@@ -755,7 +768,7 @@ class AsyncIterations(AsyncAPIResource, IterationsMixin):
             image_resolution_dpi: The DPI of the image. Defaults to 96.
             browser_canvas: The canvas size of the browser. Must be one of:
                 - "A3" (11.7in x 16.54in)
-                - "A4" (8.27in x 11.7in) 
+                - "A4" (8.27in x 11.7in)
                 - "A5" (5.83in x 8.27in)
                 Defaults to "A4".
             n_consensus: Number of consensus iterations to perform