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

retab/resources/processors/automations/links.py

@@ -0,0 +1,294 @@
+from typing import Any, Literal, Optional
+
+from pydantic_core import PydanticUndefined
+
+from ...._resource import AsyncAPIResource, SyncAPIResource
+from ....types.automations.links import Link, ListLinks, UpdateLinkRequest
+from ....types.standards import PreparedRequest
+
+
+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] = PydanticUndefined,  # type: ignore[assignment]
+        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+        password: str | None = PydanticUndefined,  # type: ignore[assignment]
+    ) -> PreparedRequest:
+        request = Link(
+            processor_id=processor_id,
+            name=name,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            need_validation=need_validation,
+            password=password,
+        )
+        return PreparedRequest(method="POST", url=self.links_base_url, data=request.model_dump(mode="json"))
+
+    def prepare_list(
+        self,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 10,
+        order: Optional[Literal["asc", "desc"]] = "desc",
+        # 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 = 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]
+        password: str | None = PydanticUndefined,  # type: ignore[assignment]
+    ) -> PreparedRequest:
+        request = UpdateLinkRequest(
+            name=name,
+            webhook_url=webhook_url,
+            webhook_headers=webhook_headers,
+            need_validation=need_validation,
+            password=password,
+        )
+        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] = PydanticUndefined,  # type: ignore[assignment]
+        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+        password: str | None = PydanticUndefined,  # type: ignore[assignment]
+    ) -> 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"Extraction Link Created. Link available at https://www.uiform.com/dashboard/processors/{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 = PydanticUndefined,  # type: ignore[assignment]
+        webhook_url: str = PydanticUndefined,  # type: ignore[assignment]
+        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
+        password: str | None = PydanticUndefined,  # type: ignore[assignment]
+        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+    ) -> 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] = PydanticUndefined,  # type: ignore[assignment]
+        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+        password: str | None = PydanticUndefined,  # type: ignore[assignment]
+    ) -> 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"Extraction Link Created. Link available at https://www.uiform.com/dashboard/processors/{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 = PydanticUndefined,  # type: ignore[assignment]
+        webhook_url: str = PydanticUndefined,  # type: ignore[assignment]
+        webhook_headers: dict[str, str] = PydanticUndefined,  # type: ignore[assignment]
+        password: str | None = PydanticUndefined,  # type: ignore[assignment]
+        need_validation: bool = PydanticUndefined,  # type: ignore[assignment]
+    ) -> 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)

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

@@ -1,24 +1,26 @@
-from typing import Any, Dict, Literal, Optional
+from typing import Literal, Optional
 
-from ...._resource import SyncAPIResource, AsyncAPIResource
+from ...._resource import AsyncAPIResource, SyncAPIResource
 from ....types.logs import AutomationLog, ExternalRequestLog, ListLogs
 from ....types.standards import PreparedRequest
 
 
 class LogsMixin:
-    def prepare_get(self, log_id: str) -> PreparedRequest:
+    def prepare_get(self, processor_id: str, log_id: str) -> PreparedRequest:
         """Get a specific automation log by ID.
 
         Args:
+            processor_id: ID of the processor
             log_id: ID of the log to retrieve
 
         Returns:
             PreparedRequest: The prepared request
         """
-        return PreparedRequest(method="GET", url=f"/v1/processors/automations/logs/{log_id}")
+        return PreparedRequest(method="GET", url=f"/v1/processors/{processor_id}/automations/logs/{log_id}")
 
     def prepare_list(
         self,
+        processor_id: str,
         before: Optional[str] = None,
         after: Optional[str] = None,
         limit: Optional[int] = 10,
@@ -34,6 +36,7 @@ class LogsMixin:
         """List automation logs with pagination support.
 
         Args:
+            processor_id: ID of the processor
             before: Optional cursor for pagination before a specific log ID
             after: Optional cursor for pagination after a specific log ID
             limit: Optional limit on number of results (max 100)
@@ -63,38 +66,41 @@ class LogsMixin:
         # 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/logs", params=params)
+        return PreparedRequest(method="GET", url=f"/v1/processors/{processor_id}/automations/logs", params=params)
 
-    def prepare_rerun(self, log_id: str) -> PreparedRequest:
+    def prepare_rerun(self, processor_id: str, log_id: str) -> PreparedRequest:
         """Rerun a webhook from an existing AutomationLog.
 
         Args:
+            processor_id: ID of the processor
             log_id: ID of the log to rerun
 
         Returns:
             PreparedRequest: The prepared request
         """
-        return PreparedRequest(method="POST", url=f"/v1/processors/automations/logs/{log_id}/rerun")
+        return PreparedRequest(method="POST", url=f"/v1/processors/{processor_id}/automations/logs/{log_id}/rerun")
 
 
 class Logs(SyncAPIResource, LogsMixin):
     """Logs API wrapper for managing automation logs"""
 
-    def get(self, log_id: str) -> AutomationLog:
+    def get(self, processor_id: str, log_id: str) -> AutomationLog:
         """Get a specific automation log by ID.
 
         Args:
+            processor_id: ID of the processor
             log_id: ID of the log to retrieve
 
         Returns:
             AutomationLog: The automation log
         """
-        request = self.prepare_get(log_id)
+        request = self.prepare_get(processor_id, log_id)
         response = self._client._prepared_request(request)
         return AutomationLog.model_validate(response)
 
     def list(
         self,
+        processor_id: str,
         before: Optional[str] = None,
         after: Optional[str] = None,
         limit: Optional[int] = 10,
@@ -109,6 +115,7 @@ class Logs(SyncAPIResource, LogsMixin):
         """List automation logs with pagination support.
 
         Args:
+            processor_id: ID of the processor
             before: Optional cursor for pagination before a specific log ID
             after: Optional cursor for pagination after a specific log ID
             limit: Optional limit on number of results (max 100)
@@ -123,23 +130,24 @@ class Logs(SyncAPIResource, LogsMixin):
         Returns:
             ListLogs: Paginated list of automation logs with metadata
         """
-        request = self.prepare_list(before, after, limit, order, status_code, status_class, automation_id, webhook_url, schema_id, schema_data_id)
+        request = self.prepare_list(processor_id, before, after, limit, order, status_code, status_class, automation_id, webhook_url, schema_id, schema_data_id)
         response = self._client._prepared_request(request)
         return ListLogs.model_validate(response)
 
-    def rerun(self, log_id: str) -> ExternalRequestLog:
+    def rerun(self, processor_id: str, log_id: str) -> ExternalRequestLog:
         """Rerun a webhook from an existing AutomationLog.
 
         Args:
+            processor_id: ID of the processor
             log_id: ID of the log to rerun
 
         Returns:
             ExternalRequestLog: The result of the rerun webhook call
         """
-        request = self.prepare_rerun(log_id)
+        request = self.prepare_rerun(processor_id, log_id)
         response = self._client._prepared_request(request)
 
-        print(f"Webhook call run successfully. Log available at https://docs.uiform.com/dashboard/processors/logs/{log_id}")
+        print(f"Webhook call run successfully. Log available at https://www.uiform.com/dashboard/processors/{processor_id}/logs/{log_id}")
 
         return ExternalRequestLog.model_validate(response)
 
@@ -147,21 +155,23 @@ class Logs(SyncAPIResource, LogsMixin):
 class AsyncLogs(AsyncAPIResource, LogsMixin):
     """Async Logs API wrapper for managing automation logs"""
 
-    async def get(self, log_id: str) -> AutomationLog:
+    async def get(self, processor_id: str, log_id: str) -> AutomationLog:
         """Get a specific automation log by ID.
 
         Args:
+            processor_id: ID of the processor
             log_id: ID of the log to retrieve
 
         Returns:
             AutomationLog: The automation log
         """
-        request = self.prepare_get(log_id)
+        request = self.prepare_get(processor_id, log_id)
         response = await self._client._prepared_request(request)
         return AutomationLog.model_validate(response)
 
     async def list(
         self,
+        processor_id: str,
         before: Optional[str] = None,
         after: Optional[str] = None,
         limit: Optional[int] = 10,
@@ -190,22 +200,23 @@ class AsyncLogs(AsyncAPIResource, LogsMixin):
         Returns:
             ListLogs: Paginated list of automation logs with metadata
         """
-        request = self.prepare_list(before, after, limit, order, status_code, status_class, automation_id, webhook_url, schema_id, schema_data_id)
+        request = self.prepare_list(processor_id, before, after, limit, order, status_code, status_class, automation_id, webhook_url, schema_id, schema_data_id)
         response = await self._client._prepared_request(request)
         return ListLogs.model_validate(response)
 
-    async def rerun(self, log_id: str) -> ExternalRequestLog:
+    async def rerun(self, processor_id: str, log_id: str) -> ExternalRequestLog:
         """Rerun a webhook from an existing AutomationLog.
 
         Args:
+            processor_id: ID of the processor
             log_id: ID of the log to rerun
 
         Returns:
             ExternalRequestLog: The result of the rerun webhook call
         """
-        request = self.prepare_rerun(log_id)
+        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://docs.uiform.com/dashboard/processors/logs/{log_id}")
+        print(f"Webhook call run successfully. Log available at https://www.uiform.com/dashboard/processors/{processor_id}/logs/{log_id}")
 
         return ExternalRequestLog.model_validate(response)