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

retab/resources/deployments/automations/endpoints.py

@@ -0,0 +1,290 @@
+from typing import Any, Literal, Optional
+
+from ....types.standards import FieldUnset
+
+from ...._resource import AsyncAPIResource, SyncAPIResource
+from ....utils.ai_models import assert_valid_model_extraction
+from ....types.automations.endpoints import Endpoint, ListEndpoints, UpdateEndpointRequest
+from ....types.standards import PreparedRequest
+
+
+class EndpointsMixin:
+    def prepare_create(
+        self,
+        processor_id: str,
+        name: str,
+        webhook_url: str,
+        model: str = "gpt-4o-mini",
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+    ) -> PreparedRequest:
+        assert_valid_model_extraction(model)
+
+        endpoint_dict: dict[str, Any] = {
+            'processor_id': processor_id,
+            'name': name,
+            'webhook_url': webhook_url,
+        }
+        if webhook_headers is not FieldUnset:
+            endpoint_dict['webhook_headers'] = webhook_headers
+        if need_validation is not FieldUnset:
+            endpoint_dict['need_validation'] = need_validation
+
+        request = Endpoint(**endpoint_dict)
+        return PreparedRequest(method="POST", url="/v1/processors/automations/endpoints", data=request.model_dump(mode="json", exclude_unset=True))
+
+    def prepare_list(
+        self,
+        processor_id: str,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 10,
+        order: Optional[Literal["asc", "desc"]] = "desc",
+        # Filtering parameters
+        name: Optional[str] = None,
+        webhook_url: Optional[str] = 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="/v1/processors/automations/endpoints", params=params)
+
+    def prepare_get(self, endpoint_id: str) -> PreparedRequest:
+        """Get a specific endpoint configuration.
+
+        Args:
+            endpoint_id: ID of the endpoint
+
+        Returns:
+            Endpoint: The endpoint configuration
+        """
+        return PreparedRequest(method="GET", url=f"/v1/processors/automations/endpoints/{endpoint_id}")
+
+    def prepare_update(
+        self,
+        endpoint_id: str,
+        name: str = FieldUnset,
+        default_language: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = 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
+
+        request = UpdateEndpointRequest(**update_dict)
+        return PreparedRequest(method="PUT", url=f"/v1/processors/automations/endpoints/{endpoint_id}", data=request.model_dump(mode="json", exclude_unset=True))
+
+    def prepare_delete(self, endpoint_id: str) -> PreparedRequest:
+        return PreparedRequest(method="DELETE", url=f"/v1/processors/automations/endpoints/{endpoint_id}")
+
+
+class Endpoints(SyncAPIResource, EndpointsMixin):
+    """Endpoints API wrapper for managing endpoint configurations"""
+
+    def create(
+        self,
+        processor_id: str,
+        name: str,
+        webhook_url: str,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+    ) -> Endpoint:
+        """Create a new endpoint configuration.
+
+        Args:
+            name: Name of the endpoint
+            webhook_url: Webhook endpoint URL
+            json_schema: JSON schema for the endpoint
+            webhook_headers: Optional HTTP headers for webhook requests
+            image_resolution_dpi: Optional image resolution DPI
+            browser_canvas: Optional browser canvas size
+            modality: Processing modality (currently only "native" supported)
+            model: AI model to use for processing
+            temperature: Model temperature setting
+            reasoning_effort: The effort level for the model to reason about the input data.
+        Returns:
+            Endpoint: The created endpoint configuration
+        """
+        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 Created. Url: https://www.retab.com/dashboard/processors/automations/{response['id']}")
+        return Endpoint.model_validate(response)
+
+    def list(
+        self,
+        processor_id: str,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 10,
+        order: Optional[Literal["asc", "desc"]] = "desc",
+        name: Optional[str] = None,
+        webhook_url: Optional[str] = None,
+    ) -> ListEndpoints:
+        """List endpoint configurations with pagination support.
+
+        Args:
+            before: Optional cursor for pagination before a specific endpoint ID
+            after: Optional cursor for pagination after a specific endpoint ID
+            limit: Optional limit on number of results (max 100)
+            order: Optional sort order ("asc" or "desc")
+            name: Optional filter by endpoint name
+            webhook_url: Optional filter by webhook URL
+
+        Returns:
+            ListEndpoints: Paginated list of endpoint configurations with metadata
+        """
+        request = self.prepare_list(processor_id, before, after, limit, order, name, webhook_url)
+        response = self._client._prepared_request(request)
+        return ListEndpoints.model_validate(response)
+
+    def get(self, endpoint_id: str) -> Endpoint:
+        """Get a specific endpoint configuration.
+
+        Args:
+            endpoint_id: ID of the endpoint
+
+        Returns:
+            Endpoint: The endpoint configuration
+        """
+        request = self.prepare_get(endpoint_id)
+        response = self._client._prepared_request(request)
+        return Endpoint.model_validate(response)
+
+    def update(
+        self,
+        endpoint_id: str,
+        name: str = FieldUnset,
+        default_language: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+    ) -> Endpoint:
+        """Update an endpoint configuration.
+
+        Args:
+            id: ID of the endpoint to update
+            name: New name for the endpoint
+            webhook_url: New webhook URL
+            webhook_headers: New webhook headers
+            json_schema: New JSON schema for the endpoint
+            image_resolution_dpi: New image resolution DPI
+            browser_canvas: New browser canvas size
+            modality: New processing modality
+            model: New AI model
+            temperature: New temperature setting
+            reasoning_effort: The effort level for the model to reason about the input data.
+        Returns:
+            Endpoint: The updated endpoint configuration
+        """
+        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)
+
+    def delete(self, endpoint_id: str) -> None:
+        """Delete an endpoint configuration.
+
+        Args:
+            id: ID of the endpoint to delete
+        """
+        request = self.prepare_delete(endpoint_id)
+        self._client._prepared_request(request)
+        print(f"Endpoint Deleted. ID: {endpoint_id}")
+
+
+class AsyncEndpoints(AsyncAPIResource, EndpointsMixin):
+    """Async Endpoints API wrapper for managing endpoint configurations"""
+
+    async def create(
+        self,
+        processor_id: str,
+        name: str,
+        webhook_url: str,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+    ) -> Endpoint:
+        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 Created. Url: https://www.retab.com/dashboard/processors/automations/{response['id']}")
+
+        return Endpoint.model_validate(response)
+
+    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",
+        name: Optional[str] = None,
+        webhook_url: Optional[str] = None,
+    ) -> ListEndpoints:
+        request = self.prepare_list(processor_id, before, after, limit, order, name, webhook_url)
+        response = await self._client._prepared_request(request)
+        return ListEndpoints.model_validate(response)
+
+    async def get(self, endpoint_id: str) -> Endpoint:
+        request = self.prepare_get(endpoint_id)
+        response = await self._client._prepared_request(request)
+        return Endpoint.model_validate(response)
+
+    async def update(
+        self,
+        endpoint_id: str,
+        name: str = FieldUnset,
+        default_language: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+    ) -> Endpoint:
+        request = self.prepare_update(
+            endpoint_id=endpoint_id,
+            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)
+
+    async def delete(self, endpoint_id: str) -> None:
+        request = self.prepare_delete(endpoint_id)
+        await self._client._prepared_request(request)

retab/resources/deployments/automations/links.py

@@ -0,0 +1,303 @@
+from typing import Any, Literal, Optional
+
+from ...._resource import AsyncAPIResource, SyncAPIResource
+from ....types.automations.links import Link, ListLinks, UpdateLinkRequest
+from ....types.standards import PreparedRequest, FieldUnset
+
+
+class LinksMixin:
+    links_base_url: str = "/v1/processors/automations/links"
+
+    def prepare_create(
+        self,
+        processor_id: str,
+        name: str,
+        webhook_url: str,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        password: str | None = FieldUnset,
+    ) -> PreparedRequest:
+        link_dict: dict[str, Any] = {
+            'processor_id': processor_id,
+            'name': name,
+            'webhook_url': webhook_url,
+        }
+        if webhook_headers is not FieldUnset:
+            link_dict['webhook_headers'] = webhook_headers
+        if need_validation is not FieldUnset:
+            link_dict['need_validation'] = need_validation
+        if password is not FieldUnset:
+            link_dict['password'] = password
+
+        request = Link(**link_dict)
+        return PreparedRequest(method="POST", url=self.links_base_url, data=request.model_dump(mode="json", exclude_unset=True))
+
+    def prepare_list(
+        self,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 10,
+        order: Optional[Literal["asc", "desc"]] = "desc",
+        # Filtering parameters
+        processor_id: Optional[str] = None,
+        name: Optional[str] = None,
+    ) -> PreparedRequest:
+        params = {
+            "before": before,
+            "after": after,
+            "limit": limit,
+            "order": order,
+            "processor_id": processor_id,
+            "name": name,
+        }
+        # Remove None values
+        params = {k: v for k, v in params.items() if v is not None}
+
+        return PreparedRequest(method="GET", url=self.links_base_url, params=params)
+
+    def prepare_get(self, link_id: str) -> PreparedRequest:
+        """Get a specific extraction link configuration.
+
+        Args:
+            link_id: ID of the extraction link
+
+        Returns:
+            Link: The extraction link configuration
+        """
+        return PreparedRequest(method="GET", url=f"{self.links_base_url}/{link_id}")
+
+    def prepare_update(
+        self,
+        link_id: str,
+        name: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        password: str | None = FieldUnset,
+    ) -> PreparedRequest:
+        update_dict: dict[str, Any] = {}
+        if name is not FieldUnset:
+            update_dict['name'] = name
+        if webhook_url is not FieldUnset:
+            update_dict['webhook_url'] = webhook_url
+        if webhook_headers is not FieldUnset:
+            update_dict['webhook_headers'] = webhook_headers
+        if need_validation is not FieldUnset:
+            update_dict['need_validation'] = need_validation
+        if password is not FieldUnset:
+            update_dict['password'] = password
+
+        request = UpdateLinkRequest(**update_dict)
+        return PreparedRequest(method="PUT", url=f"{self.links_base_url}/{link_id}", data=request.model_dump(mode="json", exclude_unset=True, exclude_defaults=True))
+
+    def prepare_delete(self, link_id: str) -> PreparedRequest:
+        return PreparedRequest(method="DELETE", url=f"{self.links_base_url}/{link_id}", raise_for_status=True)
+
+
+class Links(SyncAPIResource, LinksMixin):
+    """Extraction Link API wrapper for managing extraction link configurations"""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+
+    def create(
+        self,
+        processor_id: str,
+        name: str,
+        webhook_url: str,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        password: str | None = FieldUnset,
+    ) -> Link:
+        """Create a new extraction link configuration.
+
+        Args:
+            name: Name of the extraction link
+            json_schema: JSON schema to validate extracted data
+            webhook_url: Webhook endpoint for forwarding processed files
+            webhook_headers: Optional HTTP headers for webhook requests
+            password: Optional password for protected links
+            image_resolution_dpi: Optional image resolution DPI
+            browser_canvas: Optional browser canvas
+            modality: Processing modality (currently only "native" supported)
+            model: AI model to use for processing
+            temperature: Model temperature setting
+            reasoning_effort: The effort level for the model to reason about the input data.
+        Returns:
+            Link: The created extraction link configuration
+        """
+
+        request = self.prepare_create(
+            processor_id=processor_id,
+            name=name,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            need_validation=need_validation,
+            password=password,
+        )
+        response = self._client._prepared_request(request)
+
+        print(f"Link Created. Url: https://www.retab.com/dashboard/processors/automations/{response['id']}")
+        return Link.model_validate(response)
+
+    def list(
+        self,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 10,
+        order: Optional[Literal["asc", "desc"]] = "desc",
+        # Filtering parameters
+        processor_id: Optional[str] = None,
+        name: Optional[str] = None,
+    ) -> ListLinks:
+        """List extraction link configurations with pagination support.
+
+        Args:
+            before: Optional cursor for pagination before a specific link ID
+            after: Optional cursor for pagination after a specific link ID
+            limit: Optional limit on number of results (max 100)
+            order: Optional sort order ("asc" or "desc")
+            processor_id: Optional filter by processor ID
+            name: Optional filter by link name
+
+        Returns:
+            ListLinks: Paginated list of extraction link configurations with metadata
+        """
+        request = self.prepare_list(before=before, after=after, limit=limit, order=order, processor_id=processor_id, name=name)
+        response = self._client._prepared_request(request)
+        return ListLinks.model_validate(response)
+
+    def get(self, link_id: str) -> Link:
+        """Get a specific extraction link configuration.
+
+        Args:
+            link_id: ID of the extraction link
+
+        Returns:
+            Link: The extraction link configuration
+        """
+        request = self.prepare_get(link_id)
+        response = self._client._prepared_request(request)
+        return Link.model_validate(response)
+
+    def update(
+        self,
+        link_id: str,
+        name: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        password: str | None = FieldUnset,
+        need_validation: bool = FieldUnset,
+    ) -> Link:
+        """Update an extraction link configuration.
+
+        Args:
+            link_id: ID of the extraction link to update
+            name: New name for the link
+            webhook_url: New webhook endpoint URL
+            webhook_headers: New webhook headers
+            password: New password for protected links
+            image_resolution_dpi: New image resolution DPI
+            browser_canvas: New browser canvas
+            modality: New processing modality
+            model: New AI model
+            temperature: New temperature setting
+            reasoning_effort: The effort level for the model to reason about the input data.
+            json_schema: New JSON schema
+
+        Returns:
+            Link: The updated extraction link configuration
+        """
+
+        request = self.prepare_update(
+            link_id=link_id,
+            name=name,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            password=password,
+            need_validation=need_validation,
+        )
+        response = self._client._prepared_request(request)
+        return Link.model_validate(response)
+
+    def delete(self, link_id: str) -> None:
+        """Delete an extraction link configuration.
+
+        Args:
+            link_id: ID of the extraction link to delete
+
+        Returns:
+            Dict[str, str]: Response message confirming deletion
+        """
+        request = self.prepare_delete(link_id)
+        self._client._prepared_request(request)
+
+
+class AsyncLinks(AsyncAPIResource, LinksMixin):
+    """Async Extraction Link API wrapper for managing extraction link configurations"""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+
+    async def create(
+        self,
+        processor_id: str,
+        name: str,
+        webhook_url: str,
+        webhook_headers: dict[str, str] = FieldUnset,
+        need_validation: bool = FieldUnset,
+        password: str | None = FieldUnset,
+    ) -> Link:
+        request = self.prepare_create(
+            processor_id=processor_id,
+            name=name,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            need_validation=need_validation,
+            password=password,
+        )
+        response = await self._client._prepared_request(request)
+        print(f"Link Created. Url: https://www.retab.com/dashboard/processors/automations/{response['id']}")
+        return Link.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",
+        processor_id: Optional[str] = None,
+        name: Optional[str] = None,
+    ) -> ListLinks:
+        request = self.prepare_list(before=before, after=after, limit=limit, order=order, processor_id=processor_id, name=name)
+        response = await self._client._prepared_request(request)
+        return ListLinks.model_validate(response)
+
+    async def get(self, link_id: str) -> Link:
+        request = self.prepare_get(link_id)
+        response = await self._client._prepared_request(request)
+        return Link.model_validate(response)
+
+    async def update(
+        self,
+        link_id: str,
+        name: str = FieldUnset,
+        webhook_url: str = FieldUnset,
+        webhook_headers: dict[str, str] = FieldUnset,
+        password: str | None = FieldUnset,
+        need_validation: bool = FieldUnset,
+    ) -> Link:
+        request = self.prepare_update(
+            link_id=link_id,
+            name=name,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            password=password,
+            need_validation=need_validation,
+        )
+        response = await self._client._prepared_request(request)
+        return Link.model_validate(response)
+
+    async def delete(self, link_id: str) -> None:
+        request = self.prepare_delete(link_id)
+        await self._client._prepared_request(request)