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

retab/resources/consensus/responses_stream.py

@@ -102,7 +102,7 @@ class BaseResponsesMixin:
 
 
 class Responses(SyncAPIResource, BaseResponsesMixin):
-    """UiForm Responses API compatible with OpenAI Responses API"""
+    """Retab Responses API compatible with OpenAI Responses API"""
 
     @as_context_manager
     def stream(
@@ -117,7 +117,7 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
         idempotency_key: Optional[str] = None,
     ) -> Generator[UiResponse, None, None]:
         """
-        Create a completion using the UiForm API with streaming enabled.
+        Create a completion using the Retab API with streaming enabled.
 
         Args:
             model: The model to use
@@ -134,7 +134,7 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
 
         Usage:
         ```python
-        with uiform.responses.stream(model, input, text, temperature, reasoning) as stream:
+        with retab.responses.stream(model, input, text, temperature, reasoning) as stream:
             for response in stream:
                 print(response)
         ```
@@ -171,7 +171,7 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
         idempotency_key: Optional[str] = None,
     ) -> Generator[UiResponse, None, None]:
         """
-        Parse content using the UiForm API with streaming enabled.
+        Parse content using the Retab API with streaming enabled.
 
         Args:
             model: The model to use
@@ -188,7 +188,7 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
 
         Usage:
         ```python
-        with uiform.responses.stream_parse(model, input, MyModel, temperature, reasoning) as stream:
+        with retab.responses.stream_parse(model, input, MyModel, temperature, reasoning) as stream:
             for response in stream:
                 print(response)
         ```
@@ -214,7 +214,7 @@ class Responses(SyncAPIResource, BaseResponsesMixin):
 
 
 class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
-    """UiForm Responses API compatible with OpenAI Responses API for async usage"""
+    """Retab Responses API compatible with OpenAI Responses API for async usage"""
 
     @as_async_context_manager
     async def stream(
@@ -229,7 +229,7 @@ class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
         idempotency_key: Optional[str] = None,
     ) -> AsyncGenerator[UiResponse, None]:
         """
-        Create a completion using the UiForm API asynchronously with streaming enabled.
+        Create a completion using the Retab API asynchronously with streaming enabled.
 
         Args:
             model: The model to use
@@ -246,7 +246,7 @@ class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
 
         Usage:
         ```python
-        async with uiform.responses.async_stream(model, input, text, temperature, reasoning) as stream:
+        async with retab.responses.async_stream(model, input, text, temperature, reasoning) as stream:
             async for response in stream:
                 print(response)
         ```
@@ -283,7 +283,7 @@ class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
         idempotency_key: Optional[str] = None,
     ) -> AsyncGenerator[UiResponse, None]:
         """
-        Parse content using the UiForm API asynchronously with streaming enabled.
+        Parse content using the Retab API asynchronously with streaming enabled.
 
         Args:
             model: The model to use
@@ -300,7 +300,7 @@ class AsyncResponses(AsyncAPIResource, BaseResponsesMixin):
 
         Usage:
         ```python
-        async with uiform.responses.async_stream_parse(model, input, MyModel, temperature, reasoning) as stream:
+        async with retab.responses.async_stream_parse(model, input, MyModel, temperature, reasoning) as stream:
             async for response in stream:
                 print(response)
         ```

retab/resources/documents/client.py

@@ -5,18 +5,34 @@ from typing import Any
 import PIL.Image
 from pydantic import HttpUrl
 from pydantic_core import PydanticUndefined
+from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
-from ..._utils.json_schema import load_json_schema
+from ..._utils.json_schema import load_json_schema, filter_auxiliary_fields_json
 from ..._utils.mime import convert_mime_data_to_pil_image, prepare_mime_document
+from ..._utils.ai_models import assert_valid_model_extraction
 from ...types.documents.create_messages import DocumentCreateInputRequest, DocumentCreateMessageRequest, DocumentMessage
+from ...types.documents.extractions import DocumentExtractRequest, UiParsedChatCompletion
 from ...types.browser_canvas import BrowserCanvas
 from ...types.mime import MIMEData
 from ...types.modalities import Modality
+from ...types.schemas.object import Schema
 from ...types.standards import PreparedRequest
 from .extractions import AsyncExtractions, Extractions
 
 
+def maybe_parse_to_pydantic(schema: Schema, response: UiParsedChatCompletion, allow_partial: bool = False) -> UiParsedChatCompletion:
+    if response.choices[0].message.content:
+        try:
+            if allow_partial:
+                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:
+            pass
+    return response
+
+
 class BaseDocumentsMixin:
     def _prepare_create_messages(
         self,
@@ -75,11 +91,11 @@ class Documents(SyncAPIResource, BaseDocumentsMixin):
 
     def __init__(self, client: Any) -> None:
         super().__init__(client=client)
-        self.extractions = Extractions(client=client)
+        #self.extractions_api = Extractions(client=client)
         # self.batch = Batch(client=client)
 
     def correct_image_orientation(self, document: Path | str | IOBase | MIMEData | PIL.Image.Image) -> PIL.Image.Image:
-        """Corrects the orientation of an image using the UiForm API.
+        """Corrects the orientation of an image using the Retab API.
 
         This method takes an image in various formats and returns a PIL Image with corrected orientation.
         Useful for handling images from mobile devices or cameras that may have incorrect EXIF orientation.
@@ -96,7 +112,7 @@ class Documents(SyncAPIResource, BaseDocumentsMixin):
 
         Raises:
             ValueError: If the input is not a valid image
-            UiformAPIError: If the API request fails
+            RetabAPIError: If the API request fails
         """
         request = self._prepare_correct_image_orientation(document)
         response = self._client._prepared_request(request)
@@ -112,7 +128,7 @@ class Documents(SyncAPIResource, BaseDocumentsMixin):
         idempotency_key: str | None = None,
     ) -> DocumentMessage:
         """
-        Create document messages from a file using the UiForm API.
+        Create document messages from a file using the Retab API.
 
         Args:
             document: The document to process. Can be a file path (Path or str) or a file-like object.
@@ -124,7 +140,7 @@ class Documents(SyncAPIResource, BaseDocumentsMixin):
             DocumentMessage: The processed document message containing extracted content.
 
         Raises:
-            UiformAPIError: If the API request fails.
+            RetabAPIError: If the API request fails.
         """
         request = self._prepare_create_messages(
             document=document, modality=modality, image_resolution_dpi=image_resolution_dpi, browser_canvas=browser_canvas, idempotency_key=idempotency_key
@@ -142,7 +158,7 @@ class Documents(SyncAPIResource, BaseDocumentsMixin):
         idempotency_key: str | None = None,
     ) -> DocumentMessage:
         """
-        Create document inputs (messages with schema) from a file using the UiForm API.
+        Create document inputs (messages with schema) from a file using the Retab API.
 
         Args:
             document: The document to process. Can be a file path (Path or str), file-like object, MIMEData, PIL Image, or URL.
@@ -155,7 +171,7 @@ class Documents(SyncAPIResource, BaseDocumentsMixin):
             DocumentMessage: The processed document message containing extracted content with schema context.
 
         Raises:
-            UiformAPIError: If the API request fails.
+            RetabAPIError: If the API request fails.
         """
         request = self._prepare_create_inputs(
             document=document,
@@ -168,13 +184,98 @@ class Documents(SyncAPIResource, BaseDocumentsMixin):
         response = self._client._prepared_request(request)
         return DocumentMessage.model_validate(response)
 
+    def extract(
+        self,
+        json_schema: dict[str, Any] | Path | str,
+        model: str,
+        document: Path | str | IOBase | HttpUrl | None = None,
+        documents: list[Path | str | IOBase | HttpUrl] | None = None,
+        image_resolution_dpi: int = PydanticUndefined,  # type: ignore[assignment]
+        browser_canvas: BrowserCanvas = PydanticUndefined,  # type: ignore[assignment]
+        temperature: float = PydanticUndefined,  # type: ignore[assignment]
+        modality: Modality = PydanticUndefined,  # type: ignore[assignment]
+        reasoning_effort: ChatCompletionReasoningEffort = PydanticUndefined,  # type: ignore[assignment]
+        n_consensus: int = PydanticUndefined,  # type: ignore[assignment]
+        idempotency_key: str | None = None,
+        store: bool = False,
+    ) -> UiParsedChatCompletion:
+        """
+        Process one or more documents using the Retab API for structured data extraction.
+        
+        This method provides a direct interface to document extraction functionality,
+        intended to replace the current `.extractions.parse()` pattern.
+
+        Args:
+            json_schema: JSON schema defining the expected data structure
+            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
+            n_consensus: Number of consensus extractions to perform
+            idempotency_key: Idempotency key for request
+            store: Whether to store the document in the Retab database
+            
+        Returns:
+            UiParsedChatCompletion: Parsed response from the API
+            
+        Raises:
+            ValueError: If neither document nor documents is provided, or if both are provided
+            HTTPException: If the request fails
+        """
+        assert_valid_model_extraction(model)
+
+        json_schema = load_json_schema(json_schema)
+
+        # 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)
+        request = DocumentExtractRequest(
+            json_schema=json_schema,
+            documents=processed_documents,
+            model=model,
+            temperature=temperature,
+            stream=False,
+            modality=modality,
+            store=store,
+            reasoning_effort=reasoning_effort,
+            n_consensus=n_consensus,
+            image_resolution_dpi=image_resolution_dpi,
+            browser_canvas=browser_canvas,
+        )
+
+        prepared_request = PreparedRequest(
+            method="POST", 
+            url="/v1/documents/extract", 
+            data=request.model_dump(mode="json", exclude_unset=True, exclude_defaults=True), 
+            idempotency_key=idempotency_key
+        )
+        
+        response = self._client._prepared_request(prepared_request)
+
+        schema = Schema(json_schema=load_json_schema(json_schema))
+        return maybe_parse_to_pydantic(schema, UiParsedChatCompletion.model_validate(response))
+
 
 class AsyncDocuments(AsyncAPIResource, BaseDocumentsMixin):
     """Documents API wrapper for asynchronous usage."""
 
     def __init__(self, client: Any) -> None:
         super().__init__(client=client)
-        self.extractions = AsyncExtractions(client=client)
+        #self.extractions_api = AsyncExtractions(client=client)
 
     async def create_messages(
         self,
@@ -185,7 +286,7 @@ class AsyncDocuments(AsyncAPIResource, BaseDocumentsMixin):
         idempotency_key: str | None = None,
     ) -> DocumentMessage:
         """
-        Create document messages from a file using the UiForm API asynchronously.
+        Create document messages from a file using the Retab API asynchronously.
 
         Args:
             document: The document to process. Can be a file path (Path or str) or a file-like object.
@@ -195,7 +296,7 @@ class AsyncDocuments(AsyncAPIResource, BaseDocumentsMixin):
             DocumentMessage: The processed document message containing extracted content.
 
         Raises:
-            UiformAPIError: If the API request fails.
+            RetabAPIError: If the API request fails.
         """
         request = self._prepare_create_messages(
             document=document,
@@ -217,7 +318,7 @@ class AsyncDocuments(AsyncAPIResource, BaseDocumentsMixin):
         idempotency_key: str | None = None,
     ) -> DocumentMessage:
         """
-        Create document inputs (messages with schema) from a file using the UiForm API asynchronously.
+        Create document inputs (messages with schema) from a file using the Retab API asynchronously.
 
         Args:
             document: The document to process. Can be a file path (Path or str), file-like object, MIMEData, PIL Image, or URL.
@@ -230,7 +331,7 @@ class AsyncDocuments(AsyncAPIResource, BaseDocumentsMixin):
             DocumentMessage: The processed document message containing extracted content with schema context.
 
         Raises:
-            UiformAPIError: If the API request fails.
+            RetabAPIError: If the API request fails.
         """
         request = self._prepare_create_inputs(
             document=document,
@@ -244,7 +345,7 @@ class AsyncDocuments(AsyncAPIResource, BaseDocumentsMixin):
         return DocumentMessage.model_validate(response)
 
     async def correct_image_orientation(self, document: Path | str | IOBase | MIMEData | PIL.Image.Image) -> PIL.Image.Image:
-        """Corrects the orientation of an image using the UiForm API asynchronously.
+        """Corrects the orientation of an image using the Retab API asynchronously.
 
         This method takes an image in various formats and returns a PIL Image with corrected orientation.
         Useful for handling images from mobile devices or cameras that may have incorrect EXIF orientation.
@@ -261,9 +362,94 @@ class AsyncDocuments(AsyncAPIResource, BaseDocumentsMixin):
 
         Raises:
             ValueError: If the input is not a valid image
-            UiformAPIError: If the API request fails
+            RetabAPIError: If the API request fails
         """
         request = self._prepare_correct_image_orientation(document)
         response = await self._client._prepared_request(request)
         mime_response = MIMEData.model_validate(response["document"])
         return convert_mime_data_to_pil_image(mime_response)
+
+    async def extract(
+        self,
+        json_schema: dict[str, Any] | Path | str,
+        model: str,
+        document: Path | str | IOBase | HttpUrl | None = None,
+        documents: list[Path | str | IOBase | HttpUrl] | None = None,
+        image_resolution_dpi: int = PydanticUndefined,  # type: ignore[assignment]
+        browser_canvas: BrowserCanvas = PydanticUndefined,  # type: ignore[assignment]
+        temperature: float = PydanticUndefined,  # type: ignore[assignment]
+        modality: Modality = PydanticUndefined,  # type: ignore[assignment]
+        reasoning_effort: ChatCompletionReasoningEffort = PydanticUndefined,  # type: ignore[assignment]
+        n_consensus: int = PydanticUndefined,  # type: ignore[assignment]
+        idempotency_key: str | None = None,
+        store: bool = False,
+    ) -> UiParsedChatCompletion:
+        """
+        Process one or more documents using the Retab API for structured data extraction asynchronously.
+        
+        This method provides a direct interface to document extraction functionality,
+        intended to replace the current `.extractions.parse()` pattern.
+
+        Args:
+            json_schema: JSON schema defining the expected data structure
+            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
+            n_consensus: Number of consensus extractions to perform
+            idempotency_key: Idempotency key for request
+            store: Whether to store the document in the Retab database
+            
+        Returns:
+            UiParsedChatCompletion: Parsed response from the API
+            
+        Raises:
+            ValueError: If neither document nor documents is provided, or if both are provided
+            HTTPException: If the request fails
+        """
+        assert_valid_model_extraction(model)
+
+        json_schema = load_json_schema(json_schema)
+
+        # 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)
+        request = DocumentExtractRequest(
+            json_schema=json_schema,
+            documents=processed_documents,
+            model=model,
+            temperature=temperature,
+            stream=False,
+            modality=modality,
+            store=store,
+            reasoning_effort=reasoning_effort,
+            n_consensus=n_consensus,
+            image_resolution_dpi=image_resolution_dpi,
+            browser_canvas=browser_canvas,
+        )
+
+        prepared_request = PreparedRequest(
+            method="POST", 
+            url="/v1/documents/extract", 
+            data=request.model_dump(mode="json", exclude_unset=True, exclude_defaults=True), 
+            idempotency_key=idempotency_key
+        )
+        
+        response = await self._client._prepared_request(prepared_request)
+
+        schema = Schema(json_schema=load_json_schema(json_schema))
+        return maybe_parse_to_pydantic(schema, UiParsedChatCompletion.model_validate(response))

retab/resources/documents/extractions.py

@@ -18,7 +18,7 @@ from ..._utils.ai_models import assert_valid_model_extraction
 from ..._utils.json_schema import filter_auxiliary_fields_json, load_json_schema, unflatten_dict
 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.chat import ChatCompletionRetabMessage
 from ...types.documents.extractions import DocumentExtractRequest, LogExtractionRequest, UiParsedChatCompletion, UiParsedChatCompletionChunk, UiParsedChoice
 from ...types.browser_canvas import BrowserCanvas
 from ...types.modalities import Modality
@@ -97,8 +97,8 @@ class BaseExtractionsMixin:
         model: str,
         temperature: float,
         completion: Any | None = None,
-        # The messages can be provided in different formats, we will convert them to the UiForm-compatible format
-        messages: list[ChatCompletionUiformMessage] | None = None,
+        # The messages can be provided in different formats, we will convert them to the Retab-compatible format
+        messages: list[ChatCompletionRetabMessage] | None = None,
         openai_messages: list[ChatCompletionMessageParam] | None = None,
         anthropic_messages: list[MessageParam] | None = None,
         anthropic_system_prompt: str | None = None,
@@ -154,7 +154,7 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
         store: bool = False,
     ) -> UiParsedChatCompletion:
         """
-        Process one or more documents using the UiForm API.
+        Process one or more documents using the Retab API.
 
         Args:
             json_schema: JSON schema defining the expected data structure
@@ -168,7 +168,7 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
             reasoning_effort: The effort level for the model to reason about the input data.
             n_consensus: Number of consensus extractions to perform (default: 1 which computes a single extraction and the likelihoods comes from the model logprobs)
             idempotency_key: Idempotency key for request
-            store: Whether to store the document in the UiForm database
+            store: Whether to store the document in the Retab database
         Returns:
             UiParsedChatCompletion: Parsed response from the API
         Raises:
@@ -214,7 +214,7 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
         store: bool = False,
     ) -> Generator[UiParsedChatCompletion, None, None]:
         """
-        Process one or more documents using the UiForm API with streaming enabled.
+        Process one or more documents using the Retab API with streaming enabled.
 
         Args:
             json_schema: JSON schema defining the expected data structure
@@ -228,7 +228,7 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
             reasoning_effort: The effort level for the model to reason about the input data.
             n_consensus: Number of consensus extractions to perform (default: 1 which computes a single extraction and the likelihoods comes from the model logprobs)
             idempotency_key: Idempotency key for request
-            store: Whether to store the document in the UiForm database
+            store: Whether to store the document in the Retab database
 
         Returns:
             Generator[UiParsedChatCompletion]: Stream of parsed responses
@@ -238,12 +238,12 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
         Usage:
         ```python
         # Single document
-        with uiform.documents.extractions.stream(json_schema, model, document=document) as stream:
+        with retab.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:
+        with retab.documents.extractions.stream(json_schema, model, documents=[doc1, doc2]) as stream:
             for response in stream:
                 print(response)
         ```
@@ -311,8 +311,8 @@ class Extractions(SyncAPIResource, BaseExtractionsMixin):
         model: str,
         temperature: float,
         completion: Any | None = None,
-        # The messages can be provided in different formats, we will convert them to the UiForm-compatible format
-        messages: list[ChatCompletionUiformMessage] | None = None,
+        # The messages can be provided in different formats, we will convert them to the Retab-compatible format
+        messages: list[ChatCompletionRetabMessage] | None = None,
         openai_messages: list[ChatCompletionMessageParam] | None = None,
         anthropic_messages: list[MessageParam] | None = None,
         anthropic_system_prompt: str | None = None,
@@ -369,7 +369,7 @@ class AsyncExtractions(AsyncAPIResource, BaseExtractionsMixin):
             reasoning_effort: The effort level for the model to reason about the input data.
             n_consensus: Number of consensus extractions to perform (default: 1 which computes a single extraction and the likelihoods comes from the model logprobs)
             idempotency_key: Idempotency key for request
-            store: Whether to store the document in the UiForm database
+            store: Whether to store the document in the Retab database
         Returns:
             UiParsedChatCompletion: Parsed response from the API.
         Raises:
@@ -425,7 +425,7 @@ class AsyncExtractions(AsyncAPIResource, BaseExtractionsMixin):
             reasoning_effort: The effort level for the model to reason about the input data.
             n_consensus: Number of consensus extractions to perform (default: 1 which computes a single extraction and the likelihoods comes from the model logprobs)
             idempotency_key: Idempotency key for request
-            store: Whether to store the document in the UiForm database
+            store: Whether to store the document in the Retab database
         Returns:
             AsyncGenerator[UiParsedChatCompletion, None]: Stream of parsed responses.
         Raises:
@@ -434,12 +434,12 @@ class AsyncExtractions(AsyncAPIResource, BaseExtractionsMixin):
         Usage:
         ```python
         # Single document
-        async with uiform.documents.extractions.stream(json_schema, model, document=document) as stream:
+        async with retab.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 with retab.documents.extractions.stream(json_schema, model, documents=[doc1, doc2]) as stream:
             async for response in stream:
                 print(response)
         ```
@@ -507,8 +507,8 @@ class AsyncExtractions(AsyncAPIResource, BaseExtractionsMixin):
         model: str,
         temperature: float,
         completion: Any | None = None,
-        # The messages can be provided in different formats, we will convert them to the UiForm-compatible format
-        messages: list[ChatCompletionUiformMessage] | None = None,
+        # The messages can be provided in different formats, we will convert them to the Retab-compatible format
+        messages: list[ChatCompletionRetabMessage] | None = None,
         openai_messages: list[ChatCompletionMessageParam] | None = None,
         anthropic_messages: list[MessageParam] | None = None,
         anthropic_system_prompt: str | None = None,

retab/resources/jsonlUtils.py

@@ -22,14 +22,14 @@ from .._utils.ai_models import assert_valid_model_extraction, find_provider_from
 from .._utils.chat import convert_to_anthropic_format, convert_to_openai_format, separate_messages
 from .._utils.display import Metrics, display_metrics, process_dataset_and_compute_metrics
 from .._utils.json_schema import load_json_schema
-from ..types.chat import ChatCompletionUiformMessage
+from ..types.chat import ChatCompletionRetabMessage
 from ..types.modalities import Modality
 from ..types.schemas.object import Schema
 from ..types.browser_canvas import BrowserCanvas
 
 
 class FinetuningJSON(BaseModel):
-    messages: list[ChatCompletionUiformMessage]
+    messages: list[ChatCompletionRetabMessage]
 
 
 FinetuningJSONL = list[FinetuningJSON]
@@ -242,7 +242,7 @@ class Datasets(SyncAPIResource, BaseDatasetsMixin):
         training_set = []
 
         for pair_paths in tqdm(pairs_paths):
-            document_messages: list[ChatCompletionUiformMessage] = []
+            document_messages: list[ChatCompletionRetabMessage] = []
 
             if isinstance(pair_paths["document_fpath"], str) or isinstance(pair_paths["document_fpath"], Path):
                 document_message = self._client.documents.create_messages(document=pair_paths["document_fpath"], modality=modality)
@@ -299,7 +299,7 @@ class Datasets(SyncAPIResource, BaseDatasetsMixin):
         provider: str,
         model: str,
         temperature: float,
-        messages: list[ChatCompletionUiformMessage],
+        messages: list[ChatCompletionRetabMessage],
         schema_obj: Schema,
     ) -> str:
         """Get completion from the appropriate model provider.
@@ -659,7 +659,7 @@ class Datasets(SyncAPIResource, BaseDatasetsMixin):
             system_message, user_messages, assistant_messages = separate_messages(messages)
             system_and_user_messages = messages[:-1]
 
-            previous_annotation_message: ChatCompletionUiformMessage = {
+            previous_annotation_message: ChatCompletionRetabMessage = {
                 "role": "user",
                 "content": "Here is an old annotation using a different schema. Use it as a reference to update the annotation: " + messages[-1]["content"],
             }

retab/resources/processors/automations/endpoints.py

@@ -120,7 +120,7 @@ class Endpoints(SyncAPIResource, EndpointsMixin):
             need_validation=need_validation,
         )
         response = self._client._prepared_request(request)
-        print(f"Endpoint ID: {response['id']}. Endpoint available at https://www.uiform.com/dashboard/processors/{response['id']}")
+        print(f"Endpoint ID: {response['id']}. Endpoint available at https://www.retab.dev/dashboard/processors/{response['id']}")
         return Endpoint.model_validate(response)
 
     def list(
@@ -229,7 +229,7 @@ class AsyncEndpoints(AsyncAPIResource, EndpointsMixin):
             need_validation=need_validation,
         )
         response = await self._client._prepared_request(request)
-        print(f"Endpoint ID: {response['id']}. Endpoint available at https://www.uiform.com/dashboard/processors/{response['id']}")
+        print(f"Endpoint ID: {response['id']}. Endpoint available at https://www.retab.dev/dashboard/processors/{response['id']}")
 
         return Endpoint.model_validate(response)
 

retab/resources/processors/automations/links.py

@@ -128,7 +128,7 @@ class Links(SyncAPIResource, LinksMixin):
         )
         response = self._client._prepared_request(request)
 
-        print(f"Extraction Link Created. Link available at https://www.uiform.com/dashboard/processors/{response['id']}")
+        print(f"Extraction Link Created. Link available at https://www.retab.dev/dashboard/processors/{response['id']}")
         return Link.model_validate(response)
 
     def list(
@@ -248,7 +248,7 @@ class AsyncLinks(AsyncAPIResource, LinksMixin):
             password=password,
         )
         response = await self._client._prepared_request(request)
-        print(f"Extraction Link Created. Link available at https://www.uiform.com/dashboard/processors/{response['id']}")
+        print(f"Extraction Link Created. Link available at https://www.retab.dev/dashboard/processors/{response['id']}")
         return Link.model_validate(response)
 
     async def list(

retab/resources/processors/automations/logs.py

@@ -147,7 +147,7 @@ class Logs(SyncAPIResource, LogsMixin):
         request = self.prepare_rerun(processor_id, log_id)
         response = self._client._prepared_request(request)
 
-        print(f"Webhook call run successfully. Log available at https://www.uiform.com/dashboard/processors/{processor_id}/logs/{log_id}")
+        print(f"Webhook call run successfully. Log available at https://www.retab.dev/dashboard/processors/{processor_id}/logs/{log_id}")
 
         return ExternalRequestLog.model_validate(response)
 
@@ -217,6 +217,6 @@ class AsyncLogs(AsyncAPIResource, LogsMixin):
         request = self.prepare_rerun(processor_id, log_id)
         response = await self._client._prepared_request(request)
 
-        print(f"Webhook call run successfully. Log available at https://www.uiform.com/dashboard/processors/{processor_id}/logs/{log_id}")
+        print(f"Webhook call run successfully. Log available at https://www.retab.dev/dashboard/processors/{processor_id}/logs/{log_id}")
 
         return ExternalRequestLog.model_validate(response)

retab/resources/processors/automations/mailboxes.py

@@ -144,7 +144,7 @@ class Mailboxes(SyncAPIResource, MailBoxesMixin):
         )
         response = self._client._prepared_request(request)
 
-        print(f"Email automation created. Mailbox available at https://www.uiform.com/dashboard/processors/{response['id']}")
+        print(f"Email automation created. Mailbox available at https://www.retab.dev/dashboard/processors/{response['id']}")
 
         return Mailbox.model_validate(response)
 
@@ -278,7 +278,7 @@ class AsyncMailboxes(AsyncAPIResource, MailBoxesMixin):
         )
         response = await self._client._prepared_request(request)
 
-        print(f"Email automation created. Mailbox available at https://www.uiform.com/dashboard/processors/{response['id']}")
+        print(f"Email automation created. Mailbox available at https://www.retab.dev/dashboard/processors/{response['id']}")
 
         return Mailbox.model_validate(response)