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

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.

retab/resources/processors/automations/endpoints.py

@@ -1,6 +1,6 @@
-from typing import Literal, Optional
+from typing import Any, Literal, Optional
 
-from pydantic_core import PydanticUndefined
+from ....types.standards import FieldUnset
 
 from ...._resource import AsyncAPIResource, SyncAPIResource
 from ....utils.ai_models import assert_valid_model_extraction
@@ -15,19 +15,23 @@ class EndpointsMixin:
         name: str,
         webhook_url: str,
         model: str = "gpt-4o-mini",
-        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
-        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
     ) -> PreparedRequest:
         assert_valid_model_extraction(model)
 
-        request = Endpoint(
-            processor_id=processor_id,
-            name=name,
-            webhook_url=webhook_url,
-            webhook_headers=webhook_headers,
-            need_validation=need_validation,
-        )
-        return PreparedRequest(method="POST", url="/v1/processors/automations/endpoints", data=request.model_dump(mode="json"))
+        endpoint_dict: dict[str, Any] = {
+            'processor_id': processor_id,
+            'name': name,
+            'webhook_url': webhook_url,
+        }
+        if webhook_headers is not FieldUnset:
+            endpoint_dict['webhook_headers'] = webhook_headers
+        if need_validation is not FieldUnset:
+            endpoint_dict['need_validation'] = need_validation
+
+        request = Endpoint(**endpoint_dict)
+        return PreparedRequest(method="POST", url="/v1/processors/automations/endpoints", data=request.model_dump(mode="json", exclude_unset=True))
 
     def prepare_list(
         self,
@@ -68,20 +72,26 @@ class EndpointsMixin:
     def prepare_update(
         self,
         endpoint_id: str,
-        name: str = PydanticUndefined,  # type: ignore[assignment]
-        default_language: str = PydanticUndefined,  # type: ignore[assignment]
-        webhook_url: str = PydanticUndefined,  # type: ignore[assignment]
-        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
-        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+        name: str = FieldUnset,
+        default_language: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
     ) -> PreparedRequest:
-        request = UpdateEndpointRequest(
-            name=name,
-            default_language=default_language,
-            webhook_url=webhook_url,
-            webhook_headers=webhook_headers,
-            need_validation=need_validation,
-        )
-        return PreparedRequest(method="PUT", url=f"/v1/processors/automations/endpoints/{endpoint_id}", data=request.model_dump(mode="json"))
+        update_dict: dict[str, Any] = {}
+        if name is not FieldUnset:
+            update_dict['name'] = name
+        if default_language is not FieldUnset:
+            update_dict['default_language'] = default_language
+        if webhook_url is not FieldUnset:
+            update_dict['webhook_url'] = webhook_url
+        if webhook_headers is not FieldUnset:
+            update_dict['webhook_headers'] = webhook_headers
+        if need_validation is not FieldUnset:
+            update_dict['need_validation'] = need_validation
+
+        request = UpdateEndpointRequest(**update_dict)
+        return PreparedRequest(method="PUT", url=f"/v1/processors/automations/endpoints/{endpoint_id}", data=request.model_dump(mode="json", exclude_unset=True))
 
     def prepare_delete(self, endpoint_id: str) -> PreparedRequest:
         return PreparedRequest(method="DELETE", url=f"/v1/processors/automations/endpoints/{endpoint_id}")
@@ -95,8 +105,8 @@ class Endpoints(SyncAPIResource, EndpointsMixin):
         processor_id: str,
         name: str,
         webhook_url: str,
-        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
-        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
     ) -> Endpoint:
         """Create a new endpoint configuration.
 
@@ -168,11 +178,11 @@ class Endpoints(SyncAPIResource, EndpointsMixin):
     def update(
         self,
         endpoint_id: str,
-        name: str = PydanticUndefined,  # type: ignore[assignment]
-        default_language: str = PydanticUndefined,  # type: ignore[assignment]
-        webhook_url: str = PydanticUndefined,  # type: ignore[assignment]
-        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
-        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+        name: str = FieldUnset,
+        default_language: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
     ) -> Endpoint:
         """Update an endpoint configuration.
 
@@ -221,8 +231,8 @@ class AsyncEndpoints(AsyncAPIResource, EndpointsMixin):
         processor_id: str,
         name: str,
         webhook_url: str,
-        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
-        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
     ) -> Endpoint:
         request = self.prepare_create(
             processor_id=processor_id,
@@ -258,11 +268,11 @@ class AsyncEndpoints(AsyncAPIResource, EndpointsMixin):
     async def update(
         self,
         endpoint_id: str,
-        name: str = PydanticUndefined,  # type: ignore[assignment]
-        default_language: str = PydanticUndefined,  # type: ignore[assignment]
-        webhook_url: str = PydanticUndefined,  # type: ignore[assignment]
-        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
-        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+        name: str = FieldUnset,
+        default_language: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
     ) -> Endpoint:
         request = self.prepare_update(
             endpoint_id=endpoint_id,

retab/resources/processors/automations/links.py

@@ -1,10 +1,8 @@
 from typing import Any, Literal, Optional
 
-from pydantic_core import PydanticUndefined
-
 from ...._resource import AsyncAPIResource, SyncAPIResource
 from ....types.automations.links import Link, ListLinks, UpdateLinkRequest
-from ....types.standards import PreparedRequest
+from ....types.standards import PreparedRequest, FieldUnset
 
 
 class LinksMixin:
@@ -15,19 +13,24 @@ class LinksMixin:
         processor_id: str,
         name: str,
         webhook_url: str,
-        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
-        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
-        password: str | None = PydanticUndefined,  # type: ignore[assignment]
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        password: str | None = FieldUnset,
     ) -> PreparedRequest:
-        request = Link(
-            processor_id=processor_id,
-            name=name,
-            webhook_url=webhook_url,
-            webhook_headers=webhook_headers,
-            need_validation=need_validation,
-            password=password,
-        )
-        return PreparedRequest(method="POST", url=self.links_base_url, data=request.model_dump(mode="json"))
+        link_dict: dict[str, Any] = {
+            'processor_id': processor_id,
+            'name': name,
+            'webhook_url': webhook_url,
+        }
+        if webhook_headers is not FieldUnset:
+            link_dict['webhook_headers'] = webhook_headers
+        if need_validation is not FieldUnset:
+            link_dict['need_validation'] = need_validation
+        if password is not FieldUnset:
+            link_dict['password'] = password
+
+        request = Link(**link_dict)
+        return PreparedRequest(method="POST", url=self.links_base_url, data=request.model_dump(mode="json", exclude_unset=True))
 
     def prepare_list(
         self,
@@ -66,19 +69,25 @@ class LinksMixin:
     def prepare_update(
         self,
         link_id: str,
-        name: str = PydanticUndefined,  # type: ignore[assignment]
-        webhook_url: str = PydanticUndefined,  # type: ignore[assignment]
-        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
-        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
-        password: str | None = PydanticUndefined,  # type: ignore[assignment]
+        name: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        password: str | None = FieldUnset,
     ) -> PreparedRequest:
-        request = UpdateLinkRequest(
-            name=name,
-            webhook_url=webhook_url,
-            webhook_headers=webhook_headers,
-            need_validation=need_validation,
-            password=password,
-        )
+        update_dict: dict[str, Any] = {}
+        if name is not FieldUnset:
+            update_dict['name'] = name
+        if webhook_url is not FieldUnset:
+            update_dict['webhook_url'] = webhook_url
+        if webhook_headers is not FieldUnset:
+            update_dict['webhook_headers'] = webhook_headers
+        if need_validation is not FieldUnset:
+            update_dict['need_validation'] = need_validation
+        if password is not FieldUnset:
+            update_dict['password'] = password
+
+        request = UpdateLinkRequest(**update_dict)
         return PreparedRequest(method="PUT", url=f"{self.links_base_url}/{link_id}", data=request.model_dump(mode="json", exclude_unset=True, exclude_defaults=True))
 
     def prepare_delete(self, link_id: str) -> PreparedRequest:
@@ -96,9 +105,9 @@ class Links(SyncAPIResource, LinksMixin):
         processor_id: str,
         name: str,
         webhook_url: str,
-        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
-        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
-        password: str | None = PydanticUndefined,  # type: ignore[assignment]
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        password: str | None = FieldUnset,
     ) -> Link:
         """Create a new extraction link configuration.
 
@@ -174,11 +183,11 @@ class Links(SyncAPIResource, LinksMixin):
     def update(
         self,
         link_id: str,
-        name: str = PydanticUndefined,  # type: ignore[assignment]
-        webhook_url: str = PydanticUndefined,  # type: ignore[assignment]
-        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
-        password: str | None = PydanticUndefined,  # type: ignore[assignment]
-        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+        name: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        password: str | None = FieldUnset,
+        need_validation: bool = FieldUnset,
     ) -> Link:
         """Update an extraction link configuration.
 
@@ -235,9 +244,9 @@ class AsyncLinks(AsyncAPIResource, LinksMixin):
         processor_id: str,
         name: str,
         webhook_url: str,
-        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
-        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
-        password: str | None = PydanticUndefined,  # type: ignore[assignment]
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        password: str | None = FieldUnset,
     ) -> Link:
         request = self.prepare_create(
             processor_id=processor_id,
@@ -272,11 +281,11 @@ class AsyncLinks(AsyncAPIResource, LinksMixin):
     async def update(
         self,
         link_id: str,
-        name: str = PydanticUndefined,  # type: ignore[assignment]
-        webhook_url: str = PydanticUndefined,  # type: ignore[assignment]
-        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
-        password: str | None = PydanticUndefined,  # type: ignore[assignment]
-        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+        name: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        password: str | None = FieldUnset,
+        need_validation: bool = FieldUnset,
     ) -> Link:
         request = self.prepare_update(
             link_id=link_id,