retab 0.0.84__py3-none-any.whl → 0.0.86__py3-none-any.whl

retab/resources/edit/agent/__init__.py

@@ -0,0 +1,4 @@
+from .client import Agent, AsyncAgent
+
+__all__ = ["Agent", "AsyncAgent"]
+

retab/resources/edit/agent/client.py

@@ -0,0 +1,168 @@
+"""
+Agent Edit SDK client - Wrapper for agent-based document editing functionality.
+"""
+
+from io import IOBase
+from pathlib import Path
+from typing import Any
+
+import PIL.Image
+from pydantic import HttpUrl
+
+from ...._resource import AsyncAPIResource, SyncAPIResource
+from ....utils.mime import prepare_mime_document
+from ....types.documents.edit import (
+    EditConfig,
+    EditRequest,
+    EditResponse,
+)
+from ....types.mime import MIMEData
+from ....types.standards import PreparedRequest, FieldUnset
+
+
+class BaseAgentMixin:
+    """Shared methods for preparing agent edit API requests."""
+
+    def _prepare_fill(
+        self,
+        instructions: str,
+        document: Path | str | IOBase | MIMEData | PIL.Image.Image | HttpUrl | None = None,
+        model: str = FieldUnset,
+        color: str = FieldUnset,
+        **extra_body: Any,
+    ) -> PreparedRequest:
+        request_dict: dict[str, Any] = {
+            "instructions": instructions,
+        }
+
+        if document is not None:
+            mime_document = prepare_mime_document(document)
+            request_dict["document"] = mime_document
+
+        if model is not FieldUnset:
+            request_dict["model"] = model
+
+        if color is not FieldUnset:
+            request_dict["config"] = EditConfig(color=color)
+
+        # Merge any extra fields provided by the caller
+        if extra_body:
+            request_dict.update(extra_body)
+
+        edit_request = EditRequest(**request_dict)
+        return PreparedRequest(
+            method="POST",
+            url="/v1/edit/agent/fill",
+            data=edit_request.model_dump(mode="json", exclude_unset=True),
+        )
+
+
+class Agent(SyncAPIResource, BaseAgentMixin):
+    """Agent Edit API wrapper for synchronous usage."""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+
+    def fill(
+        self,
+        instructions: str,
+        document: Path | str | IOBase | MIMEData | PIL.Image.Image | HttpUrl | None = None,
+        model: str = FieldUnset,
+        color: str = FieldUnset,
+        **extra_body: Any,
+    ) -> EditResponse:
+        """
+        Edit a document by inferring form fields and filling them with provided instructions.
+
+        This method performs:
+        1. Detection to identify form field bounding boxes
+        2. LLM inference to name and describe detected fields
+        3. LLM-based form filling using the provided instructions
+        4. Returns the filled document with form field values populated
+
+        Args:
+            instructions: Instructions describing how to fill the form fields.
+            document: The document to edit. Can be a file path (Path or str), file-like object,
+                MIMEData, PIL Image, or URL.
+            model: The LLM model to use for inference. Defaults to "retab-small".
+            color: Hex color code for filled text (e.g. "#000080"). Defaults to dark blue.
+
+        Returns:
+            EditResponse: Response containing:
+                - form_data: List of form fields with filled values
+                - filled_document: Document with filled form values (MIMEData)
+
+        Raises:
+            HTTPException: If the request fails.
+
+        Supported document formats:
+            - PDF: Native form field detection and filling
+            - DOCX/DOC: Native editing to preserve styles and formatting
+            - PPTX/PPT: Native editing for presentations
+            - XLSX/XLS: Native editing for spreadsheets
+        """
+        request = self._prepare_fill(
+            instructions=instructions,
+            document=document,
+            model=model,
+            color=color,
+            **extra_body,
+        )
+        response = self._client._prepared_request(request)
+        return EditResponse.model_validate(response)
+
+
+class AsyncAgent(AsyncAPIResource, BaseAgentMixin):
+    """Agent Edit API wrapper for asynchronous usage."""
+
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+
+    async def fill(
+        self,
+        instructions: str,
+        document: Path | str | IOBase | MIMEData | PIL.Image.Image | HttpUrl | None = None,
+        model: str = FieldUnset,
+        color: str = FieldUnset,
+        **extra_body: Any,
+    ) -> EditResponse:
+        """
+        Edit a document by inferring form fields and filling them with provided instructions asynchronously.
+
+        This method performs:
+        1. Detection to identify form field bounding boxes
+        2. LLM inference to name and describe detected fields
+        3. LLM-based form filling using the provided instructions
+        4. Returns the filled document with form field values populated
+
+        Args:
+            instructions: Instructions describing how to fill the form fields.
+            document: The document to edit. Can be a file path (Path or str), file-like object,
+                MIMEData, PIL Image, or URL.
+            model: The LLM model to use for inference. Defaults to "retab-small".
+            color: Hex color code for filled text (e.g. "#000080"). Defaults to dark blue.
+
+        Returns:
+            EditResponse: Response containing:
+                - form_data: List of form fields with filled values
+                - filled_document: Document with filled form values (MIMEData)
+
+        Raises:
+            HTTPException: If the request fails.
+
+        Supported document formats:
+            - PDF: Native form field detection and filling
+            - DOCX/DOC: Native editing to preserve styles and formatting
+            - PPTX/PPT: Native editing for presentations
+            - XLSX/XLS: Native editing for spreadsheets
+        """
+        request = self._prepare_fill(
+            instructions=instructions,
+            document=document,
+            model=model,
+            color=color,
+            **extra_body,
+        )
+        response = await self._client._prepared_request(request)
+        return EditResponse.model_validate(response)
+

retab/resources/edit/client.py

@@ -1,176 +1,41 @@
 """
 Edit SDK client - Wrapper for document editing functionality.
+
+Provides access to:
+- edit.agent.fill() - Agent-based document editing (PDF, DOCX, PPTX, XLSX)
+- edit.templates.* - Template-based PDF form filling
 """
 
-from io import IOBase
-from pathlib import Path
 from typing import Any
 
-import PIL.Image
-from pydantic import HttpUrl
-
 from ..._resource import AsyncAPIResource, SyncAPIResource
-from ...utils.mime import prepare_mime_document
-from ...types.documents.edit import (
-    EditRequest,
-    EditResponse,
-)
-from ...types.mime import MIMEData
-from ...types.standards import PreparedRequest, FieldUnset
 from .templates import Templates, AsyncTemplates
+from .agent import Agent, AsyncAgent
 
 
-class BaseEditMixin:
-    """Shared methods for preparing edit API requests."""
-
-    def _prepare_fill_document(
-        self,
-        instructions: str,
-        document: Path | str | IOBase | MIMEData | PIL.Image.Image | HttpUrl | None = None,
-        model: str = FieldUnset,
-        template_id: str | None = FieldUnset,
-        **extra_body: Any,
-    ) -> PreparedRequest:
-        request_dict: dict[str, Any] = {
-            "instructions": instructions,
-        }
-
-        if document is not None:
-            mime_document = prepare_mime_document(document)
-            request_dict["document"] = mime_document
-
-        if model is not FieldUnset:
-            request_dict["model"] = model
-        if template_id is not FieldUnset:
-            request_dict["template_id"] = template_id
-
-        # Merge any extra fields provided by the caller
-        if extra_body:
-            request_dict.update(extra_body)
-
-        edit_request = EditRequest(**request_dict)
-        return PreparedRequest(
-            method="POST",
-            url="/v1/edit/fill-document",
-            data=edit_request.model_dump(mode="json", exclude_unset=True),
-        )
-
-
-class Edit(SyncAPIResource, BaseEditMixin):
-    """Edit API wrapper for synchronous usage."""
+class Edit(SyncAPIResource):
+    """Edit API wrapper for synchronous usage.
+    
+    Sub-clients:
+        agent: Agent-based document editing (fill any document with AI)
+        templates: Template-based PDF form filling (for batch processing)
+    """
 
     def __init__(self, client: Any) -> None:
         super().__init__(client=client)
+        self.agent = Agent(client=client)
         self.templates = Templates(client=client)
 
-    def fill_document(
-        self,
-        instructions: str,
-        document: Path | str | IOBase | MIMEData | PIL.Image.Image | HttpUrl | None = None,
-        model: str = FieldUnset,
-        template_id: str | None = FieldUnset,
-        **extra_body: Any,
-    ) -> EditResponse:
-        """
-        Edit a document by inferring form fields and filling them with provided instructions.
-
-        This method performs:
-        1. Detection to identify form field bounding boxes
-        2. LLM inference to name and describe detected fields
-        3. LLM-based form filling using the provided instructions
-        4. Returns the filled document with form field values populated
-
-        Either `document` OR `template_id` must be provided, but not both.
-
-        Args:
-            instructions: Instructions describing how to fill the form fields.
-            document: The document to edit. Can be a file path (Path or str), file-like object,
-                MIMEData, PIL Image, or URL. Mutually exclusive with template_id.
-            model: The LLM model to use for inference. Defaults to "retab-small".
-            template_id: Template ID to use for filling. When provided, uses the template's
-                pre-defined form fields and empty PDF. Only works for PDF documents.
-                Mutually exclusive with document.
 
-        Returns:
-            EditResponse: Response containing:
-                - form_data: List of form fields with filled values
-                - filled_document: Document with filled form values (MIMEData)
-
-        Raises:
-            HTTPException: If the request fails.
-
-        Supported document formats:
-            - PDF: Native form field detection and filling
-            - DOCX/DOC: Native editing to preserve styles and formatting
-            - PPTX/PPT: Native editing for presentations
-            - XLSX/XLS: Native editing for spreadsheets
-        """
-        request = self._prepare_fill_document(
-            instructions=instructions,
-            document=document,
-            model=model,
-            template_id=template_id,
-            **extra_body,
-        )
-        response = self._client._prepared_request(request)
-        return EditResponse.model_validate(response)
-
-
-class AsyncEdit(AsyncAPIResource, BaseEditMixin):
-    """Edit API wrapper for asynchronous usage."""
+class AsyncEdit(AsyncAPIResource):
+    """Edit API wrapper for asynchronous usage.
+    
+    Sub-clients:
+        agent: Agent-based document editing (fill any document with AI)
+        templates: Template-based PDF form filling (for batch processing)
+    """
 
     def __init__(self, client: Any) -> None:
         super().__init__(client=client)
+        self.agent = AsyncAgent(client=client)
         self.templates = AsyncTemplates(client=client)
-
-    async def fill_document(
-        self,
-        instructions: str,
-        document: Path | str | IOBase | MIMEData | PIL.Image.Image | HttpUrl | None = None,
-        model: str = FieldUnset,
-        template_id: str | None = FieldUnset,
-        **extra_body: Any,
-    ) -> EditResponse:
-        """
-        Edit a document by inferring form fields and filling them with provided instructions asynchronously.
-
-        This method performs:
-        1. Detection to identify form field bounding boxes
-        2. LLM inference to name and describe detected fields
-        3. LLM-based form filling using the provided instructions
-        4. Returns the filled document with form field values populated
-
-        Either `document` OR `template_id` must be provided, but not both.
-
-        Args:
-            instructions: Instructions describing how to fill the form fields.
-            document: The document to edit. Can be a file path (Path or str), file-like object,
-                MIMEData, PIL Image, or URL. Mutually exclusive with template_id.
-            model: The LLM model to use for inference. Defaults to "retab-small".
-            template_id: Template ID to use for filling. When provided, uses the template's
-                pre-defined form fields and empty PDF. Only works for PDF documents.
-                Mutually exclusive with document.
-
-        Returns:
-            EditResponse: Response containing:
-                - form_data: List of form fields with filled values
-                - filled_document: Document with filled form values (MIMEData)
-
-        Raises:
-            HTTPException: If the request fails.
-
-        Supported document formats:
-            - PDF: Native form field detection and filling
-            - DOCX/DOC: Native editing to preserve styles and formatting
-            - PPTX/PPT: Native editing for presentations
-            - XLSX/XLS: Native editing for spreadsheets
-        """
-        request = self._prepare_fill_document(
-            instructions=instructions,
-            document=document,
-            model=model,
-            template_id=template_id,
-            **extra_body,
-        )
-        response = await self._client._prepared_request(request)
-        return EditResponse.model_validate(response)

retab/resources/edit/templates/client.py

@@ -12,6 +12,7 @@ from pydantic import HttpUrl
 from ...._resource import AsyncAPIResource, SyncAPIResource
 from ....utils.mime import prepare_mime_document
 from ....types.documents.edit import (
+    EditConfig,
     FormField,
     InferFormSchemaRequest,
     InferFormSchemaResponse,
@@ -163,6 +164,7 @@ class BaseTemplatesMixin:
         template_id: str,
         instructions: str,
         model: str = FieldUnset,
+        color: str = FieldUnset,
         **extra_body: Any,
     ) -> PreparedRequest:
         request_dict: dict[str, Any] = {
@@ -172,6 +174,8 @@ class BaseTemplatesMixin:
 
         if model is not FieldUnset:
             request_dict["model"] = model
+        if color is not FieldUnset:
+            request_dict["config"] = EditConfig(color=color)
         if extra_body:
             request_dict.update(extra_body)
 
@@ -368,6 +372,7 @@ class Templates(SyncAPIResource, BaseTemplatesMixin):
         template_id: str,
         instructions: str,
         model: str = FieldUnset,
+        color: str = FieldUnset,
         **extra_body: Any,
     ) -> EditResponse:
         """
@@ -380,6 +385,7 @@ class Templates(SyncAPIResource, BaseTemplatesMixin):
             template_id: The template ID to use for filling
             instructions: Instructions describing how to fill the form fields
             model: The LLM model to use for inference (default: "retab-small")
+            color: Hex color code for filled text (e.g. "#000080"). Defaults to dark blue.
 
         Returns:
             EditResponse: Response containing:
@@ -395,6 +401,7 @@ class Templates(SyncAPIResource, BaseTemplatesMixin):
             template_id=template_id,
             instructions=instructions,
             model=model,
+            color=color,
             **extra_body,
         )
         response = self._client._prepared_request(request)
@@ -586,6 +593,7 @@ class AsyncTemplates(AsyncAPIResource, BaseTemplatesMixin):
         template_id: str,
         instructions: str,
         model: str = FieldUnset,
+        color: str = FieldUnset,
         **extra_body: Any,
     ) -> EditResponse:
         """
@@ -598,6 +606,7 @@ class AsyncTemplates(AsyncAPIResource, BaseTemplatesMixin):
             template_id: The template ID to use for filling
             instructions: Instructions describing how to fill the form fields
             model: The LLM model to use for inference (default: "retab-small")
+            color: Hex color code for filled text (e.g. "#000080"). Defaults to dark blue.
 
         Returns:
             EditResponse: Response containing:
@@ -613,6 +622,7 @@ class AsyncTemplates(AsyncAPIResource, BaseTemplatesMixin):
             template_id=template_id,
             instructions=instructions,
             model=model,
+            color=color,
             **extra_body,
         )
         response = await self._client._prepared_request(request)

retab/resources/workflows/client.py

@@ -1,190 +1,28 @@
-from io import IOBase
-from pathlib import Path
-from typing import Any, Dict
-
-import PIL.Image
-from pydantic import HttpUrl
+from typing import Any
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
-from ...utils.mime import MIMEData, prepare_mime_document
-from ...types.standards import PreparedRequest
-from ...types.workflows import WorkflowRun
-
-
-# Type alias for document inputs
-DocumentInput = Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl
-
-
-class WorkflowsMixin:
-    """Mixin providing shared methods for workflow operations."""
-
-    def prepare_run(
-        self,
-        workflow_id: str,
-        documents: Dict[str, DocumentInput],
-    ) -> PreparedRequest:
-        """Prepare a request to run a workflow with input documents.
-
-        Args:
-            workflow_id: The ID of the workflow to run
-            documents: Mapping of start node IDs to their input documents.
-                       Each document can be a file path, bytes, file-like object,
-                       MIMEData, PIL Image, or HttpUrl.
-
-        Returns:
-            PreparedRequest: The prepared request
-            
-        Example:
-            >>> client.workflows.run(
-            ...     workflow_id="wf_abc123",
-            ...     documents={
-            ...         "start-node-1": Path("invoice.pdf"),
-            ...         "start-node-2": Path("receipt.pdf"),
-            ...     }
-            ... )
-        """
-        # Convert each document to MIMEData and then to the format expected by the backend
-        documents_payload: Dict[str, Dict[str, Any]] = {}
-        for node_id, document in documents.items():
-            mime_data = prepare_mime_document(document)
-            documents_payload[node_id] = {
-                "filename": mime_data.filename,
-                "content": mime_data.content,
-                "mime_type": mime_data.mime_type,
-            }
-
-        data = {"documents": documents_payload}
-        return PreparedRequest(method="POST", url=f"/v1/workflows/{workflow_id}/run", data=data)
-
-    def prepare_get_run(self, run_id: str) -> PreparedRequest:
-        """Prepare a request to get a workflow run by ID.
-
-        Args:
-            run_id: The ID of the workflow run to retrieve
-
-        Returns:
-            PreparedRequest: The prepared request
-        """
-        return PreparedRequest(method="GET", url=f"/v1/workflows/runs/{run_id}")
-
-
-class Workflows(SyncAPIResource, WorkflowsMixin):
-    """Workflows API wrapper for synchronous operations."""
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def run(
-        self,
-        workflow_id: str,
-        documents: Dict[str, DocumentInput],
-    ) -> WorkflowRun:
-        """Run a workflow with the provided input documents.
-
-        This creates a workflow run and starts execution in the background.
-        The returned WorkflowRun will have status "running" - use get_run() 
-        to check for updates on the run status.
-
-        Args:
-            workflow_id: The ID of the workflow to run
-            documents: Mapping of start node IDs to their input documents.
-                       Each document can be a file path, bytes, file-like object,
-                       MIMEData, PIL Image, or HttpUrl.
-
-        Returns:
-            WorkflowRun: The created workflow run with status "running"
-
-        Raises:
-            HTTPException: If the request fails (e.g., workflow not found,
-                          missing input documents for start nodes)
-
-        Example:
-            >>> run = client.workflows.run(
-            ...     workflow_id="wf_abc123",
-            ...     documents={
-            ...         "start-node-1": Path("invoice.pdf"),
-            ...         "start-node-2": Path("receipt.pdf"),
-            ...     }
-            ... )
-            >>> print(f"Run started: {run.id}, status: {run.status}")
-        """
-        request = self.prepare_run(workflow_id=workflow_id, documents=documents)
-        response = self._client._prepared_request(request)
-        return WorkflowRun.model_validate(response)
-
-    def get_run(self, run_id: str) -> WorkflowRun:
-        """Get a workflow run by ID.
-
-        Args:
-            run_id: The ID of the workflow run to retrieve
-
-        Returns:
-            WorkflowRun: The workflow run
-
-        Raises:
-            HTTPException: If the request fails (e.g., run not found)
-        """
-        request = self.prepare_get_run(run_id)
-        response = self._client._prepared_request(request)
-        return WorkflowRun.model_validate(response)
-
-
-class AsyncWorkflows(AsyncAPIResource, WorkflowsMixin):
-    """Workflows API wrapper for asynchronous operations."""
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    async def run(
-        self,
-        workflow_id: str,
-        documents: Dict[str, DocumentInput],
-    ) -> WorkflowRun:
-        """Run a workflow with the provided input documents.
-
-        This creates a workflow run and starts execution in the background.
-        The returned WorkflowRun will have status "running" - use get_run() 
-        to check for updates on the run status.
+from .runs import WorkflowRuns, AsyncWorkflowRuns
 
-        Args:
-            workflow_id: The ID of the workflow to run
-            documents: Mapping of start node IDs to their input documents.
-                       Each document can be a file path, bytes, file-like object,
-                       MIMEData, PIL Image, or HttpUrl.
 
-        Returns:
-            WorkflowRun: The created workflow run with status "running"
+class Workflows(SyncAPIResource):
+    """Workflows API wrapper for synchronous operations.
 
-        Raises:
-            HTTPException: If the request fails (e.g., workflow not found,
-                          missing input documents for start nodes)
+    Sub-clients:
+        runs: Workflow run operations (create, get)
+    """
 
-        Example:
-            >>> run = await client.workflows.run(
-            ...     workflow_id="wf_abc123",
-            ...     documents={
-            ...         "start-node-1": Path("invoice.pdf"),
-            ...         "start-node-2": Path("receipt.pdf"),
-            ...     }
-            ... )
-            >>> print(f"Run started: {run.id}, status: {run.status}")
-        """
-        request = self.prepare_run(workflow_id=workflow_id, documents=documents)
-        response = await self._client._prepared_request(request)
-        return WorkflowRun.model_validate(response)
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+        self.runs = WorkflowRuns(client=client)
 
-    async def get_run(self, run_id: str) -> WorkflowRun:
-        """Get a workflow run by ID.
 
-        Args:
-            run_id: The ID of the workflow run to retrieve
+class AsyncWorkflows(AsyncAPIResource):
+    """Workflows API wrapper for asynchronous operations.
 
-        Returns:
-            WorkflowRun: The workflow run
+    Sub-clients:
+        runs: Workflow run operations (create, get)
+    """
 
-        Raises:
-            HTTPException: If the request fails (e.g., run not found)
-        """
-        request = self.prepare_get_run(run_id)
-        response = await self._client._prepared_request(request)
-        return WorkflowRun.model_validate(response)
+    def __init__(self, client: Any) -> None:
+        super().__init__(client=client)
+        self.runs = AsyncWorkflowRuns(client=client)

retab/resources/workflows/runs/__init__.py

@@ -0,0 +1,3 @@
+from .client import AsyncWorkflowRuns, WorkflowRuns
+
+__all__ = ["WorkflowRuns", "AsyncWorkflowRuns"]

retab/resources/workflows/runs/client.py

@@ -0,0 +1,190 @@
+from io import IOBase
+from pathlib import Path
+from typing import Any, Dict
+
+import PIL.Image
+from pydantic import HttpUrl
+
+from ...._resource import AsyncAPIResource, SyncAPIResource
+from ....utils.mime import MIMEData, prepare_mime_document
+from ....types.standards import PreparedRequest
+from ....types.workflows import WorkflowRun
+
+
+# Type alias for document inputs
+DocumentInput = Path | str | bytes | IOBase | MIMEData | PIL.Image.Image | HttpUrl
+
+
+class WorkflowRunsMixin:
+    """Mixin providing shared methods for workflow run operations."""
+
+    def prepare_create(
+        self,
+        workflow_id: str,
+        documents: Dict[str, DocumentInput],
+    ) -> PreparedRequest:
+        """Prepare a request to run a workflow with input documents.
+
+        Args:
+            workflow_id: The ID of the workflow to run
+            documents: Mapping of start node IDs to their input documents.
+                       Each document can be a file path, bytes, file-like object,
+                       MIMEData, PIL Image, or HttpUrl.
+
+        Returns:
+            PreparedRequest: The prepared request
+
+        Example:
+            >>> client.workflows.runs.create(
+            ...     workflow_id="wf_abc123",
+            ...     documents={
+            ...         "start-node-1": Path("invoice.pdf"),
+            ...         "start-node-2": Path("receipt.pdf"),
+            ...     }
+            ... )
+        """
+        # Convert each document to MIMEData and then to the format expected by the backend
+        documents_payload: Dict[str, Dict[str, Any]] = {}
+        for node_id, document in documents.items():
+            mime_data = prepare_mime_document(document)
+            documents_payload[node_id] = {
+                "filename": mime_data.filename,
+                "content": mime_data.content,
+                "mime_type": mime_data.mime_type,
+            }
+
+        data = {"documents": documents_payload}
+        return PreparedRequest(method="POST", url=f"/v1/workflows/{workflow_id}/run", data=data)
+
+    def prepare_get(self, run_id: str) -> PreparedRequest:
+        """Prepare a request to get a workflow run by ID.
+
+        Args:
+            run_id: The ID of the workflow run to retrieve
+
+        Returns:
+            PreparedRequest: The prepared request
+        """
+        return PreparedRequest(method="GET", url=f"/v1/workflows/runs/{run_id}")
+
+
+class WorkflowRuns(SyncAPIResource, WorkflowRunsMixin):
+    """Workflow Runs API wrapper for synchronous operations."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def create(
+        self,
+        workflow_id: str,
+        documents: Dict[str, DocumentInput],
+    ) -> WorkflowRun:
+        """Run a workflow with the provided input documents.
+
+        This creates a workflow run and starts execution in the background.
+        The returned WorkflowRun will have status "running" - use get()
+        to check for updates on the run status.
+
+        Args:
+            workflow_id: The ID of the workflow to run
+            documents: Mapping of start node IDs to their input documents.
+                       Each document can be a file path, bytes, file-like object,
+                       MIMEData, PIL Image, or HttpUrl.
+
+        Returns:
+            WorkflowRun: The created workflow run with status "running"
+
+        Raises:
+            HTTPException: If the request fails (e.g., workflow not found,
+                          missing input documents for start nodes)
+
+        Example:
+            >>> run = client.workflows.runs.create(
+            ...     workflow_id="wf_abc123",
+            ...     documents={
+            ...         "start-node-1": Path("invoice.pdf"),
+            ...         "start-node-2": Path("receipt.pdf"),
+            ...     }
+            ... )
+            >>> print(f"Run started: {run.id}, status: {run.status}")
+        """
+        request = self.prepare_create(workflow_id=workflow_id, documents=documents)
+        response = self._client._prepared_request(request)
+        return WorkflowRun.model_validate(response)
+
+    def get(self, run_id: str) -> WorkflowRun:
+        """Get a workflow run by ID.
+
+        Args:
+            run_id: The ID of the workflow run to retrieve
+
+        Returns:
+            WorkflowRun: The workflow run
+
+        Raises:
+            HTTPException: If the request fails (e.g., run not found)
+        """
+        request = self.prepare_get(run_id)
+        response = self._client._prepared_request(request)
+        return WorkflowRun.model_validate(response)
+
+
+class AsyncWorkflowRuns(AsyncAPIResource, WorkflowRunsMixin):
+    """Workflow Runs API wrapper for asynchronous operations."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    async def create(
+        self,
+        workflow_id: str,
+        documents: Dict[str, DocumentInput],
+    ) -> WorkflowRun:
+        """Run a workflow with the provided input documents.
+
+        This creates a workflow run and starts execution in the background.
+        The returned WorkflowRun will have status "running" - use get()
+        to check for updates on the run status.
+
+        Args:
+            workflow_id: The ID of the workflow to run
+            documents: Mapping of start node IDs to their input documents.
+                       Each document can be a file path, bytes, file-like object,
+                       MIMEData, PIL Image, or HttpUrl.
+
+        Returns:
+            WorkflowRun: The created workflow run with status "running"
+
+        Raises:
+            HTTPException: If the request fails (e.g., workflow not found,
+                          missing input documents for start nodes)
+
+        Example:
+            >>> run = await client.workflows.runs.create(
+            ...     workflow_id="wf_abc123",
+            ...     documents={
+            ...         "start-node-1": Path("invoice.pdf"),
+            ...         "start-node-2": Path("receipt.pdf"),
+            ...     }
+            ... )
+            >>> print(f"Run started: {run.id}, status: {run.status}")
+        """
+        request = self.prepare_create(workflow_id=workflow_id, documents=documents)
+        response = await self._client._prepared_request(request)
+        return WorkflowRun.model_validate(response)
+
+    async def get(self, run_id: str) -> WorkflowRun:
+        """Get a workflow run by ID.
+
+        Args:
+            run_id: The ID of the workflow run to retrieve
+
+        Returns:
+            WorkflowRun: The workflow run
+
+        Raises:
+            HTTPException: If the request fails (e.g., run not found)
+        """
+        request = self.prepare_get(run_id)
+        response = await self._client._prepared_request(request)
+        return WorkflowRun.model_validate(response)

retab/types/documents/edit.py

@@ -107,10 +107,15 @@ class OCRResult(BaseModel):
 class InferFormSchemaRequest(BaseModel):
     """Request to infer form schema from a PDF or DOCX document."""
     
-    document: MIMEData = Field(..., description="Input document (PDF or DOCX). DOCX files will be converted to PDF.")
+    document: MIMEData = Field(..., description="Input document (PDF, DOCX, XLSX or PPTX).")
     model: str = Field(default="retab-small", description="LLM model to use for inference")
 
 
+class EditConfig(BaseModel):
+    """Configuration for edit requests."""
+    color: str = Field(default="#000080", description="Hex code of the color to use for the filled text")
+
+
 class EditRequest(BaseModel):
     """Request for the infer_and_fill_schema endpoint.
     
@@ -118,10 +123,11 @@ class EditRequest(BaseModel):
     - When `document` is provided: OCR + LLM inference to detect and fill form fields
     - When `template_id` is provided: Uses pre-defined form fields from the template (PDF only)
     """
-    document: Optional[MIMEData] = Field(default=None, description="Input document (PDF or DOCX). DOCX files will be converted to PDF. Mutually exclusive with template_id.")
+    document: Optional[MIMEData] = Field(default=None, description="Input document (PDF, DOCX, XLSX or PPTX). Mutually exclusive with template_id.")
     model: str = Field(default="retab-small", description="LLM model to use for inference")
     instructions: str = Field(..., description="Instructions to fill the form")
     template_id: Optional[str] = Field(default=None, description="Template ID to use for filling. When provided, uses the template's pre-defined form fields and empty PDF. Only works for PDF documents. Mutually exclusive with document.")
+    config: EditConfig = Field(default_factory=EditConfig, description="Configuration for the edit request")
 
 class EditResponse(BaseModel):
     """Response from the fill_form endpoint.

retab/types/edit/templates.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel, Field
 import datetime
 
 from ..mime import BaseMIMEData, MIMEData
-from ..documents.edit import FormField
+from ..documents.edit import FormField, EditConfig
 
 
 class EditTemplate(BaseModel):
@@ -48,3 +48,4 @@ class FillTemplateRequest(BaseModel):
     model: str = Field(default="retab-small", description="LLM model to use for inference")
     instructions: str = Field(..., description="Instructions to fill the form")
     template_id: str = Field(..., description="Template ID to use for filling. When provided, uses the template's pre-defined form fields and empty PDF. Only works for PDF documents. Mutually exclusive with document.")
+    config: EditConfig = Field(default_factory=EditConfig, description="Configuration for the fill request")

{retab-0.0.84.dist-info → retab-0.0.86.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: retab
-Version: 0.0.84
+Version: 0.0.86
 Summary: Retab official python library
 Home-page: https://github.com/retab-dev/retab
 Author: Retab

{retab-0.0.84.dist-info → retab-0.0.86.dist-info}/RECORD

@@ -9,15 +9,19 @@ retab/resources/schemas.py,sha256=rZ6OzfmoYv-mGaRVzvXjO09dD-KxP74mZhOO8sMgcDQ,46
 retab/resources/documents/__init__.py,sha256=OjXmngFN0RKqO4SI-mJBNzr6Ex6rMxfq0DxaqzP0RQs,89
 retab/resources/documents/client.py,sha256=0ZOJojT4M9QZ53nheS_vuNZWcnmwTnKx3YqYyJ7_sGY,48912
 retab/resources/edit/__init__.py,sha256=yycIstpTSKsz2qXbrY3Buzd35UDcPWvb5hw6Eb2rLow,69
-retab/resources/edit/client.py,sha256=osWvuKj2SNH6-nQKsWcTYcm3jVENGlwGTvDnT45nDBY,6649
+retab/resources/edit/client.py,sha256=DJKlwh8xui7IDRjwPmiGKTC1_HshXLYXX-xr93FhSbo,1270
+retab/resources/edit/agent/__init__.py,sha256=i5IdOMhwOOQmnhPFeBbh7-ChqwQh5q7oLow1zJ0ZAwM,74
+retab/resources/edit/agent/client.py,sha256=z5kIC7vAPQi98jFfHXymjYg7gf5bSQSCELFGBKBg1s4,5951
 retab/resources/edit/templates/__init__.py,sha256=n-zA_HXo7iGgeIclSwcsxmSueXJIRMo0iZjk_sax85I,90
-retab/resources/edit/templates/client.py,sha256=Eevzy5JaQmG5-hEshugQvrhgIBAjgZ8ZYZkpBSKEdBQ,19729
+retab/resources/edit/templates/client.py,sha256=kEyqat5I84_QBeWSjptteSwvlMGRZ1UF9KDzH7p0f9s,20173
 retab/resources/extractions/__init__.py,sha256=2H1ezUG8hI5SmTRy6NFzXdYLOdGFFsFrI60uzkitV20,97
 retab/resources/extractions/client.py,sha256=sEoNjOgX91FTOgoJUV-I1A9A9xl1ciCdPlhYwjhEjbA,11035
 retab/resources/projects/__init__.py,sha256=tPR3_3tr7bsoYd618qmGjnYN2R23PmF5oCFd7Z5_HGY,85
 retab/resources/projects/client.py,sha256=5LPAhJt5-nqBP4VWYvo0k7cW6HLGF6K9xMiHKQzIXho,15593
 retab/resources/workflows/__init__.py,sha256=-I0QNX7XKEr8ZJTV4-awMyKxZqGlSkKMdibiHiB7cZ0,89
-retab/resources/workflows/client.py,sha256=svKOmkqB1-P56IjzauWNdfQtzT0rlWRIu3EddwX-HiM,6743
+retab/resources/workflows/client.py,sha256=G1dYV66Wsas_QWQ9O2N7s1VUt72TP1W1ZG-_cEWEURM,755
+retab/resources/workflows/runs/__init__.py,sha256=5hPZ-70StN0U8bOlhm9H_ZXFljBjy8VoWQRu1_cGAVM,101
+retab/resources/workflows/runs/client.py,sha256=8l87Sf5RNNLIJNyhCwCprqA9ffq3J9zSlwoQHdyrEN4,6771
 retab/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 retab/types/chat.py,sha256=x9VbtPMa4w6Gc0HrFC3ILl6cCnfEn5ytDnwJtZmlcys,1436
 retab/types/inference_settings.py,sha256=wIivYffvEE7v6lhbjbhAZGssK4uYr64Oq6cZKxzY5_M,1131
@@ -29,12 +33,12 @@ retab/types/documents/__init__.py,sha256=t1jXdpYqi-zQMC_9uM0m7eA1hRU0MCROwUx89cc
 retab/types/documents/classify.py,sha256=Tb6d_7kuTlWLr7bPn782dHrjtUVBCvXV3o9zm7j2lmE,1128
 retab/types/documents/correct_orientation.py,sha256=e-ivsslI6L6Gl0YkcslXw_DH620xMGEYVp4tdeviXeM,261
 retab/types/documents/create_messages.py,sha256=Uym0SnVUGkyt1C5AOD37BsZ3puyeu_igR6X9SboojfA,7267
-retab/types/documents/edit.py,sha256=YOsLE4nDf5XLrgkoAxKvU5pivfTSHSjrQSIm2Ezyfn8,5424
+retab/types/documents/edit.py,sha256=b6UcYLOJkClpMu4QyYmdp-X4WtN8U_3oiMBc1KLklVY,5663
 retab/types/documents/extract.py,sha256=x_59fm69-icsxxGRgpFd0NN-SLRoMYqbvfCZuG7zyGc,18033
 retab/types/documents/parse.py,sha256=MXe7zh3DusWQhGe0Sr95nPy6cB8DRX8MA4Hmjj_AP7E,1300
 retab/types/documents/split.py,sha256=xRdJ6IpSRAPi_ZtAG2FNqg5A-v5tzfb1QQkW5UfO2pY,1246
 retab/types/edit/__init__.py,sha256=M8hF97h7fX8RP9IsB6qpkw0eyvO0DFQvP6FmWL8caCQ,331
-retab/types/edit/templates.py,sha256=4ndnk-MlJE7roP_YktgxLpRSd68hdwNDWiqAFMy0Ddo,2291
+retab/types/edit/templates.py,sha256=RLRIMdXzU-5_3XPf0iMSozjRTAP5Tliq0nrjlZn0l8E,2412
 retab/types/extractions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 retab/types/extractions/types.py,sha256=mnCYSfJoEKsXN2eG-PrahnnQyR6RDjP5VO9sHC1Opmg,102
 retab/types/projects/__init__.py,sha256=I7P_dems5_LOLgYQ-4Bzt9B6P6jRlQwP-D_9GxRDhVk,155
@@ -55,7 +59,7 @@ retab/utils/hashing.py,sha256=_BMVUvftOcJav68QL0rLkH2dbhW9RRJPzeGC2akR0fc,757
 retab/utils/json_schema.py,sha256=zP4pQLpVHBKWo_abCjb_dU4kA0azhHopd-1TFUgVEvc,20655
 retab/utils/mime.py,sha256=mTP_lqSPttOP5DYJxopiWaeFXrUCPjhwd7y53nCVGO4,6189
 retab/utils/stream_context_managers.py,sha256=gI1gVQSj3nWz6Mvjz7Ix5AiY0g6vSL-c2tPfuP04izo,2314
-retab-0.0.84.dist-info/METADATA,sha256=8UeP_dWkqP9GOjbR1vpSGZwa9m528VEYNqkxLvbFrfE,4532
-retab-0.0.84.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-retab-0.0.84.dist-info/top_level.txt,sha256=waQR0EGdhLIQtztoE3AXg7ik5ONQ9q_bsKVpyFuJdq0,6
-retab-0.0.84.dist-info/RECORD,,
+retab-0.0.86.dist-info/METADATA,sha256=X2bfnXHFaYuJVUKWbvbhoxOBoboro6h5GxBY-bVOHc0,4532
+retab-0.0.86.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+retab-0.0.86.dist-info/top_level.txt,sha256=waQR0EGdhLIQtztoE3AXg7ik5ONQ9q_bsKVpyFuJdq0,6
+retab-0.0.86.dist-info/RECORD,,