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

retab/resources/models.py

@@ -0,0 +1,73 @@
+from openai.types.model import Model
+
+from .._resource import AsyncAPIResource, SyncAPIResource
+from ..types.standards import PreparedRequest
+
+
+class ModelsMixin:
+    def prepare_list(
+        self,
+        supports_finetuning: bool = False,
+        supports_image: bool = False,
+        include_finetuned_models: bool = True,
+    ) -> PreparedRequest:
+        params = {
+            "supports_finetuning": supports_finetuning,
+            "supports_image": supports_image,
+            "include_finetuned_models": include_finetuned_models,
+        }
+        return PreparedRequest(method="GET", url="/v1/models", params=params)
+
+
+class Models(SyncAPIResource, ModelsMixin):
+    """Models API wrapper"""
+
+    def list(
+        self,
+        supports_finetuning: bool = False,
+        supports_image: bool = False,
+        include_finetuned_models: bool = True,
+    ) -> list[Model]:
+        """
+        List all available models.
+
+        Args:
+            supports_finetuning: Filter for models that support fine-tuning
+            supports_image: Filter for models that support image inputs
+            include_finetuned_models: Include fine-tuned models in results
+
+        Returns:
+            list[Model]: List of available models
+        Raises:
+            HTTPException if the request fails
+        """
+        request = self.prepare_list(supports_finetuning, supports_image, include_finetuned_models)
+        output = self._client._prepared_request(request)
+        return [Model(**model) for model in output["data"]]
+
+
+class AsyncModels(AsyncAPIResource, ModelsMixin):
+    """Models Asyncronous API wrapper"""
+
+    async def list(
+        self,
+        supports_finetuning: bool = False,
+        supports_image: bool = False,
+        include_finetuned_models: bool = True,
+    ) -> list[Model]:
+        """
+        List all available models asynchronously.
+
+        Args:
+            supports_finetuning: Filter for models that support fine-tuning
+            supports_image: Filter for models that support image inputs
+            include_finetuned_models: Include fine-tuned models in results
+
+        Returns:
+            list[Model]: List of available models
+        Raises:
+            HTTPException if the request fails
+        """
+        request = self.prepare_list(supports_finetuning, supports_image, include_finetuned_models)
+        output = await self._client._prepared_request(request)
+        return [Model(**model) for model in output["data"]]

retab/resources/processors/automations/client.py

@@ -0,0 +1,244 @@
+import hashlib
+import hmac
+import json
+from typing import Any, Literal, Optional, Union
+
+from ...._resource import AsyncAPIResource, SyncAPIResource
+from ....types.automations.endpoints import Endpoint, UpdateEndpointRequest
+from ....types.automations.links import Link, UpdateLinkRequest
+from ....types.automations.mailboxes import Mailbox, UpdateMailboxRequest
+from ....types.automations.outlook import Outlook, UpdateOutlookRequest
+from ....types.standards import PreparedRequest
+from .endpoints import AsyncEndpoints, Endpoints
+from .links import AsyncLinks, Links
+from .logs import AsyncLogs, Logs
+from .mailboxes import AsyncMailboxes, Mailboxes
+from .outlook import AsyncOutlooks, Outlooks
+from .tests import AsyncTests, Tests
+
+
+class SignatureVerificationError(Exception):
+    """Raised when webhook signature verification fails."""
+
+    pass
+
+
+class AutomationsMixin:
+    def _verify_event(self, event_body: bytes, event_signature: str, secret: str) -> Any:
+        """
+        Verify the signature of a webhook event.
+
+        Args:
+            body: The raw request body
+            signature: The signature header
+            secret: The secret key used for signing
+
+        Returns:
+            The parsed event payload
+
+        Raises:
+            SignatureVerificationError: If the signature verification fails
+        """
+        expected_signature = hmac.new(secret.encode(), event_body, hashlib.sha256).hexdigest()
+
+        if not hmac.compare_digest(event_signature, expected_signature):
+            raise SignatureVerificationError("Invalid signature")
+
+        return json.loads(event_body.decode("utf-8"))
+
+    def prepare_list(
+        self,
+        processor_id: str,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 10,
+        order: Optional[Literal["asc", "desc"]] = "desc",
+        automation_id: Optional[str] = None,
+        webhook_url: Optional[str] = None,
+        name: Optional[str] = None,
+    ) -> PreparedRequest:
+        params = {
+            "before": before,
+            "after": after,
+            "limit": limit,
+            "order": order,
+            "id": automation_id,
+            "webhook_url": webhook_url,
+            "name": name,
+        }
+        params = {k: v for k, v in params.items() if v is not None}
+        return PreparedRequest(method="GET", url=f"/v1/processors/{processor_id}/automations", params=params)
+
+    def prepare_get(self, processor_id: str, automation_id: str) -> PreparedRequest:
+        return PreparedRequest(method="GET", url=f"/v1/processors/{processor_id}/automations/{automation_id}")
+
+    def prepare_update(
+        self,
+        processor_id: str,
+        automation_id: str,
+        automation_data: Union[UpdateLinkRequest, UpdateMailboxRequest, UpdateEndpointRequest, UpdateOutlookRequest],
+    ) -> PreparedRequest:
+        return PreparedRequest(method="PUT", url=f"/v1/processors/{processor_id}/automations/{automation_id}", data=automation_data.model_dump(mode="json"))
+
+    def prepare_delete(self, processor_id: str, automation_id: str) -> PreparedRequest:
+        return PreparedRequest(method="DELETE", url=f"/v1/processors/{processor_id}/automations/{automation_id}")
+
+
+class Automations(SyncAPIResource, AutomationsMixin):
+    """Automations API wrapper"""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+        self.mailboxes = Mailboxes(client=client)
+        self.links = Links(client=client)
+        self.outlook = Outlooks(client=client)
+        self.endpoints = Endpoints(client=client)
+        self.tests = Tests(client=client)
+        self.logs = Logs(client=client)
+
+    def verify_event(self, event_body: bytes, event_signature: str, secret: str) -> Any:
+        """
+        Verify the signature of a webhook event.
+        """
+        return self._verify_event(event_body, event_signature, secret)
+
+    def list_automations(
+        self,
+        processor_id: str,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 10,
+        order: Optional[Literal["asc", "desc"]] = "desc",
+        automation_id: Optional[str] = None,
+        webhook_url: Optional[str] = None,
+        name: Optional[str] = None,
+    ):
+        """List automations attached to this processor."""
+        request = self.prepare_list(processor_id, before, after, limit, order, automation_id, webhook_url, name)
+        response = self._client._prepared_request(request)
+        return response
+
+    def get_automation(self, processor_id: str, automation_id: str) -> Union[Link, Mailbox, Endpoint, Outlook]:
+        """Get a specific automation attached to this processor."""
+        request = self.prepare_get(processor_id, automation_id)
+        response = self._client._prepared_request(request)
+
+        # Return the appropriate model based on the automation type
+        if response["object"] == "automation.link":
+            return Link.model_validate(response)
+        elif response["object"] == "automation.mailbox":
+            return Mailbox.model_validate(response)
+        elif response["object"] == "automation.endpoint":
+            return Endpoint.model_validate(response)
+        elif response["object"] == "automation.outlook":
+            return Outlook.model_validate(response)
+        else:
+            raise ValueError(f"Unknown automation type: {response.get('object')}")
+
+    def update_automation(
+        self,
+        processor_id: str,
+        automation_id: str,
+        automation_data: Union[UpdateLinkRequest, UpdateMailboxRequest, UpdateEndpointRequest, UpdateOutlookRequest],
+    ) -> Union[Link, Mailbox, Endpoint, Outlook]:
+        """Update an automation attached to this processor."""
+        request = self.prepare_update(processor_id, automation_id, automation_data)
+        response = self._client._prepared_request(request)
+
+        # Return the appropriate model based on the automation type
+        if response["object"] == "automation.link":
+            return Link.model_validate(response)
+        elif response["object"] == "automation.mailbox":
+            return Mailbox.model_validate(response)
+        elif response["object"] == "automation.endpoint":
+            return Endpoint.model_validate(response)
+        elif response["object"] == "automation.outlook":
+            return Outlook.model_validate(response)
+        else:
+            raise ValueError(f"Unknown automation type: {response.get('object')}")
+
+    def delete_automation(self, processor_id: str, automation_id: str) -> None:
+        """Delete an automation attached to this processor."""
+        request = self.prepare_delete(processor_id, automation_id)
+        self._client._prepared_request(request)
+        print(f"Automation {automation_id} deleted from processor {processor_id}")
+
+
+class AsyncAutomations(AsyncAPIResource, AutomationsMixin):
+    """Async Automations API wrapper"""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+        self.mailboxes = AsyncMailboxes(client=client)
+        self.links = AsyncLinks(client=client)
+        self.outlook = AsyncOutlooks(client=client)
+        self.endpoints = AsyncEndpoints(client=client)
+        self.tests = AsyncTests(client=client)
+        self.logs = AsyncLogs(client=client)
+
+    async def verify_event(self, event_body: bytes, event_signature: str, secret: str) -> Any:
+        """
+        Verify the signature of a webhook event.
+        """
+        return self._verify_event(event_body, event_signature, secret)
+
+    async def list(
+        self,
+        processor_id: str,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 10,
+        order: Optional[Literal["asc", "desc"]] = "desc",
+        automation_id: Optional[str] = None,
+        webhook_url: Optional[str] = None,
+        name: Optional[str] = None,
+    ):
+        """List automations attached to this processor."""
+        request = self.prepare_list(processor_id, before, after, limit, order, automation_id, webhook_url, name)
+        response = await self._client._prepared_request(request)
+        return response
+
+    async def get(self, processor_id: str, automation_id: str) -> Union[Link, Mailbox, Endpoint, Outlook]:
+        """Get a specific automation attached to this processor."""
+        request = self.prepare_get(processor_id, automation_id)
+        response = await self._client._prepared_request(request)
+
+        # Return the appropriate model based on the automation type
+        if response["object"] == "automation.link":
+            return Link.model_validate(response)
+        elif response["object"] == "automation.mailbox":
+            return Mailbox.model_validate(response)
+        elif response["object"] == "automation.endpoint":
+            return Endpoint.model_validate(response)
+        elif response["object"] == "automation.outlook":
+            return Outlook.model_validate(response)
+        else:
+            raise ValueError(f"Unknown automation type: {response.get('object')}")
+
+    async def update(
+        self,
+        processor_id: str,
+        automation_id: str,
+        automation_data: Union[UpdateLinkRequest, UpdateMailboxRequest, UpdateEndpointRequest, UpdateOutlookRequest],
+    ) -> Union[Link, Mailbox, Endpoint, Outlook]:
+        """Update an automation attached to this processor."""
+        request = self.prepare_update(processor_id, automation_id, automation_data)
+        response = await self._client._prepared_request(request)
+
+        # Return the appropriate model based on the automation type
+        if response["object"] == "automation.link":
+            return Link.model_validate(response)
+        elif response["object"] == "automation.mailbox":
+            return Mailbox.model_validate(response)
+        elif response["object"] == "automation.endpoint":
+            return Endpoint.model_validate(response)
+        elif response["object"] == "automation.outlook":
+            return Outlook.model_validate(response)
+        else:
+            raise ValueError(f"Unknown automation type: {response.get('object')}")
+
+    async def delete(self, processor_id: str, automation_id: str) -> None:
+        """Delete an automation attached to this processor."""
+        request = self.prepare_delete(processor_id, automation_id)
+        await self._client._prepared_request(request)
+        print(f"Automation {automation_id} deleted from processor {processor_id}")

{uiform → retab}/resources/processors/automations/endpoints.py

@@ -1,54 +1,33 @@
-import datetime
-from pathlib import Path
-from typing import Any, Dict, Literal, Optional
+from typing import Literal, Optional
 
-import httpx
-from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
-from pydantic import HttpUrl
+from pydantic_core import PydanticUndefined
 
 from ...._resource import AsyncAPIResource, SyncAPIResource
 from ...._utils.ai_models import assert_valid_model_extraction
 from ....types.automations.endpoints import Endpoint, ListEndpoints, UpdateEndpointRequest
-from ....types.logs import ExternalRequestLog
-
-# from ...types.documents.extractions import DocumentExtractResponse
-from ....types.mime import BaseMIMEData, MIMEData
-from ....types.modalities import Modality
 from ....types.standards import PreparedRequest
 
 
 class EndpointsMixin:
     def prepare_create(
         self,
+        processor_id: str,
         name: str,
-        webhook_url: HttpUrl,
-        json_schema: Dict[str, Any],
-        webhook_headers: Optional[Dict[str, str]] = None,
-        # DocumentExtraction Config
-        image_resolution_dpi: Optional[int] = None,
-        browser_canvas: Optional[Literal['A3', 'A4', 'A5']] = None,
-        modality: Modality = "native",
+        webhook_url: str,
         model: str = "gpt-4o-mini",
-        temperature: float = 0,
-        reasoning_effort: ChatCompletionReasoningEffort = "medium",
+        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
+        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
     ) -> PreparedRequest:
         assert_valid_model_extraction(model)
 
-        data = {
-            "name": name,
-            "webhook_url": webhook_url,
-            "webhook_headers": webhook_headers or {},
-            "json_schema": json_schema,
-            "image_resolution_dpi": image_resolution_dpi,
-            "browser_canvas": browser_canvas,
-            "modality": modality,
-            "model": model,
-            "temperature": temperature,
-            "reasoning_effort": reasoning_effort,
-        }
-
-        request = Endpoint.model_validate(data)
-        return PreparedRequest(method="POST", url="/v1/deployments/endpoints", data=request.model_dump(mode='json'))
+        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"))
 
     def prepare_list(
         self,
@@ -71,7 +50,7 @@ class EndpointsMixin:
         # Remove None values
         params = {k: v for k, v in params.items() if v is not None}
 
-        return PreparedRequest(method="GET", url="/v1/deployments/endpoints", params=params)
+        return PreparedRequest(method="GET", url="/v1/processors/automations/endpoints", params=params)
 
     def prepare_get(self, endpoint_id: str) -> PreparedRequest:
         """Get a specific endpoint configuration.
@@ -87,44 +66,20 @@ class EndpointsMixin:
     def prepare_update(
         self,
         endpoint_id: str,
-        name: Optional[str] = None,
-        webhook_url: Optional[HttpUrl] = None,
-        webhook_headers: Optional[Dict[str, str]] = None,
-        json_schema: Optional[Dict[str, Any]] = None,
-        image_resolution_dpi: Optional[int] = None,
-        browser_canvas: Optional[Literal['A3', 'A4', 'A5']] = None,
-        modality: Optional[Modality] = None,
-        model: Optional[str] = None,
-        temperature: Optional[float] = None,
-        reasoning_effort: Optional[ChatCompletionReasoningEffort] = None,
+        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]
     ) -> PreparedRequest:
-        data: dict[str, Any] = {}
-
-        if endpoint_id is not None:
-            data["id"] = endpoint_id
-        if name is not None:
-            data["name"] = name
-        if webhook_url is not None:
-            data["webhook_url"] = webhook_url
-        if webhook_headers is not None:
-            data["webhook_headers"] = webhook_headers
-        if json_schema is not None:
-            data["json_schema"] = json_schema
-        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 modality is not None:
-            data["modality"] = modality
-        if model is not None:
-            assert_valid_model_extraction(model)
-            data["model"] = model
-        if temperature is not None:
-            data["temperature"] = temperature
-        if reasoning_effort is not None:
-            data["reasoning_effort"] = reasoning_effort
-        request = UpdateEndpointRequest.model_validate(data)
-        return PreparedRequest(method="PUT", url=f"/v1/processors/automations/endpoints/{endpoint_id}", data=request.model_dump(mode='json'))
+        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"))
 
     def prepare_delete(self, endpoint_id: str) -> PreparedRequest:
         return PreparedRequest(method="DELETE", url=f"/v1/processors/automations/endpoints/{endpoint_id}")
@@ -135,17 +90,11 @@ class Endpoints(SyncAPIResource, EndpointsMixin):
 
     def create(
         self,
+        processor_id: str,
         name: str,
-        webhook_url: HttpUrl,
-        json_schema: Dict[str, Any],
-        webhook_headers: Optional[Dict[str, str]] = None,
-        # DocumentExtraction Config
-        image_resolution_dpi: Optional[int] = None,
-        browser_canvas: Optional[Literal['A3', 'A4', 'A5']] = None,
-        modality: Modality = "native",
-        model: str = "gpt-4o-mini",
-        temperature: float = 0,
-        reasoning_effort: ChatCompletionReasoningEffort = "medium",
+        webhook_url: str,
+        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
+        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
     ) -> Endpoint:
         """Create a new endpoint configuration.
 
@@ -163,7 +112,13 @@ class Endpoints(SyncAPIResource, EndpointsMixin):
         Returns:
             Endpoint: The created endpoint configuration
         """
-        request = self.prepare_create(name, webhook_url, json_schema, webhook_headers, image_resolution_dpi, browser_canvas, modality, model, temperature, reasoning_effort)
+        request = self.prepare_create(
+            processor_id=processor_id,
+            name=name,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            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']}")
         return Endpoint.model_validate(response)
@@ -210,16 +165,11 @@ class Endpoints(SyncAPIResource, EndpointsMixin):
     def update(
         self,
         endpoint_id: str,
-        name: Optional[str] = None,
-        webhook_url: Optional[HttpUrl] = None,
-        webhook_headers: Optional[Dict[str, str]] = None,
-        json_schema: Optional[Dict[str, Any]] = None,
-        image_resolution_dpi: Optional[int] = None,
-        browser_canvas: Optional[Literal['A3', 'A4', 'A5']] = None,
-        modality: Optional[Modality] = None,
-        model: Optional[str] = None,
-        temperature: Optional[float] = None,
-        reasoning_effort: Optional[ChatCompletionReasoningEffort] = None,
+        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]
     ) -> Endpoint:
         """Update an endpoint configuration.
 
@@ -238,7 +188,14 @@ class Endpoints(SyncAPIResource, EndpointsMixin):
         Returns:
             Endpoint: The updated endpoint configuration
         """
-        request = self.prepare_update(endpoint_id, name, webhook_url, webhook_headers, json_schema, image_resolution_dpi, browser_canvas, modality, model, temperature, reasoning_effort)
+        request = self.prepare_update(
+            endpoint_id=endpoint_id,
+            name=name,
+            default_language=default_language,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            need_validation=need_validation,
+        )
         response = self._client._prepared_request(request)
         return Endpoint.model_validate(response)
 
@@ -258,22 +215,22 @@ class AsyncEndpoints(AsyncAPIResource, EndpointsMixin):
 
     async def create(
         self,
+        processor_id: str,
         name: str,
-        webhook_url: HttpUrl,
-        json_schema: Dict[str, Any],
-        webhook_headers: Optional[Dict[str, str]] = None,
-        # DocumentExtraction Config
-        image_resolution_dpi: Optional[int] = None,
-        browser_canvas: Optional[Literal['A3', 'A4', 'A5']] = None,
-        modality: Modality = "native",
-        model: str = "gpt-4o-mini",
-        temperature: float = 0,
-        reasoning_effort: ChatCompletionReasoningEffort = "medium",
+        webhook_url: str,
+        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
+        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
     ) -> Endpoint:
-        request = self.prepare_create(name, webhook_url, json_schema, webhook_headers, image_resolution_dpi, browser_canvas, modality, model, temperature, reasoning_effort)
+        request = self.prepare_create(
+            processor_id=processor_id,
+            name=name,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            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']}")
-        
+
         return Endpoint.model_validate(response)
 
     async def list(
@@ -297,18 +254,20 @@ class AsyncEndpoints(AsyncAPIResource, EndpointsMixin):
     async def update(
         self,
         endpoint_id: str,
-        name: Optional[str] = None,
-        webhook_url: Optional[HttpUrl] = None,
-        webhook_headers: Optional[Dict[str, str]] = None,
-        json_schema: Optional[Dict[str, Any]] = None,
-        image_resolution_dpi: Optional[int] = None,
-        browser_canvas: Optional[Literal['A3', 'A4', 'A5']] = None,
-        modality: Optional[Modality] = None,
-        model: Optional[str] = None,
-        temperature: Optional[float] = None,
-        reasoning_effort: Optional[ChatCompletionReasoningEffort] = None,
+        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]
     ) -> Endpoint:
-        request = self.prepare_update(endpoint_id, name, webhook_url, webhook_headers, json_schema, image_resolution_dpi, browser_canvas, modality, model, temperature, reasoning_effort)
+        request = self.prepare_update(
+            endpoint_id=endpoint_id,
+            name=name,
+            default_language=default_language,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            need_validation=need_validation,
+        )
         response = await self._client._prepared_request(request)
         return Endpoint.model_validate(response)