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

retab/resources/evaluations/iterations.py

@@ -4,7 +4,7 @@ from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionRea
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
 from ...types.browser_canvas import BrowserCanvas
-from ...types.evaluations import CreateIterationRequest, Iteration, ProcessIterationRequest, IterationDocumentStatusResponse, PatchIterationRequest
+from ...types.projects import CreateIterationRequest, Iteration, ProcessIterationRequest, IterationDocumentStatusResponse, PatchIterationRequest
 from ...types.inference_settings import InferenceSettings
 from ...types.metrics import DistancesResult
 from ...types.modalities import Modality
@@ -14,13 +14,13 @@ from ...types.documents.extractions import RetabParsedChatCompletion
 
 class IterationsMixin:
     def prepare_get(self, evaluation_id: str, iteration_id: str) -> PreparedRequest:
-        return PreparedRequest(method="GET", url=f"/v1/evaluations/{evaluation_id}/iterations/{iteration_id}")
+        return PreparedRequest(method="GET", url=f"/v1/projects/{evaluation_id}/iterations/{iteration_id}")
 
     def prepare_list(self, evaluation_id: str, model: Optional[str] = None) -> PreparedRequest:
         params = {}
         if model:
             params["model"] = model
-        return PreparedRequest(method="GET", url=f"/v1/evaluations/{evaluation_id}/iterations", params=params)
+        return PreparedRequest(method="GET", url=f"/v1/projects/{evaluation_id}/iterations", params=params)
 
     def prepare_create(
         self,
@@ -34,19 +34,27 @@ 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)
 
-        return PreparedRequest(method="POST", url=f"/v1/evaluations/{evaluation_id}/iterations", data=request.model_dump(exclude_unset=True, exclude_defaults=True, mode="json"))
+        return PreparedRequest(method="POST", url=f"/v1/projects/{evaluation_id}/iterations", data=request.model_dump(exclude_unset=True, exclude_defaults=True, mode="json"))
 
     def prepare_update(
         self,
@@ -61,29 +69,39 @@ 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")
+            method="PATCH", url=f"/v1/projects/{evaluation_id}/iterations/{iteration_id}", data=iteration_data.model_dump(exclude_unset=True, exclude_defaults=True, mode="json")
         )
 
     def prepare_delete(self, evaluation_id: str, iteration_id: str) -> PreparedRequest:
-        return PreparedRequest(method="DELETE", url=f"/v1/evaluations/{evaluation_id}/iterations/{iteration_id}")
+        return PreparedRequest(method="DELETE", url=f"/v1/projects/{evaluation_id}/iterations/{iteration_id}")
 
     def prepare_compute_distances(self, evaluation_id: str, iteration_id: str, document_id: str) -> PreparedRequest:
-        return PreparedRequest(method="GET", url=f"/v1/evaluations/{evaluation_id}/iterations/{iteration_id}/documents/{document_id}/distances")
+        return PreparedRequest(method="GET", url=f"/v1/projects/{evaluation_id}/iterations/{iteration_id}/documents/{document_id}/distances")
 
     def prepare_process(
         self,
@@ -96,13 +114,13 @@ class IterationsMixin:
             document_ids=document_ids,
             only_outdated=only_outdated,
         )
-        return PreparedRequest(method="POST", url=f"/v1/evaluations/{evaluation_id}/iterations/{iteration_id}/process", data=request.model_dump(exclude_none=True, mode="json"))
+        return PreparedRequest(method="POST", url=f"/v1/projects/{evaluation_id}/iterations/{iteration_id}/process", data=request.model_dump(exclude_none=True, mode="json"))
 
     def prepare_process_document(self, evaluation_id: str, iteration_id: str, document_id: str) -> PreparedRequest:
-        return PreparedRequest(method="POST", url=f"/v1/evaluations/{evaluation_id}/iterations/{iteration_id}/documents/{document_id}/process", data={"stream": False})
+        return PreparedRequest(method="POST", url=f"/v1/projects/{evaluation_id}/iterations/{iteration_id}/documents/{document_id}/process", data={"stream": False})
 
     def prepare_status(self, evaluation_id: str, iteration_id: str) -> PreparedRequest:
-        return PreparedRequest(method="GET", url=f"/v1/evaluations/{evaluation_id}/iterations/{iteration_id}/status")
+        return PreparedRequest(method="GET", url=f"/v1/projects/{evaluation_id}/iterations/{iteration_id}/status")
 
 
 class Iterations(SyncAPIResource, IterationsMixin):
@@ -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,