datalab-python-sdk 0.1.14__tar.gz → 0.1.15__tar.gz

{datalab_python_sdk-0.1.14 → datalab_python_sdk-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datalab-python-sdk
-Version: 0.1.14
+Version: 0.1.15
 Summary: SDK for the Datalab document intelligence API
 Author-email: Datalab Team <hi@datalab.to>
 License-Expression: MIT

{datalab_python_sdk-0.1.14 → datalab_python_sdk-0.1.15}/datalab_sdk/cli.py

@@ -93,6 +93,9 @@ def marker_options(func):
     func = click.option(
         "--page_schema", help="Schema to set to do structured extraction"
     )(func)
+    func = click.option(
+        "--add_block_ids", is_flag=True, help="Add block IDs to HTML output"
+    )(func)
     return func
 
 
@@ -139,13 +142,19 @@ async def process_files_async(
                 ) as client:
                     if method == "convert":
                         result = await client.convert(
-                            file_path, options=options, save_output=output_path,
-                            max_polls=max_polls, poll_interval=poll_interval
+                            file_path,
+                            options=options,
+                            save_output=output_path,
+                            max_polls=max_polls,
+                            poll_interval=poll_interval,
                         )
                     else:  # method == 'ocr'
                         result = await client.ocr(
-                            file_path, options=options, save_output=output_path,
-                            max_polls=max_polls, poll_interval=poll_interval
+                            file_path,
+                            options=options,
+                            save_output=output_path,
+                            max_polls=max_polls,
+                            poll_interval=poll_interval,
                         )
 
                 return {
@@ -247,6 +256,7 @@ def process_documents(
     disable_image_extraction: bool = False,
     block_correction_prompt: Optional[str] = None,
     page_schema: Optional[str] = None,
+    add_block_ids: bool = False,
 ):
     """Unified document processing function"""
     try:
@@ -290,6 +300,7 @@ def process_documents(
                 block_correction_prompt=block_correction_prompt,
                 skip_cache=skip_cache,
                 page_schema=page_schema,
+                add_block_ids=add_block_ids,
             )
         else:  # method == "ocr"
             options = OCROptions(
@@ -352,6 +363,7 @@ def convert(
     disable_image_extraction: bool,
     block_correction_prompt: Optional[str],
     page_schema: Optional[str],
+    add_block_ids: bool,
 ):
     """Convert documents to markdown, HTML, or JSON"""
     process_documents(
@@ -376,6 +388,7 @@ def convert(
         disable_image_extraction=disable_image_extraction,
         block_correction_prompt=block_correction_prompt,
         page_schema=page_schema,
+        add_block_ids=add_block_ids,
     )
 
 
@@ -465,7 +478,7 @@ def create_workflow(
             name=name, team_id=team_id, steps=workflow_steps
         )
 
-        click.echo(f"Workflow created successfully!")
+        click.echo("Workflow created successfully!")
         click.echo(f"   ID: {workflow.id}")
         click.echo(f"   Name: {workflow.name}")
         click.echo(f"   Team ID: {workflow.team_id}")
@@ -497,7 +510,7 @@ def get_workflow(workflow_id: int, api_key: Optional[str], base_url: str):
         client = DatalabClient(api_key=api_key, base_url=base_url)
         workflow = client.get_workflow(workflow_id)
 
-        click.echo(f"Workflow Details:")
+        click.echo("Workflow Details:")
         click.echo(f"   ID: {workflow.id}")
         click.echo(f"   Name: {workflow.name}")
         click.echo(f"   Team ID: {workflow.team_id}")
@@ -642,13 +655,15 @@ def execute_workflow(
             input_config=input_cfg,
         )
 
-        click.echo(f"\nSuccessfully triggered workflow execution!")
+        click.echo("\nSuccessfully triggered workflow execution!")
         click.echo(f"   Execution ID: {execution.id}")
         click.echo(f"   Status: {execution.status}")
-        click.echo(f"\nTo check the status, run:")
+        click.echo("\nTo check the status, run:")
         click.echo(f"   datalab get-execution-status --execution_id {execution.id}")
-        click.echo(f"\n   Or poll until complete:")
-        click.echo(f"   datalab get-execution-status --execution_id {execution.id} --max_polls 300 --poll_interval 2")
+        click.echo("\n   Or poll until complete:")
+        click.echo(
+            f"   datalab get-execution-status --execution_id {execution.id} --max_polls 300 --poll_interval 2"
+        )
 
     except DatalabError as e:
         click.echo(f"Error: {e}", err=True)
@@ -667,13 +682,18 @@ def execute_workflow(
     help="Output file path to save execution results",
 )
 @click.option(
-    "--max_polls", default=1, type=int, help="Maximum number of polling attempts (1 for single check)"
+    "--max_polls",
+    default=1,
+    type=int,
+    help="Maximum number of polling attempts (1 for single check)",
+)
+@click.option(
+    "--poll_interval", default=1, type=int, help="Polling interval in seconds"
 )
-@click.option("--poll_interval", default=1, type=int, help="Polling interval in seconds")
 @click.option(
     "--download",
     is_flag=True,
-    help="Download actual results from presigned URLs (default: just show URLs)"
+    help="Download actual results from presigned URLs (default: just show URLs)",
 )
 @click.option("--api_key", required=False, help="Datalab API key")
 @click.option("--base_url", default=settings.DATALAB_HOST, help="API base URL")
@@ -704,7 +724,7 @@ def get_execution_status(
             download_results=download,
         )
 
-        click.echo(f"Execution Status:")
+        click.echo("Execution Status:")
         click.echo(f"   Execution ID: {execution.id}")
         click.echo(f"   Workflow ID: {execution.workflow_id}")
         click.echo(f"   Status: {execution.status}")
@@ -712,7 +732,7 @@ def get_execution_status(
         click.echo(f"   Created: {execution.created}")
 
         if execution.steps:
-            click.echo(f"\n   Step Results:")
+            click.echo("\n   Step Results:")
             for step_name, step_data in execution.steps.items():
                 click.echo(f"\n   [{step_name}]")
 
@@ -720,20 +740,34 @@ def get_execution_status(
                 for file_key, file_step_data in step_data.items():
                     if isinstance(file_step_data, dict):
                         click.echo(f"\n      File/Group: {file_key}")
-                        click.echo(f"         Step ID: {file_step_data.get('id', 'N/A')}")
-                        click.echo(f"         Status: {file_step_data.get('status', 'N/A')}")
+                        click.echo(
+                            f"         Step ID: {file_step_data.get('id', 'N/A')}"
+                        )
+                        click.echo(
+                            f"         Status: {file_step_data.get('status', 'N/A')}"
+                        )
 
-                        if file_step_data.get('started_at'):
-                            click.echo(f"         Started: {file_step_data.get('started_at')}")
-                        if file_step_data.get('finished_at'):
-                            click.echo(f"         Finished: {file_step_data.get('finished_at')}")
-                        if file_step_data.get('file_ids'):
-                            click.echo(f"         Files: {', '.join(file_step_data.get('file_ids'))}")
+                        if file_step_data.get("started_at"):
+                            click.echo(
+                                f"         Started: {file_step_data.get('started_at')}"
+                            )
+                        if file_step_data.get("finished_at"):
+                            click.echo(
+                                f"         Finished: {file_step_data.get('finished_at')}"
+                            )
+                        if file_step_data.get("file_ids"):
+                            click.echo(
+                                f"         Files: {', '.join(file_step_data.get('file_ids'))}"
+                            )
 
                         if "output_url" in file_step_data and not download:
-                            click.echo(f"         Output URL: {file_step_data.get('output_url')}")
+                            click.echo(
+                                f"         Output URL: {file_step_data.get('output_url')}"
+                            )
                         elif download and "downloaded_data" in file_step_data:
-                            click.echo(f"         Results: {json.dumps(file_step_data['downloaded_data'], indent=12)}")
+                            click.echo(
+                                f"         Results: {json.dumps(file_step_data['downloaded_data'], indent=12)}"
+                            )
                     else:
                         click.echo(f"      {file_step_data}")
 
@@ -750,7 +784,9 @@ def get_execution_status(
 
 
 @click.command()
-@click.option("--definition", required=True, help="Path to workflow definition JSON file")
+@click.option(
+    "--definition", required=True, help="Path to workflow definition JSON file"
+)
 def visualize_workflow(definition: str):
     """Visualize workflow DAG from a JSON definition file"""
     try:
@@ -763,7 +799,7 @@ def visualize_workflow(definition: str):
         if not definition_path.exists():
             raise DatalabError(f"Definition file not found: {definition}")
 
-        with open(definition_path, 'r') as f:
+        with open(definition_path, "r") as f:
             workflow_def = json.load(f)
 
         name = workflow_def.get("name", "Unnamed Workflow")
@@ -776,9 +812,9 @@ def visualize_workflow(definition: str):
         # Build dependency graph
         step_map = {step["unique_name"]: step for step in steps}
 
-        click.echo(f"\n{'='*70}")
+        click.echo(f"\n{'=' * 70}")
         click.echo(f"Workflow: {name}")
-        click.echo(f"{'='*70}\n")
+        click.echo(f"{'=' * 70}\n")
 
         # Build parent/child maps
         children = defaultdict(list)
@@ -788,9 +824,13 @@ def visualize_workflow(definition: str):
                 children[dep].append(step_name)
 
         # Topological sort to determine layers
-        in_degree = {step["unique_name"]: len(step.get("depends_on", [])) for step in steps}
+        in_degree = {
+            step["unique_name"]: len(step.get("depends_on", [])) for step in steps
+        }
         layers = []
-        queue = deque([s["unique_name"] for s in steps if in_degree[s["unique_name"]] == 0])
+        queue = deque(
+            [s["unique_name"] for s in steps if in_degree[s["unique_name"]] == 0]
+        )
 
         while queue:
             layer = []
@@ -844,11 +884,17 @@ def _render_dag_simple(layers, children, step_map):
 
             # Show the step - color code by step type
             step_color = "blue" if "marker" in step_key else "magenta"
-            click.echo(f"  • {click.style(step_name, fg=step_color)} ({click.style(step_key, fg='white', dim=True)})")
+            click.echo(
+                f"  • {click.style(step_name, fg=step_color)} ({click.style(step_key, fg='white', dim=True)})"
+            )
 
             # Show dependencies if any
             if depends:
-                click.echo(click.style(f"    ← depends on: {', '.join(depends)}", fg="white", dim=True))
+                click.echo(
+                    click.style(
+                        f"    ← depends on: {', '.join(depends)}", fg="white", dim=True
+                    )
+                )
 
         # Show what comes next
         if layer_idx < len(layers) - 1:

{datalab_python_sdk-0.1.14 → datalab_python_sdk-0.1.15}/datalab_sdk/client.py

@@ -109,7 +109,8 @@ class AsyncDatalabClient:
         except aiohttp.ClientResponseError as e:
             try:
                 error_data = await response.json()
-                error_message = error_data.get("error", str(e))
+                # FastAPI returns errors in "detail" field, but some APIs use "error"
+                error_message = error_data.get("detail") or error_data.get("error") or str(e)
             except Exception:
                 error_message = str(e)
             raise DatalabAPIError(
@@ -180,6 +181,15 @@ class AsyncDatalabClient:
         if not file_path.exists():
             raise DatalabFileError(f"File not found: {file_path}")
 
+        # Read file content
+        file_data = file_path.read_bytes()
+        
+        # Check if file is empty
+        if not file_data:
+            raise DatalabFileError(
+                f"File is empty: {file_path}. Please provide a file with content."
+            )
+
         # Determine MIME type
         mime_type, _ = mimetypes.guess_type(str(file_path))
         if not mime_type:
@@ -187,7 +197,7 @@ class AsyncDatalabClient:
             extension = file_path.suffix.lower()
             mime_type = MIMETYPE_MAP.get(extension, "application/octet-stream")
 
-        return file_path.name, file_path.read_bytes(), mime_type
+        return file_path.name, file_data, mime_type
 
     def get_form_params(self, file_path=None, file_url=None, options=None):
         form_data = aiohttp.FormData()
@@ -267,11 +277,17 @@ class AsyncDatalabClient:
             json=result_data.get("json"),
             chunks=result_data.get("chunks"),
             extraction_schema_json=result_data.get("extraction_schema_json"),
+            segmentation_results=result_data.get("segmentation_results"),
             images=result_data.get("images"),
             metadata=result_data.get("metadata"),
             error=result_data.get("error"),
             page_count=result_data.get("page_count"),
             status=result_data.get("status", "complete"),
+            checkpoint_id=result_data.get("checkpoint_id"),
+            versions=result_data.get("versions"),
+            parse_quality_score=result_data.get("parse_quality_score"),
+            runtime=result_data.get("runtime"),
+            cost_breakdown=result_data.get("cost_breakdown"),
         )
 
         # Save output if requested
@@ -317,6 +333,8 @@ class AsyncDatalabClient:
             error=result_data.get("error"),
             page_count=result_data.get("page_count"),
             status=result_data.get("status", "complete"),
+            versions=result_data.get("versions"),
+            cost_breakdown=result_data.get("cost_breakdown"),
         )
 
         # Save output if requested
@@ -464,6 +482,31 @@ class AsyncDatalabClient:
 
         return workflows
 
+    async def delete_workflow(self, workflow_id: int) -> Dict[str, Any]:
+        """
+        Delete a workflow definition
+
+        Args:
+            workflow_id: ID of the workflow to delete
+
+        Returns:
+            Dictionary containing:
+                - success: Whether the deletion was successful
+                - message: Confirmation message
+
+        Raises:
+            DatalabAPIError: If workflow has executions or cannot be deleted
+        """
+        response = await self._make_request(
+            "DELETE",
+            f"/api/v1/workflows/workflows/{workflow_id}",
+        )
+
+        return {
+            "success": response.get("success", True),
+            "message": response.get("message", f"Workflow {workflow_id} deleted successfully"),
+        }
+
     async def execute_workflow(
         self,
         workflow_id: int,
@@ -800,6 +843,95 @@ class AsyncDatalabClient:
             "offset": response.get("offset", offset),
         }
 
+    async def get_file_metadata(
+        self,
+        file_id: Union[int, str],
+    ) -> UploadedFileMetadata:
+        """
+        Get metadata for an uploaded file
+
+        Args:
+            file_id: File ID (integer or hashid string)
+
+        Returns:
+            UploadedFileMetadata object with file information
+        """
+        response = await self._make_request(
+            "GET",
+            f"/api/v1/files/{file_id}",
+        )
+
+        return UploadedFileMetadata(
+            file_id=response["file_id"],
+            original_filename=response["original_filename"],
+            content_type=response["content_type"],
+            reference=response["reference"],
+            upload_status=response["upload_status"],
+            file_size=response.get("file_size"),
+            created=response.get("created"),
+        )
+
+    async def get_file_download_url(
+        self,
+        file_id: Union[int, str],
+        expires_in: int = 3600,
+    ) -> Dict[str, Any]:
+        """
+        Generate presigned URL for downloading a file
+
+        Args:
+            file_id: File ID (integer or hashid string)
+            expires_in: URL expiry time in seconds (default: 3600, max: 86400)
+
+        Returns:
+            Dictionary containing:
+                - download_url: Presigned URL for downloading the file
+                - expires_in: URL expiry time in seconds
+                - file_id: File ID
+                - original_filename: Original filename
+        """
+        if expires_in < 60 or expires_in > 86400:
+            raise ValueError("expires_in must be between 60 and 86400 seconds")
+
+        response = await self._make_request(
+            "GET",
+            f"/api/v1/files/{file_id}/download?expires_in={expires_in}",
+        )
+
+        return {
+            "download_url": response["download_url"],
+            "expires_in": response["expires_in"],
+            "file_id": response["file_id"],
+            "original_filename": response["original_filename"],
+        }
+
+    async def delete_file(
+        self,
+        file_id: Union[int, str],
+    ) -> Dict[str, Any]:
+        """
+        Delete an uploaded file
+
+        Removes the file from both storage and the database.
+
+        Args:
+            file_id: File ID (integer or hashid string)
+
+        Returns:
+            Dictionary containing:
+                - success: Whether the deletion was successful
+                - message: Confirmation message
+        """
+        response = await self._make_request(
+            "DELETE",
+            f"/api/v1/files/{file_id}",
+        )
+
+        return {
+            "success": response.get("success", True),
+            "message": response.get("message", f"File {file_id} deleted successfully"),
+        }
+
 
 class DatalabClient:
     """Synchronous wrapper around AsyncDatalabClient"""
@@ -993,3 +1125,83 @@ class DatalabClient:
         return self._run_async(
             self._async_client.list_files(limit=limit, offset=offset)
         )
+
+    def get_file_metadata(
+        self,
+        file_id: Union[int, str],
+    ) -> UploadedFileMetadata:
+        """
+        Get metadata for an uploaded file (sync version)
+
+        Args:
+            file_id: File ID (integer or hashid string)
+
+        Returns:
+            UploadedFileMetadata object with file information
+        """
+        return self._run_async(
+            self._async_client.get_file_metadata(file_id=file_id)
+        )
+
+    def get_file_download_url(
+        self,
+        file_id: Union[int, str],
+        expires_in: int = 3600,
+    ) -> Dict[str, Any]:
+        """
+        Generate presigned URL for downloading a file (sync version)
+
+        Args:
+            file_id: File ID (integer or hashid string)
+            expires_in: URL expiry time in seconds (default: 3600, max: 86400)
+
+        Returns:
+            Dictionary containing:
+                - download_url: Presigned URL for downloading the file
+                - expires_in: URL expiry time in seconds
+                - file_id: File ID
+                - original_filename: Original filename
+        """
+        return self._run_async(
+            self._async_client.get_file_download_url(file_id=file_id, expires_in=expires_in)
+        )
+
+    def delete_file(
+        self,
+        file_id: Union[int, str],
+    ) -> Dict[str, Any]:
+        """
+        Delete an uploaded file (sync version)
+
+        Removes the file from both storage and the database.
+
+        Args:
+            file_id: File ID (integer or hashid string)
+
+        Returns:
+            Dictionary containing:
+                - success: Whether the deletion was successful
+                - message: Confirmation message
+        """
+        return self._run_async(
+            self._async_client.delete_file(file_id=file_id)
+        )
+
+    def delete_workflow(self, workflow_id: int) -> Dict[str, Any]:
+        """
+        Delete a workflow definition (sync version)
+
+        Args:
+            workflow_id: ID of the workflow to delete
+
+        Returns:
+            Dictionary containing:
+                - success: Whether the deletion was successful
+                - message: Confirmation message
+
+        Raises:
+            DatalabAPIError: If workflow has executions or cannot be deleted
+        """
+        return self._run_async(
+            self._async_client.delete_workflow(workflow_id=workflow_id)
+        )

{datalab_python_sdk-0.1.14 → datalab_python_sdk-0.1.15}/datalab_sdk/mimetypes.py

@@ -9,7 +9,11 @@ MIMETYPE_MAP = {
     ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
     ".doc": "application/msword",
     ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".xlsm": "application/vnd.ms-excel.sheet.macroEnabled.12",
+    ".xltx": "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
     ".xls": "application/vnd.ms-excel",
+    ".csv": "text/csv",
+    ".ods": "application/vnd.oasis.opendocument.spreadsheet",
     ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
     ".ppt": "application/vnd.ms-powerpoint",
     ".html": "text/html",

{datalab_python_sdk-0.1.14 → datalab_python_sdk-0.1.15}/datalab_sdk/models.py

@@ -44,13 +44,40 @@ class ConvertOptions(ProcessingOptions):
     use_llm: bool = False
     strip_existing_ocr: bool = False
     disable_image_extraction: bool = False
+    disable_ocr_math: bool = False
     block_correction_prompt: Optional[str] = None
     additional_config: Optional[Dict[str, Any]] = None
     page_schema: Optional[Dict[str, Any]] = None
+    segmentation_schema: Optional[str] = None  # JSON string for document segmentation
+    save_checkpoint: bool = False
+    extras: Optional[str] = (
+        None  # Comma-separated list: 'track_changes', 'chart_understanding'
+    )
     output_format: str = "markdown"  # markdown, json, html, chunks
     mode: str = "fast"  # fast, balanced, accurate
+    keep_spreadsheet_formatting: bool = False
     webhook_url: Optional[str] = None
     extras: Optional[str] = None  # comma-separated extras
+    add_block_ids: bool = False  # add block IDs to HTML output
+
+    def to_form_data(self) -> Dict[str, Any]:
+        """Convert to form data format for API requests"""
+        # Start with parent's form data
+        form_data = super().to_form_data()
+
+        # Remove keep_spreadsheet_formatting from top-level (it goes in additional_config)
+        form_data.pop("keep_spreadsheet_formatting", None)
+
+        additional_config_dict = {}
+        if self.additional_config:
+            additional_config_dict.update(self.additional_config)
+        if self.keep_spreadsheet_formatting:
+            additional_config_dict["keep_spreadsheet_formatting"] = True
+
+        if additional_config_dict:
+            form_data["additional_config"] = (None, json.dumps(additional_config_dict))
+
+        return form_data
 
 
 @dataclass
@@ -69,11 +96,17 @@ class ConversionResult:
     json: Optional[Dict[str, Any]] = None
     chunks: Optional[Dict[str, Any]] = None
     extraction_schema_json: Optional[str] = None
+    segmentation_results: Optional[Dict[str, Any]] = None
     images: Optional[Dict[str, str]] = None
     metadata: Optional[Dict[str, Any]] = None
     error: Optional[str] = None
     page_count: Optional[int] = None
     status: str = "complete"
+    checkpoint_id: Optional[str] = None
+    versions: Optional[Union[Dict[str, Any], str]] = None
+    parse_quality_score: Optional[float] = None
+    runtime: Optional[float] = None
+    cost_breakdown: Optional[Dict[str, Any]] = None
 
     def save_output(
         self, output_path: Union[str, Path], save_images: bool = True
@@ -270,6 +303,8 @@ class OCRResult:
     error: Optional[str] = None
     page_count: Optional[int] = None
     status: str = "complete"
+    versions: Optional[Union[Dict[str, Any], str]] = None
+    cost_breakdown: Optional[Dict[str, Any]] = None
 
     def get_text(self, page_num: Optional[int] = None) -> str:
         """Extract text from OCR results"""

{datalab_python_sdk-0.1.14 → datalab_python_sdk-0.1.15}/pyproject.toml

@@ -7,7 +7,7 @@ readme = "README.md"
 license = "MIT"
 repository = "https://github.com/datalab-to/sdk"
 keywords = ["datalab", "sdk", "document-intelligence", "api"]
-version = "0.1.14"
+version = "0.1.15"
 description = "SDK for the Datalab document intelligence API"
 requires-python = ">=3.10"
 dependencies = [

{datalab_python_sdk-0.1.14 → datalab_python_sdk-0.1.15}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.10"
 
 [[package]]
@@ -212,7 +212,7 @@ wheels = [
 
 [[package]]
 name = "datalab-python-sdk"
-version = "0.1.14"
+version = "0.1.15"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },