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

retab/resources/deployments/automations/outlook.py

@@ -0,0 +1,377 @@
+from typing import Any, Literal, List
+
+from ....types.standards import FieldUnset
+
+from ...._resource import AsyncAPIResource, SyncAPIResource
+from ....types.automations.outlook import (
+    FetchParams,
+    ListOutlooks,
+    MatchParams,
+    Outlook,
+    UpdateOutlookRequest,
+)
+from ....types.standards import PreparedRequest
+
+
+class OutlooksMixin:
+    outlooks_base_url: str = "/v1/processors/automations/outlook"
+
+    def prepare_create(
+        self,
+        name: str,
+        processor_id: str,
+        webhook_url: str,
+        default_language: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        authorized_domains: list[str] = FieldUnset,
+        authorized_emails: list[str] = FieldUnset,
+        layout_schema: dict[str, Any] = FieldUnset,
+        match_params: list[MatchParams] = FieldUnset,
+        fetch_params: list[FetchParams] = FieldUnset,
+    ) -> PreparedRequest:
+        # Build outlook dictionary with only provided fields
+        outlook_dict: dict[str, Any] = {
+            'processor_id': processor_id,
+            'name': name,
+            'webhook_url': webhook_url,
+        }
+        if default_language is not FieldUnset:
+            outlook_dict['default_language'] = default_language
+        if webhook_headers is not FieldUnset:
+            outlook_dict['webhook_headers'] = webhook_headers
+        if need_validation is not FieldUnset:
+            outlook_dict['need_validation'] = need_validation
+        if authorized_domains is not FieldUnset:
+            outlook_dict['authorized_domains'] = authorized_domains
+        if authorized_emails is not FieldUnset:
+            outlook_dict['authorized_emails'] = authorized_emails
+        if layout_schema is not FieldUnset:
+            outlook_dict['layout_schema'] = layout_schema
+        if match_params is not FieldUnset:
+            outlook_dict['match_params'] = match_params
+        if fetch_params is not FieldUnset:
+            outlook_dict['fetch_params'] = fetch_params
+
+        # Validate the data
+        outlook_data = Outlook(**outlook_dict)
+        return PreparedRequest(
+            method="POST",
+            url=self.outlooks_base_url,
+            data=outlook_data.model_dump(mode="json", exclude_unset=True),
+        )
+
+    def prepare_list(
+        self,
+        processor_id: str,
+        before: str | None = None,
+        after: str | None = None,
+        limit: int = 10,
+        order: Literal["asc", "desc"] | None = "desc",
+        name: str | None = None,
+        webhook_url: str | None = None,
+    ) -> PreparedRequest:
+        params = {
+            "processor_id": processor_id,
+            "before": before,
+            "after": after,
+            "limit": limit,
+            "order": order,
+            "name": name,
+            "webhook_url": webhook_url,
+        }
+        # Remove None values
+        params = {k: v for k, v in params.items() if v is not None}
+
+        return PreparedRequest(method="GET", url=self.outlooks_base_url, params=params)
+
+    def prepare_get(self, outlook_id: str) -> PreparedRequest:
+        return PreparedRequest(method="GET", url=f"{self.outlooks_base_url}/{outlook_id}")
+
+    def prepare_update(
+        self,
+        outlook_id: str,
+        name: str = FieldUnset,
+        default_language: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        authorized_domains: list[str] = FieldUnset,
+        authorized_emails: list[str] = FieldUnset,
+        match_params: list[MatchParams] = FieldUnset,
+        fetch_params: list[FetchParams] = FieldUnset,
+        layout_schema: dict[str, Any] = FieldUnset,
+    ) -> PreparedRequest:
+        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
+        if authorized_domains is not FieldUnset:
+            update_dict['authorized_domains'] = authorized_domains
+        if authorized_emails is not FieldUnset:
+            update_dict['authorized_emails'] = authorized_emails
+        if layout_schema is not FieldUnset:
+            update_dict['layout_schema'] = layout_schema
+        if match_params is not FieldUnset:
+            update_dict['match_params'] = match_params
+        if fetch_params is not FieldUnset:
+            update_dict['fetch_params'] = fetch_params
+
+        update_outlook_request = UpdateOutlookRequest(**update_dict)
+
+        return PreparedRequest(
+            method="PUT",
+            url=f"{self.outlooks_base_url}/{outlook_id}",
+            data=update_outlook_request.model_dump(mode="json", exclude_unset=True),
+        )
+
+    def prepare_delete(self, outlook_id: str) -> PreparedRequest:
+        return PreparedRequest(method="DELETE", url=f"{self.outlooks_base_url}/{outlook_id}")
+
+
+class Outlooks(SyncAPIResource, OutlooksMixin):
+    """Outlook API wrapper for managing outlook automation configurations"""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+
+    def create(
+        self,
+        name: str,
+        processor_id: str,
+        webhook_url: str,
+        default_language: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        authorized_domains: list[str] = FieldUnset,
+        authorized_emails: list[str] = FieldUnset,
+        layout_schema: dict[str, Any] = FieldUnset,
+        match_params: list[MatchParams] = FieldUnset,
+        fetch_params: list[FetchParams] = FieldUnset,
+    ) -> Outlook:
+        """Create a new outlook automation configuration.
+
+        Args:
+            name: Name of the outlook plugin
+            processor_id: ID of the processor to use for the automation
+            webhook_url: Webhook URL to receive processed data
+            webhook_headers: Webhook headers to send with processed data
+            authorized_domains: List of authorized domains
+            authorized_emails: List of authorized emails
+            layout_schema: Layout schema to display the data
+            match_params: List of match parameters for the outlook automation
+            fetch_params: List of fetch parameters for the outlook automation
+        Returns:
+            Outlook: The created outlook plugin configuration
+        """
+
+        request = self.prepare_create(
+            name=name,
+            processor_id=processor_id,
+            webhook_url=webhook_url,
+            default_language=default_language,
+            webhook_headers=webhook_headers,
+            need_validation=need_validation,
+            authorized_domains=authorized_domains,
+            authorized_emails=authorized_emails,
+            layout_schema=layout_schema,
+            match_params=match_params,
+            fetch_params=fetch_params,
+        )
+        response = self._client._prepared_request(request)
+
+        print(f"Outlook plugin created. Url: https://www.retab.com/dashboard/processors/automations/{response['id']}")
+
+        return Outlook.model_validate(response)
+
+    def list(
+        self,
+        processor_id: str,
+        before: str | None = None,
+        after: str | None = None,
+        limit: int = 10,
+        order: Literal["asc", "desc"] | None = "desc",
+        name: str | None = None,
+        webhook_url: str | None = None,
+    ) -> ListOutlooks:
+        """List all outlook automation configurations.
+
+        Args:
+            before: Optional cursor for pagination - get results before this log ID
+            after: Optional cursor for pagination - get results after this log ID
+            limit: Maximum number of logs to return (1-100, default 10)
+            order: Sort order by creation time - "asc" or "desc" (default "desc")
+            name: Optional name filter
+            webhook_url: Optional webhook URL filter
+        Returns:
+            List[Outlook]: List of outlook plugin configurations
+        """
+        request = self.prepare_list(processor_id, before, after, limit, order, name, webhook_url)
+        response = self._client._prepared_request(request)
+        return ListOutlooks.model_validate(response)
+
+    def get(self, outlook_id: str) -> Outlook:
+        """Get a specific outlook automation configuration.
+
+        Args:
+            id: ID of the outlook plugin
+
+        Returns:
+            Outlook: The outlook plugin configuration
+        """
+        request = self.prepare_get(outlook_id)
+        response = self._client._prepared_request(request)
+        return Outlook.model_validate(response)
+
+    def update(
+        self,
+        outlook_id: str,
+        name: str = FieldUnset,
+        default_language: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        authorized_domains: List[str] = FieldUnset,
+        authorized_emails: List[str] = FieldUnset,
+        layout_schema: dict[str, Any] = FieldUnset,
+        match_params: List[MatchParams] = FieldUnset,
+        fetch_params: List[FetchParams] = FieldUnset,
+    ) -> Outlook:
+        """Update an outlook automation configuration.
+
+        Args:
+            outlook_id: ID of the outlook plugin to update
+            name: New name for the outlook plugin
+            webhook_url: New webhook URL
+            webhook_headers: New webhook headers
+            authorized_domains: New authorized domains
+            authorized_emails: New authorized emails
+            match_params: New match parameters for the outlook automation
+            fetch_params: New fetch parameters for the outlook automation
+            layout_schema: New layout schema for the outlook automation
+
+        Returns:
+            Outlook: The updated outlook plugin configuration
+        """
+        request = self.prepare_update(
+            outlook_id,
+            name=name,
+            default_language=default_language,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            need_validation=need_validation,
+            authorized_domains=authorized_domains,
+            authorized_emails=authorized_emails,
+            layout_schema=layout_schema,
+            match_params=match_params,
+            fetch_params=fetch_params,
+        )
+        response = self._client._prepared_request(request)
+        return Outlook.model_validate(response)
+
+    def delete(self, outlook_id: str) -> None:
+        """Delete an outlook automation configuration.
+
+        Args:
+            outlook_id: ID of the outlook plugin to delete
+        """
+        request = self.prepare_delete(outlook_id)
+        self._client._prepared_request(request)
+        return None
+
+
+class AsyncOutlooks(AsyncAPIResource, OutlooksMixin):
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+
+    async def create(
+        self,
+        name: str,
+        processor_id: str,
+        webhook_url: str,
+        default_language: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        authorized_domains: list[str] = FieldUnset,
+        authorized_emails: list[str] = FieldUnset,
+        layout_schema: dict[str, Any] = FieldUnset,
+        match_params: list[MatchParams] = FieldUnset,
+        fetch_params: list[FetchParams] = FieldUnset,
+    ) -> Outlook:
+        request = self.prepare_create(
+            name=name,
+            processor_id=processor_id,
+            webhook_url=webhook_url,
+            default_language=default_language,
+            webhook_headers=webhook_headers,
+            need_validation=need_validation,
+            authorized_domains=authorized_domains,
+            authorized_emails=authorized_emails,
+            layout_schema=layout_schema,
+            match_params=match_params,
+            fetch_params=fetch_params,
+        )
+        response = await self._client._prepared_request(request)
+        print(f"Outlook plugin created. Url: https://www.retab.com/dashboard/processors/automations/{response['id']}")
+        return Outlook.model_validate(response)
+
+    async def list(
+        self,
+        processor_id: str,
+        before: str | None = None,
+        after: str | None = None,
+        limit: int = 10,
+        order: Literal["asc", "desc"] | None = "desc",
+        name: str | None = None,
+        webhook_url: str | None = None,
+    ) -> ListOutlooks:
+        request = self.prepare_list(processor_id, before, after, limit, order, name, webhook_url)
+        response = await self._client._prepared_request(request)
+        return ListOutlooks.model_validate(response)
+
+    async def get(self, outlook_id: str) -> Outlook:
+        request = self.prepare_get(outlook_id)
+        response = await self._client._prepared_request(request)
+        return Outlook.model_validate(response)
+
+    async def update(
+        self,
+        outlook_id: str,
+        name: str = FieldUnset,
+        default_language: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        authorized_domains: List[str] = FieldUnset,
+        authorized_emails: List[str] = FieldUnset,
+        layout_schema: dict[str, Any] = FieldUnset,
+        match_params: List[MatchParams] = FieldUnset,
+        fetch_params: List[FetchParams] = FieldUnset,
+    ) -> Outlook:
+        request = self.prepare_update(
+            outlook_id=outlook_id,
+            name=name,
+            default_language=default_language,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            need_validation=need_validation,
+            authorized_domains=authorized_domains,
+            authorized_emails=authorized_emails,
+            layout_schema=layout_schema,
+            match_params=match_params,
+            fetch_params=fetch_params,
+        )
+        response = await self._client._prepared_request(request)
+        return Outlook.model_validate(response)
+
+    async def delete(self, outlook_id: str) -> None:
+        request = self.prepare_delete(outlook_id)
+        await self._client._prepared_request(request)
+        return None

retab/resources/deployments/automations/tests.py

@@ -0,0 +1,161 @@
+import json
+import base64
+from io import IOBase
+from pathlib import Path
+
+from PIL.Image import Image
+from pydantic import HttpUrl
+
+from ...._resource import AsyncAPIResource, SyncAPIResource
+from ....utils.mime import prepare_mime_document
+from ....types.logs import AutomationLog
+from ....types.mime import MIMEData
+from ....types.standards import PreparedRequest
+
+
+class TestsMixin:
+    def prepare_upload(self, automation_id: str, document: Path | str | IOBase | HttpUrl | Image | MIMEData) -> PreparedRequest:
+        mime_document = prepare_mime_document(document)
+
+        # Convert MIME document to file upload format (similar to processors client)
+        files = {"file": (mime_document.filename, base64.b64decode(mime_document.content), mime_document.mime_type)}
+
+        # Send as multipart form data with file upload
+        return PreparedRequest(method="POST", url=f"/v1/processors/automations/tests/upload/{automation_id}", files=files)
+
+    def prepare_webhook(self, automation_id: str) -> PreparedRequest:
+        return PreparedRequest(method="POST", url=f"/v1/processors/automations/tests/webhook/{automation_id}", data=None)
+
+    def print_upload_verbose(self, log: AutomationLog) -> None:
+        if log.external_request_log:
+            print("\nTEST FILE UPLOAD RESULTS:")
+            print("\n#########################")
+            print(f"Status Code: {log.external_request_log.status_code}")
+            print(f"Duration: {log.external_request_log.duration_ms:.2f}ms")
+
+            if log.external_request_log.error:
+                print(f"\nERROR: {log.external_request_log.error}")
+
+            if log.external_request_log.response_body:
+                print("\n--------------")
+                print("RESPONSE BODY:")
+                print("--------------")
+                print(json.dumps(log.external_request_log.response_body, indent=2))
+
+            if log.external_request_log.response_headers:
+                print("\n--------------")
+                print("RESPONSE HEADERS:")
+                print("--------------")
+                print(json.dumps(log.external_request_log.response_headers, indent=2))
+
+    def print_webhook_verbose(self, log: AutomationLog) -> None:
+        if log.external_request_log:
+            print("\nTEST WEBHOOK RESULTS:")
+            print("\n#########################")
+            print(f"Status Code: {log.external_request_log.status_code}")
+            print(f"Duration: {log.external_request_log.duration_ms:.2f}ms")
+
+            if log.external_request_log.error:
+                print(f"\nERROR: {log.external_request_log.error}")
+
+            if log.external_request_log.response_body:
+                print("\n--------------")
+                print("RESPONSE BODY:")
+                print("--------------")
+                print(json.dumps(log.external_request_log.response_body, indent=2))
+
+            if log.external_request_log.response_headers:
+                print("\n--------------")
+                print("RESPONSE HEADERS:")
+                print("--------------")
+                print(json.dumps(log.external_request_log.response_headers, indent=2))
+
+
+class Tests(SyncAPIResource, TestsMixin):
+    """Test API wrapper for testing automation configurations"""
+
+    def upload(self, automation_id: str, document: Path | str | IOBase | HttpUrl | Image | MIMEData, verbose: bool = True) -> AutomationLog:
+        """Test endpoint that simulates the complete extraction process with the provided document.
+
+        Args:
+            automation_id: ID of the automation to test
+            document: Document to process
+            verbose: Whether to print verbose output
+
+        Returns:
+            AutomationLog: The automation log with extraction results
+        """
+        request = self.prepare_upload(automation_id, document)
+        response = self._client._prepared_request(request)
+
+        log = AutomationLog.model_validate(response)
+
+        if verbose:
+            self.print_upload_verbose(log)
+
+        return log
+
+    def webhook(self, automation_id: str, verbose: bool = True) -> AutomationLog:
+        """Test endpoint that simulates the complete webhook process with sample data.
+
+        Args:
+            automation_id: ID of the automation to test
+            verbose: Whether to print verbose output
+
+        Returns:
+            AutomationLog: The automation log with webhook results
+        """
+        request = self.prepare_webhook(automation_id)
+        response = self._client._prepared_request(request)
+
+        log = AutomationLog.model_validate(response)
+
+        if verbose:
+            self.print_webhook_verbose(log)
+
+        return log
+
+
+class AsyncTests(AsyncAPIResource, TestsMixin):
+    """Async Test API wrapper for testing deployment configurations"""
+
+    async def upload(self, automation_id: str, document: Path | str | IOBase | HttpUrl | Image | MIMEData, verbose: bool = True) -> AutomationLog:
+        """Test endpoint that simulates the complete extraction process with the provided document.
+
+        Args:
+            automation_id: ID of the automation to test
+            document: Document to process
+            verbose: Whether to print verbose output
+
+        Returns:
+            AutomationLog: The automation log with extraction results
+        """
+        request = self.prepare_upload(automation_id, document)
+        response = await self._client._prepared_request(request)
+
+        log = AutomationLog.model_validate(response)
+
+        if verbose:
+            self.print_upload_verbose(log)
+
+        return log
+
+    async def webhook(self, automation_id: str, verbose: bool = True) -> AutomationLog:
+        """Test endpoint that simulates the complete webhook process with sample data.
+
+        Args:
+            automation_id: ID of the automation to test
+            verbose: Whether to print verbose output
+
+        Returns:
+            AutomationLog: The automation log with webhook results
+        """
+        request = self.prepare_webhook(automation_id)
+        response = await self._client._prepared_request(request)
+
+        log = AutomationLog.model_validate(response)
+
+        if verbose:
+            self.print_webhook_verbose(log)
+
+        return log

retab/resources/deployments/client.py

@@ -0,0 +1,148 @@
+import base64
+from io import IOBase
+from pathlib import Path
+from typing import Any, List
+
+import PIL.Image
+from pydantic import HttpUrl
+from ..._resource import AsyncAPIResource, SyncAPIResource
+from ...utils.mime import MIMEData, prepare_mime_document
+from ...types.documents.extractions import RetabParsedChatCompletion
+from ...types.standards import PreparedRequest
+
+
+class DeploymentsMixin:
+    def prepare_submit(
+        self,
+        project_id: str,
+        iteration_id: str,
+        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.
+
+        Args:
+            project_id: ID of the project
+            iteration_id: ID of the iteration
+            document: Single document to process (mutually exclusive with documents)
+            documents: List of documents to process (mutually exclusive with document)
+            temperature: Optional temperature override
+            seed: Optional seed for reproducibility
+            store: Whether to store the results
+
+        Returns:
+            PreparedRequest: The prepared request
+        """
+        # 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,
+            "seed": seed,
+            "store": store,
+        }
+        # Remove None values
+        form_data = {k: v for k, v in form_data.items() if v is not None}
+
+        # Prepare files for upload
+        files = {}
+        if document:
+            # 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)
+        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
+                        (mime_doc.filename, base64.b64decode(mime_doc.content), mime_doc.mime_type),
+                    )
+                )
+            files = files_list
+
+        url = f"/v1/deployments/{project_id}/{iteration_id}/submit"
+
+        return PreparedRequest(method="POST", url=url, form_data=form_data, files=files)
+
+
+class Deployments(SyncAPIResource, DeploymentsMixin):
+    """Deployments API wrapper for managing deployment configurations"""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+
+    def submit(
+        self,
+        project_id: str,
+        iteration_id: str,
+        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,
+    ) -> RetabParsedChatCompletion:
+        """Submit documents to a deployment for processing.
+
+        Args:
+            project_id: ID of the project
+            iteration_id: ID of the iteration
+            document: Single document to process (mutually exclusive with documents)
+            documents: List of documents to process (mutually exclusive with document)
+            temperature: Optional temperature override
+            seed: Optional seed for reproducibility
+            store: Whether to store the results
+
+        Returns:
+            RetabParsedChatCompletion: The processing result
+        """
+        request = self.prepare_submit(project_id=project_id, iteration_id=iteration_id, document=document, documents=documents, temperature=temperature, seed=seed, store=store)
+        response = self._client._prepared_request(request)
+        return RetabParsedChatCompletion.model_validate(response)
+
+
+class AsyncDeployments(AsyncAPIResource, DeploymentsMixin):
+    """Async Deployments API wrapper for managing deployment configurations"""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+
+    async def submit(
+        self,
+        project_id: str,
+        iteration_id: str,
+        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,
+    ) -> RetabParsedChatCompletion:
+        """Submit documents to a deployment for processing.
+
+        Args:
+            project_id: ID of the project
+            iteration_id: ID of the iteration
+            document: Single document to process (mutually exclusive with documents)
+            documents: List of documents to process (mutually exclusive with document)
+            temperature: Optional temperature override
+            seed: Optional seed for reproducibility
+            store: Whether to store the results
+
+        Returns:
+            RetabParsedChatCompletion: The processing result
+        """
+        request = self.prepare_submit(project_id=project_id, iteration_id=iteration_id, document=document, documents=documents, temperature=temperature, seed=seed, store=store)
+        response = await self._client._prepared_request(request)
+        return RetabParsedChatCompletion.model_validate(response)