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

{uiform → retab}/resources/processors/client.py

@@ -1,31 +1,29 @@
 import base64
-import datetime
 from io import IOBase
 from pathlib import Path
-from typing import Any, Dict, List, Literal, Optional
+from typing import Any, Dict, List, Literal
 
-import httpx
 import PIL.Image
 from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
-from pydantic import HttpUrl
+from pydantic import BaseModel, HttpUrl
+from pydantic_core import PydanticUndefined
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
 from ..._utils.ai_models import assert_valid_model_extraction
 from ..._utils.mime import MIMEData, prepare_mime_document
+from ...types.browser_canvas import BrowserCanvas
+from ...types.documents.extractions import UiParsedChatCompletion
 from ...types.logs import ProcessorConfig, UpdateProcessorRequest
-from ...types.pagination import ListMetadata
-from ...types.documents.extractions import UiParsedChatCompletion, DocumentExtractRequest
-from pydantic import BaseModel
-
-# from ...types.documents.extractions import DocumentExtractResponse
-from ...types.mime import BaseMIMEData
 from ...types.modalities import Modality
+from ...types.pagination import ListMetadata
 from ...types.standards import PreparedRequest
-from .automations import Automations, AsyncAutomations
+from .automations.client import AsyncAutomations, Automations
 
 
 class ListProcessors(BaseModel):
-    data: List[ProcessorConfig]
+    """Response model for listing processor configurations."""
+
+    data: list[ProcessorConfig]
     list_metadata: ListMetadata
 
 
@@ -33,44 +31,43 @@ class ProcessorsMixin:
     def prepare_create(
         self,
         name: str,
-        json_schema: Dict[str, Any],
+        json_schema: dict[str, Any],
         modality: Modality = "native",
         model: str = "gpt-4o-mini",
-        temperature: float = 0,
-        reasoning_effort: ChatCompletionReasoningEffort = "medium",
-        image_resolution_dpi: Optional[int] = 96,
-        browser_canvas: Optional[Literal['A3', 'A4', 'A5']] = 'A4',
-        n_consensus: int = 1,
+        temperature: float = PydanticUndefined,  # type: ignore[assignment]
+        reasoning_effort: ChatCompletionReasoningEffort = PydanticUndefined,  # type: ignore[assignment]
+        image_resolution_dpi: int = PydanticUndefined,  # type: ignore[assignment]
+        browser_canvas: BrowserCanvas = PydanticUndefined,  # type: ignore[assignment]
+        n_consensus: int = PydanticUndefined,  # type: ignore[assignment]
     ) -> PreparedRequest:
         assert_valid_model_extraction(model)
 
-        data = {
-            "name": name,
-            "json_schema": json_schema,
-            "modality": modality,
-            "model": model,
-            "temperature": temperature,
-            "reasoning_effort": reasoning_effort,
-            "image_resolution_dpi": image_resolution_dpi,
-            "browser_canvas": browser_canvas,
-            "n_consensus": n_consensus,
-        }
+        processor_config = ProcessorConfig(
+            name=name,
+            json_schema=json_schema,
+            modality=modality,
+            model=model,
+            temperature=temperature,
+            reasoning_effort=reasoning_effort,
+            image_resolution_dpi=image_resolution_dpi,
+            browser_canvas=browser_canvas,
+            n_consensus=n_consensus,
+        )
 
-        request = ProcessorConfig.model_validate(data)
-        return PreparedRequest(method="POST", url="/v1/processors", data=request.model_dump(mode='json'))
+        return PreparedRequest(method="POST", url="/v1/processors", data=processor_config.model_dump(mode="json"))
 
     def prepare_list(
         self,
-        before: Optional[str] = None,
-        after: Optional[str] = None,
-        limit: Optional[int] = 10,
-        order: Optional[Literal["asc", "desc"]] = "desc",
+        before: str | None = None,
+        after: str | None = None,
+        limit: int | None = 10,
+        order: Literal["asc", "desc"] | None = "desc",
         # Filtering parameters
-        name: Optional[str] = None,
-        modality: Optional[str] = None,
-        model: Optional[str] = None,
-        schema_id: Optional[str] = None,
-        schema_data_id: Optional[str] = None,
+        name: str | None = None,
+        modality: str | None = None,
+        model: str | None = None,
+        schema_id: str | None = None,
+        schema_data_id: str | None = None,
     ) -> PreparedRequest:
         params = {
             "before": before,
@@ -102,39 +99,32 @@ class ProcessorsMixin:
     def prepare_update(
         self,
         processor_id: str,
-        name: Optional[str] = None,
-        modality: Optional[Modality] = None,
-        image_resolution_dpi: Optional[int] = None,
-        browser_canvas: Optional[Literal['A3', 'A4', 'A5']] = None,
-        model: Optional[str] = None,
-        json_schema: Optional[Dict[str, Any]] = None,
-        temperature: Optional[float] = None,
-        reasoning_effort: Optional[ChatCompletionReasoningEffort] = None,
-        n_consensus: Optional[int] = None,
+        name: str | None = None,
+        modality: Modality | None = None,
+        image_resolution_dpi: int | None = None,
+        browser_canvas: BrowserCanvas | None = None,
+        model: str | None = None,
+        json_schema: dict[str, Any] | None = None,
+        temperature: float | None = None,
+        reasoning_effort: ChatCompletionReasoningEffort | None = None,
+        n_consensus: int | None = None,
     ) -> PreparedRequest:
-        data: dict[str, Any] = {}
-
-        if name is not None:
-            data["name"] = name
-        if modality is not None:
-            data["modality"] = modality
-        if image_resolution_dpi is not None:
-            data["image_resolution_dpi"] = image_resolution_dpi
-        if browser_canvas is not None:
-            data["browser_canvas"] = browser_canvas
         if model is not None:
             assert_valid_model_extraction(model)
-            data["model"] = model
-        if json_schema is not None:
-            data["json_schema"] = json_schema
-        if temperature is not None:
-            data["temperature"] = temperature
-        if reasoning_effort is not None:
-            data["reasoning_effort"] = reasoning_effort
-        if n_consensus is not None:
-            data["n_consensus"] = n_consensus
-        request = UpdateProcessorRequest.model_validate(data)
-        return PreparedRequest(method="PUT", url=f"/v1/processors/{processor_id}", data=request.model_dump(mode='json'))
+
+        update_request = UpdateProcessorRequest(
+            name=name,
+            modality=modality,
+            image_resolution_dpi=image_resolution_dpi,
+            browser_canvas=browser_canvas,
+            model=model,
+            json_schema=json_schema,
+            temperature=temperature,
+            reasoning_effort=reasoning_effort,
+            n_consensus=n_consensus,
+        )
+
+        return PreparedRequest(method="PUT", url=f"/v1/processors/{processor_id}", data=update_request.model_dump(mode="json", exclude_none=True))
 
     def prepare_delete(self, processor_id: str) -> PreparedRequest:
         return PreparedRequest(method="DELETE", url=f"/v1/processors/{processor_id}")
@@ -142,10 +132,10 @@ class ProcessorsMixin:
     def prepare_submit(
         self,
         processor_id: str,
-        document: Optional[Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl] = None,
-        documents: Optional[List[Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl]] = None,
-        temperature: Optional[float] = None,
-        seed: Optional[int] = None,
+        document: Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl | None = None,
+        documents: list[Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl] | None = None,
+        temperature: float | None = None,
+        seed: int | None = None,
         store: bool = True,
     ) -> PreparedRequest:
         """Prepare a request to submit documents to a processor.
@@ -164,10 +154,10 @@ class ProcessorsMixin:
         # Validate that either document or documents is provided, but not both
         if not document and not documents:
             raise ValueError("Either 'document' or 'documents' must be provided")
-        
+
         if document and documents:
             raise ValueError("Provide either 'document' (single) or 'documents' (multiple), not both")
-        
+
         # Prepare form data parameters
         form_data = {
             "temperature": temperature,
@@ -183,31 +173,23 @@ class ProcessorsMixin:
             # Convert document to MIMEData if needed
             mime_document = prepare_mime_document(document)
             # Single document upload
-            files["document"] = (
-                mime_document.filename,
-                base64.b64decode(mime_document.content),
-                mime_document.mime_type
-            )
+            files["document"] = (mime_document.filename, base64.b64decode(mime_document.content), mime_document.mime_type)
         elif documents:
             # Multiple documents upload - httpx supports multiple files with same field name using a list
             files_list = []
             for doc in documents:
                 # Convert each document to MIMEData if needed
                 mime_doc = prepare_mime_document(doc)
-                files_list.append((
-                    "documents",  # field name
+                files_list.append(
                     (
-                        mime_doc.filename,
-                        base64.b64decode(mime_doc.content),
-                        mime_doc.mime_type
+                        "documents",  # field name
+                        (mime_doc.filename, base64.b64decode(mime_doc.content), mime_doc.mime_type),
                     )
-                ))
+                )
             files = files_list
 
         url = f"/v1/processors/{processor_id}/submit"
-        # if stream:
-        #     url = f"/v1/processors/{processor_id}/submit/stream"
-        
+
         return PreparedRequest(method="POST", url=url, form_data=form_data, files=files)
 
 
@@ -224,11 +206,11 @@ class Processors(SyncAPIResource, ProcessorsMixin):
         json_schema: Dict[str, Any],
         modality: Modality = "native",
         model: str = "gpt-4o-mini",
-        temperature: float = 0,
-        reasoning_effort: ChatCompletionReasoningEffort = "medium",
-        image_resolution_dpi: Optional[int] = 96,
-        browser_canvas: Optional[Literal['A3', 'A4', 'A5']] = 'A4',
-        n_consensus: int = 1,
+        temperature: float = PydanticUndefined,  # type: ignore[assignment]
+        reasoning_effort: ChatCompletionReasoningEffort = PydanticUndefined,  # type: ignore[assignment]
+        image_resolution_dpi: int = PydanticUndefined,  # type: ignore[assignment]
+        browser_canvas: BrowserCanvas = PydanticUndefined,  # type: ignore[assignment]
+        n_consensus: int = PydanticUndefined,  # type: ignore[assignment]
     ) -> ProcessorConfig:
         """Create a new processor configuration.
 
@@ -245,22 +227,32 @@ class Processors(SyncAPIResource, ProcessorsMixin):
         Returns:
             ProcessorConfig: The created processor configuration
         """
-        request = self.prepare_create(name, json_schema, modality, model, temperature, reasoning_effort, image_resolution_dpi, browser_canvas, n_consensus)
+        request = self.prepare_create(
+            name=name,
+            json_schema=json_schema,
+            modality=modality,
+            model=model,
+            temperature=temperature,
+            reasoning_effort=reasoning_effort,
+            image_resolution_dpi=image_resolution_dpi,
+            browser_canvas=browser_canvas,
+            n_consensus=n_consensus,
+        )
         response = self._client._prepared_request(request)
         print(f"Processor ID: {response['id']}. Processor available at https://www.uiform.com/dashboard/processors/{response['id']}")
         return ProcessorConfig.model_validate(response)
 
     def list(
         self,
-        before: Optional[str] = None,
-        after: Optional[str] = None,
-        limit: Optional[int] = 10,
-        order: Optional[Literal["asc", "desc"]] = "desc",
-        name: Optional[str] = None,
-        modality: Optional[str] = None,
-        model: Optional[str] = None,
-        schema_id: Optional[str] = None,
-        schema_data_id: Optional[str] = None,
+        before: str | None = None,
+        after: str | None = None,
+        limit: int | None = 10,
+        order: Literal["asc", "desc"] | None = "desc",
+        name: str | None = None,
+        modality: str | None = None,
+        model: str | None = None,
+        schema_id: str | None = None,
+        schema_data_id: str | None = None,
     ) -> ListProcessors:
         """List processor configurations with pagination support.
 
@@ -298,15 +290,15 @@ class Processors(SyncAPIResource, ProcessorsMixin):
     def update(
         self,
         processor_id: str,
-        name: Optional[str] = None,
-        modality: Optional[Modality] = None,
-        image_resolution_dpi: Optional[int] = None,
-        browser_canvas: Optional[Literal['A3', 'A4', 'A5']] = None,
-        model: Optional[str] = None,
-        json_schema: Optional[Dict[str, Any]] = None,
-        temperature: Optional[float] = None,
-        reasoning_effort: Optional[ChatCompletionReasoningEffort] = None,
-        n_consensus: Optional[int] = None,
+        name: str | None = None,
+        modality: Modality | None = None,
+        image_resolution_dpi: int | None = None,
+        browser_canvas: BrowserCanvas | None = None,
+        model: str | None = None,
+        json_schema: dict[str, Any] | None = None,
+        temperature: float | None = None,
+        reasoning_effort: ChatCompletionReasoningEffort | None = None,
+        n_consensus: int | None = None,
     ) -> ProcessorConfig:
         """Update a processor configuration.
 
@@ -324,7 +316,18 @@ class Processors(SyncAPIResource, ProcessorsMixin):
         Returns:
             ProcessorConfig: The updated processor configuration
         """
-        request = self.prepare_update(processor_id, name, modality, image_resolution_dpi, browser_canvas, model, json_schema, temperature, reasoning_effort, n_consensus)
+        request = self.prepare_update(
+            processor_id=processor_id,
+            name=name,
+            modality=modality,
+            image_resolution_dpi=image_resolution_dpi,
+            browser_canvas=browser_canvas,
+            model=model,
+            json_schema=json_schema,
+            temperature=temperature,
+            reasoning_effort=reasoning_effort,
+            n_consensus=n_consensus,
+        )
         response = self._client._prepared_request(request)
         return ProcessorConfig.model_validate(response)
 
@@ -341,10 +344,10 @@ class Processors(SyncAPIResource, ProcessorsMixin):
     def submit(
         self,
         processor_id: str,
-        document: Optional[Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl] = None,
-        documents: Optional[List[Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl]] = None,
-        temperature: Optional[float] = None,
-        seed: Optional[int] = None,
+        document: Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl | None = None,
+        documents: List[Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl] | None = None,
+        temperature: float | None = None,
+        seed: int | None = None,
         store: bool = True,
     ) -> UiParsedChatCompletion:
         """Submit documents to a processor for processing.
@@ -360,14 +363,7 @@ class Processors(SyncAPIResource, ProcessorsMixin):
         Returns:
             UiParsedChatCompletion: The processing result
         """
-        request = self.prepare_submit(
-            processor_id=processor_id,
-            document=document,
-            documents=documents,
-            temperature=temperature,
-            seed=seed,
-            store=store
-        )
+        request = self.prepare_submit(processor_id=processor_id, document=document, documents=documents, temperature=temperature, seed=seed, store=store)
         response = self._client._prepared_request(request)
         return UiParsedChatCompletion.model_validate(response)
 
@@ -385,29 +381,39 @@ class AsyncProcessors(AsyncAPIResource, ProcessorsMixin):
         json_schema: Dict[str, Any],
         modality: Modality = "native",
         model: str = "gpt-4o-mini",
-        temperature: float = 0,
-        reasoning_effort: ChatCompletionReasoningEffort = "medium",
-        image_resolution_dpi: Optional[int] = 96,
-        browser_canvas: Optional[Literal['A3', 'A4', 'A5']] = 'A4',
-        n_consensus: int = 1,
+        temperature: float = PydanticUndefined,  # type: ignore[assignment]
+        reasoning_effort: ChatCompletionReasoningEffort = PydanticUndefined,  # type: ignore[assignment]
+        image_resolution_dpi: int = PydanticUndefined,  # type: ignore[assignment]
+        browser_canvas: BrowserCanvas = PydanticUndefined,  # type: ignore[assignment]
+        n_consensus: int = PydanticUndefined,  # type: ignore[assignment]
     ) -> ProcessorConfig:
-        request = self.prepare_create(name, json_schema, modality, model, temperature, reasoning_effort, image_resolution_dpi, browser_canvas, n_consensus)
+        request = self.prepare_create(
+            name=name,
+            json_schema=json_schema,
+            modality=modality,
+            model=model,
+            temperature=temperature,
+            reasoning_effort=reasoning_effort,
+            image_resolution_dpi=image_resolution_dpi,
+            browser_canvas=browser_canvas,
+            n_consensus=n_consensus,
+        )
         response = await self._client._prepared_request(request)
         print(f"Processor ID: {response['id']}. Processor available at https://www.uiform.com/dashboard/processors/{response['id']}")
-        
+
         return ProcessorConfig.model_validate(response)
 
     async def list(
         self,
-        before: Optional[str] = None,
-        after: Optional[str] = None,
-        limit: Optional[int] = 10,
-        order: Optional[Literal["asc", "desc"]] = "desc",
-        name: Optional[str] = None,
-        modality: Optional[str] = None,
-        model: Optional[str] = None,
-        schema_id: Optional[str] = None,
-        schema_data_id: Optional[str] = None,
+        before: str | None = None,
+        after: str | None = None,
+        limit: int | None = 10,
+        order: Literal["asc", "desc"] | None = "desc",
+        name: str | None = None,
+        modality: str | None = None,
+        model: str | None = None,
+        schema_id: str | None = None,
+        schema_data_id: str | None = None,
     ) -> ListProcessors:
         request = self.prepare_list(before, after, limit, order, name, modality, model, schema_id, schema_data_id)
         response = await self._client._prepared_request(request)
@@ -421,16 +427,32 @@ class AsyncProcessors(AsyncAPIResource, ProcessorsMixin):
     async def update(
         self,
         processor_id: str,
-        name: Optional[str] = None,
-        modality: Optional[Modality] = None,
-        image_resolution_dpi: Optional[int] = None,
-        browser_canvas: Optional[Literal['A3', 'A4', 'A5']] = None,
-        model: Optional[str] = None,
-        json_schema: Optional[Dict[str, Any]] = None,
-        temperature: Optional[float] = None,
-        reasoning_effort: Optional[ChatCompletionReasoningEffort] = None,
-        n_consensus: Optional[int] = None,
+        name: str | None = None,
+        modality: Modality | None = None,
+        image_resolution_dpi: int | None = None,
+        browser_canvas: BrowserCanvas | None = None,
+        model: str | None = None,
+        json_schema: dict[str, Any] | None = None,
+        temperature: float | None = None,
+        reasoning_effort: ChatCompletionReasoningEffort | None = None,
+        n_consensus: int | None = None,
     ) -> ProcessorConfig:
+        """Update a processor configuration.
+
+        Args:
+            processor_id: ID of the processor to update
+            name: New name for the processor
+            modality: New processing modality
+            image_resolution_dpi: New image resolution DPI
+            browser_canvas: New browser canvas size
+            model: New AI model
+            json_schema: New JSON schema for the processor
+            temperature: New temperature setting
+            reasoning_effort: The effort level for the model to reason about the input data.
+            n_consensus: New number of consensus required
+        Returns:
+            ProcessorConfig: The updated processor configuration
+        """
         request = self.prepare_update(processor_id, name, modality, image_resolution_dpi, browser_canvas, model, json_schema, temperature, reasoning_effort, n_consensus)
         response = await self._client._prepared_request(request)
         return ProcessorConfig.model_validate(response)
@@ -443,10 +465,10 @@ class AsyncProcessors(AsyncAPIResource, ProcessorsMixin):
     async def submit(
         self,
         processor_id: str,
-        document: Optional[Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl] = None,
-        documents: Optional[List[Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl]] = None,
-        temperature: Optional[float] = None,
-        seed: Optional[int] = None,
+        document: Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl | None = None,
+        documents: List[Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl] | None = None,
+        temperature: float | None = None,
+        seed: int | None = None,
         store: bool = True,
     ) -> UiParsedChatCompletion:
         """Submit documents to a processor for processing.
@@ -462,13 +484,6 @@ class AsyncProcessors(AsyncAPIResource, ProcessorsMixin):
         Returns:
             UiParsedChatCompletion: The processing result
         """
-        request = self.prepare_submit(
-            processor_id=processor_id,
-            document=document,
-            documents=documents,
-            temperature=temperature,
-            seed=seed,
-            store=store
-        )
+        request = self.prepare_submit(processor_id=processor_id, document=document, documents=documents, temperature=temperature, seed=seed, store=store)
         response = await self._client._prepared_request(request)
         return UiParsedChatCompletion.model_validate(response)