datalab-python-sdk 0.1.0__py3-none-any.whl

datalab_python_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: datalab-python-sdk
+Version: 0.1.0
+Summary: Auto-generated SDK for Datalab API
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: aiohttp>=3.12.14
+Requires-Dist: click>=8.2.1
+Requires-Dist: pydantic-settings<3.0.0,>=2.10.1
+Requires-Dist: pydantic<3.0.0,>=2.11.7
+Requires-Dist: pytest-asyncio>=1.0.0
+Provides-Extra: test
+Requires-Dist: aiofiles>=23.2.0; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'test'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'test'
+Requires-Dist: pytest-mock>=3.11.0; extra == 'test'
+Requires-Dist: pytest>=7.4.0; extra == 'test'

datalab_python_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+datalab_sdk/__init__.py,sha256=Ou4cGIih1julnRVMmXLipBiQibYGGK_f4DtQggM286E,647
+datalab_sdk/cli.py,sha256=aoEunI4h7hOfS3lnGeC55sIEfMz8avKG6rHtjpH4KJw,13191
+datalab_sdk/client.py,sha256=UoP8cZxZOxzuzaRFekHdwKofYVOqQXk2sKRCOTgj1qk,10065
+datalab_sdk/exceptions.py,sha256=MDfNd-l152OUVhZSfEsE95McJq-IuOsrEsEQ4CRMbEI,785
+datalab_sdk/mimetypes.py,sha256=kgAM5ZRIcbjwBgDeMs4LsjtlaYpbDyRLDkZGy8vpruc,698
+datalab_sdk/models.py,sha256=e2_wHonABi_-TVrfe77gniK1Hh-EjepTrItmbRRQMlY,4954
+datalab_sdk/settings.py,sha256=kVa9mlfkbOHX0VyX154UmeN_um1BPNaVBgRQ-DkaUNQ,338
+datalab_python_sdk-0.1.0.dist-info/METADATA,sha256=Z0qLU5jMAdtZnm9lsA6XxZsEvHMo0YMcKaAOqaEFQIQ,609
+datalab_python_sdk-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+datalab_python_sdk-0.1.0.dist-info/entry_points.txt,sha256=rqWxO21UV57JxxyeF20iBTxHpzBYOA69hCHIqwdn-Ok,48
+datalab_python_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=XGjT-Uz6t7UZzr3JCZfilsGcZEgMm_1aONcRunohxWg,1064
+datalab_python_sdk-0.1.0.dist-info/RECORD,,

datalab_python_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

datalab_python_sdk-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+datalab = datalab_sdk.cli:cli

datalab_python_sdk-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,18 @@
+Copyright 2025 Endless Labs Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

datalab_sdk/__init__.py

@@ -0,0 +1,26 @@
+"""
+Datalab SDK - Python client for Datalab API
+
+This SDK provides both synchronous and asynchronous interfaces to the Datalab API,
+supporting document conversion, OCR, layout analysis, and table recognition.
+"""
+
+from .client import DatalabClient, AsyncDatalabClient
+from .exceptions import DatalabError, DatalabAPIError, DatalabTimeoutError
+from .models import (
+    ConversionResult,
+    OCRResult,
+    ProcessingOptions,
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    "DatalabClient",
+    "AsyncDatalabClient",
+    "DatalabError",
+    "DatalabAPIError",
+    "DatalabTimeoutError",
+    "ConversionResult",
+    "OCRResult",
+    "ProcessingOptions",
+]

datalab_sdk/cli.py

@@ -0,0 +1,416 @@
+#!/usr/bin/env python3
+"""
+Datalab SDK Command Line Interface
+"""
+
+import os
+import sys
+import asyncio
+from pathlib import Path
+from typing import Optional, List
+import click
+
+from datalab_sdk.client import DatalabClient, AsyncDatalabClient
+from datalab_sdk.models import ProcessingOptions
+from datalab_sdk.exceptions import DatalabError
+from datalab_sdk.settings import settings
+
+
+def get_supported_extensions() -> List[str]:
+    """Get list of supported file extensions"""
+    return [
+        ".pdf",
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".gif",
+        ".tiff",
+        ".webp",
+        ".docx",
+        ".doc",
+        ".xlsx",
+        ".xls",
+        ".pptx",
+        ".ppt",
+        ".html",
+        ".epub",
+    ]
+
+
+def find_files_in_directory(
+    directory: Path, extensions: Optional[List[str]] = None
+) -> List[Path]:
+    """Find all supported files in a directory"""
+    if extensions is None:
+        extensions = get_supported_extensions()
+
+    files = []
+    for file_path in directory.rglob("*"):
+        if file_path.is_file() and file_path.suffix.lower() in extensions:
+            files.append(file_path)
+
+    return files
+
+
+async def process_files_async(
+    files: List[Path],
+    output_dir: Path,
+    method: str,
+    options: Optional[ProcessingOptions] = None,
+    max_pages: Optional[int] = None,
+    max_concurrent: int = 5,
+) -> List[dict]:
+    """Process files asynchronously"""
+    semaphore = asyncio.Semaphore(max_concurrent)
+
+    async def process_single_file(file_path: Path) -> dict:
+        async with semaphore:
+            try:
+                # Create output path
+                relative_path = file_path.name
+                output_path = output_dir / Path(relative_path).stem
+
+                async with AsyncDatalabClient() as client:
+                    if method == "convert":
+                        result = await client.convert(
+                            file_path, options=options, save_output=output_path
+                        )
+                    else:  # method == 'ocr'
+                        result = await client.ocr(
+                            file_path, max_pages=max_pages, save_output=output_path
+                        )
+
+                return {
+                    "file_path": str(file_path),
+                    "output_path": str(output_path),
+                    "success": result.success,
+                    "error": result.error,
+                    "page_count": result.page_count,
+                }
+            except Exception as e:
+                return {
+                    "file_path": str(file_path),
+                    "output_path": None,
+                    "success": False,
+                    "error": str(e),
+                    "page_count": None,
+                }
+
+    # Process all files concurrently
+    tasks = [process_single_file(file_path) for file_path in files]
+    results = await asyncio.gather(*tasks)
+
+    return results
+
+
+def process_single_file_sync(
+    file_path: Path,
+    output_dir: Path,
+    method: str,
+    options: Optional[ProcessingOptions] = None,
+    max_pages: Optional[int] = None,
+) -> dict:
+    """Process a single file synchronously"""
+    try:
+        # Create output path
+        output_path = output_dir / file_path.stem
+        output_file = output_path / file_path.stem
+
+        client = DatalabClient()
+        if method == "convert":
+            result = client.convert(file_path, options=options, save_output=output_file)
+        else:  # method == 'ocr'
+            result = client.ocr(file_path, max_pages=max_pages, save_output=output_file)
+
+        return {
+            "file_path": str(file_path),
+            "output_path": str(output_path),
+            "success": result.success,
+            "error": result.error,
+            "page_count": result.page_count,
+        }
+    except Exception as e:
+        return {
+            "file_path": str(file_path),
+            "output_path": None,
+            "success": False,
+            "error": str(e),
+            "page_count": None,
+        }
+
+
+@click.group()
+@click.version_option(version="1.0.0")
+def cli():
+    """Datalab SDK - Command line interface for document processing"""
+    pass
+
+
+@click.command()
+@click.argument("path", type=click.Path(exists=True))
+@click.option("--api_key", required=False, help="Datalab API key")
+@click.option(
+    "--output_dir", "-o", required=False, type=click.Path(), help="Output directory"
+)
+@click.option(
+    "--format",
+    "output_format",
+    default="markdown",
+    type=click.Choice(["markdown", "html", "json"]),
+    help="Output format",
+)
+@click.option("--max_pages", type=int, help="Maximum number of pages to process")
+@click.option("--force_ocr", is_flag=True, help="Force OCR on every page")
+@click.option(
+    "--format_lines", is_flag=True, help="Partially OCR lines for better formatting"
+)
+@click.option("--paginate", is_flag=True, help="Add page delimiters to output")
+@click.option("--use_llm", is_flag=True, help="Use LLM to enhance accuracy")
+@click.option("--page_range", help='Page range to process (e.g., "0-2" or "0,1,2")')
+@click.option(
+    "--extensions", help="Comma-separated list of file extensions (for directories)"
+)
+@click.option(
+    "--max_concurrent", default=5, type=int, help="Maximum concurrent requests"
+)
+@click.option("--base_url", default=settings.DATALAB_HOST, help="API base URL")
+def convert(
+    path: str,
+    api_key: str,
+    output_dir: str,
+    output_format: str,
+    max_pages: Optional[int],
+    force_ocr: bool,
+    format_lines: bool,
+    paginate: bool,
+    use_llm: bool,
+    page_range: Optional[str],
+    extensions: Optional[str],
+    max_concurrent: int,
+    base_url: str,
+):
+    """Convert documents to markdown, HTML, or JSON"""
+
+    if api_key is None:
+        api_key = settings.DATALAB_API_KEY
+    if api_key is None:
+        raise DatalabError(
+            "You must either pass in an api key via --api_key or set the DATALAB_API_KEY env variable."
+        )
+
+    path = Path(path)
+
+    if output_dir is None:
+        output_dir = os.getcwd()
+
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Parse extensions
+    file_extensions = None
+    if extensions:
+        file_extensions = [ext.strip() for ext in extensions.split(",")]
+        file_extensions = [
+            ext if ext.startswith(".") else f".{ext}" for ext in file_extensions
+        ]
+
+    # Create processing options
+    options = ProcessingOptions(
+        output_format=output_format,
+        max_pages=max_pages,
+        force_ocr=force_ocr,
+        format_lines=format_lines,
+        paginate=paginate,
+        use_llm=use_llm,
+        page_range=page_range,
+    )
+
+    try:
+        # Set API key and base URL in client
+        settings.DATALAB_API_KEY = api_key
+        settings.DATALAB_HOST = base_url
+
+        if path.is_file():
+            # Single file processing
+            if file_extensions and path.suffix.lower() not in file_extensions:
+                click.echo(f"❌ Skipping {path}: unsupported file type", err=True)
+                sys.exit(1)
+
+            result = process_single_file_sync(path, output_dir, "convert", options)
+
+            if result["success"]:
+                click.echo(f"✅ Successfully converted {result['file_path']}")
+                if result["page_count"]:
+                    click.echo(f"   📄 Processed {result['page_count']} pages")
+                if result["output_path"]:
+                    click.echo(f"   📁 Output saved to: {result['output_path']}")
+            else:
+                click.echo(
+                    f"❌ Failed to convert {result['file_path']}: {result['error']}",
+                    err=True,
+                )
+                sys.exit(1)
+        else:
+            # Directory processing
+            files = find_files_in_directory(path, file_extensions)
+
+            if not files:
+                click.echo(f"❌ No supported files found in {path}", err=True)
+                sys.exit(1)
+
+            click.echo(f"📂 Found {len(files)} files to process")
+
+            # Process files asynchronously
+            results = asyncio.run(
+                process_files_async(
+                    files, output_dir, "convert", options, max_pages, max_concurrent
+                )
+            )
+
+            # Show results
+            successful = sum(1 for r in results if r["success"])
+            failed = len(results) - successful
+
+            click.echo("\n📊 Conversion Summary:")
+            click.echo(f"   ✅ Successfully converted: {successful} files")
+            if failed > 0:
+                click.echo(f"   ❌ Failed: {failed} files")
+
+                # Show failed files
+                click.echo("\n   Failed files:")
+                for result in results:
+                    if not result["success"]:
+                        click.echo(f"      - {result['file_path']}: {result['error']}")
+
+            click.echo(f"\n📁 Output saved to: {output_dir}")
+
+    except DatalabError as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+@click.command()
+@click.argument("path", type=click.Path(exists=True))
+@click.option("--api_key", required=False, help="Datalab API key")
+@click.option(
+    "--output_dir", "-o", required=False, type=click.Path(), help="Output directory"
+)
+@click.option("--max_pages", type=int, help="Maximum number of pages to process")
+@click.option(
+    "--extensions", help="Comma-separated list of file extensions (for directories)"
+)
+@click.option(
+    "--max_concurrent", default=5, type=int, help="Maximum concurrent requests"
+)
+@click.option("--base_url", default=settings.DATALAB_HOST, help="API base URL")
+def ocr(
+    path: str,
+    api_key: str,
+    output_dir: str,
+    max_pages: Optional[int],
+    extensions: Optional[str],
+    max_concurrent: int,
+    base_url: str,
+):
+    """Perform OCR on documents"""
+
+    if api_key is None:
+        api_key = settings.DATALAB_API_KEY
+    if api_key is None:
+        raise DatalabError(
+            "You must either pass in an api key via --api_key or set the DATALAB_API_KEY env variable."
+        )
+
+    path = Path(path)
+
+    if output_dir is None:
+        output_dir = os.getcwd()
+
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Parse extensions
+    file_extensions = None
+    if extensions:
+        file_extensions = [ext.strip() for ext in extensions.split(",")]
+        file_extensions = [
+            ext if ext.startswith(".") else f".{ext}" for ext in file_extensions
+        ]
+
+    try:
+        # Set API key and base URL in client
+        settings.DATALAB_API_KEY = api_key
+        settings.DATALAB_HOST = base_url
+
+        if path.is_file():
+            # Single file processing
+            if file_extensions and path.suffix.lower() not in file_extensions:
+                click.echo(f"❌ Skipping {path}: unsupported file type", err=True)
+                sys.exit(1)
+
+            result = process_single_file_sync(
+                path, output_dir, "ocr", max_pages=max_pages
+            )
+
+            if result["success"]:
+                click.echo(f"✅ Successfully performed OCR on {result['file_path']}")
+                if result["page_count"]:
+                    click.echo(f"   📄 Processed {result['page_count']} pages")
+                if result["output_path"]:
+                    click.echo(f"   📁 Output saved to: {result['output_path']}")
+            else:
+                click.echo(
+                    f"❌ Failed OCR on {result['file_path']}: {result['error']}",
+                    err=True,
+                )
+                sys.exit(1)
+        else:
+            # Directory processing
+            files = find_files_in_directory(path, file_extensions)
+
+            if not files:
+                click.echo(f"❌ No supported files found in {path}", err=True)
+                sys.exit(1)
+
+            click.echo(f"📂 Found {len(files)} files to process")
+
+            # Process files asynchronously
+            results = asyncio.run(
+                process_files_async(
+                    files,
+                    output_dir,
+                    "ocr",
+                    max_pages=max_pages,
+                    max_concurrent=max_concurrent,
+                )
+            )
+
+            # Show results
+            successful = sum(1 for r in results if r["success"])
+            failed = len(results) - successful
+
+            click.echo("\n📊 OCR Summary:")
+            click.echo(f"   ✅ Successfully processed: {successful} files")
+            if failed > 0:
+                click.echo(f"   ❌ Failed: {failed} files")
+
+                # Show failed files
+                click.echo("\n   Failed files:")
+                for result in results:
+                    if not result["success"]:
+                        click.echo(f"      - {result['file_path']}: {result['error']}")
+
+            click.echo(f"\n📁 Output saved to: {output_dir}")
+
+    except DatalabError as e:
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)
+
+
+# Add commands to CLI group
+cli.add_command(convert)
+cli.add_command(ocr)
+
+
+if __name__ == "__main__":
+    cli()

datalab_sdk/client.py

@@ -0,0 +1,301 @@
+"""
+Datalab API client - async core with sync wrapper
+"""
+
+import asyncio
+import mimetypes
+import aiohttp
+from pathlib import Path
+from typing import Union, Optional, Dict, Any
+
+from datalab_sdk.exceptions import (
+    DatalabAPIError,
+    DatalabTimeoutError,
+    DatalabFileError,
+)
+from datalab_sdk.mimetypes import MIMETYPE_MAP
+from datalab_sdk.models import ConversionResult, OCRResult, ProcessingOptions
+from datalab_sdk.settings import settings
+
+
+class AsyncDatalabClient:
+    """Asynchronous client for Datalab API"""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str = settings.DATALAB_HOST,
+        timeout: int = 300,
+    ):
+        """
+        Initialize the async Datalab client
+
+        Args:
+            api_key: Your Datalab API key
+            base_url: Base URL for the API (default: https://www.datalab.to)
+            timeout: Default timeout for requests in seconds
+        """
+        if api_key is None:
+            api_key = settings.DATALAB_API_KEY
+        if api_key is None:
+            raise DatalabAPIError("You must pass in an api_key or set DATALAB_API_KEY.")
+
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._session = None
+
+    async def __aenter__(self):
+        """Async context manager entry"""
+        await self._ensure_session()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit"""
+        await self.close()
+
+    async def _ensure_session(self):
+        """Ensure aiohttp session is created"""
+        if self._session is None:
+            timeout = aiohttp.ClientTimeout(total=self.timeout)
+            self._session = aiohttp.ClientSession(
+                timeout=timeout,
+                headers={
+                    "X-Api-Key": self.api_key,
+                    "User-Agent": "datalab-python-sdk/0.1.0",
+                },
+            )
+
+    async def close(self):
+        """Close the aiohttp session"""
+        if self._session:
+            await self._session.close()
+            self._session = None
+
+    async def _make_request(
+        self, method: str, endpoint: str, **kwargs
+    ) -> Dict[str, Any]:
+        """Make an async request to the API"""
+        await self._ensure_session()
+
+        url = endpoint
+        if not endpoint.startswith("http"):
+            url = f"{self.base_url}/{endpoint.lstrip('/')}"
+
+        try:
+            async with self._session.request(method, url, **kwargs) as response:
+                response.raise_for_status()
+                return await response.json()
+        except asyncio.TimeoutError:
+            raise DatalabTimeoutError(f"Request timed out after {self.timeout} seconds")
+        except aiohttp.ClientResponseError as e:
+            try:
+                error_data = await response.json()
+                error_message = error_data.get("error", str(e))
+            except Exception:
+                error_message = str(e)
+            raise DatalabAPIError(
+                error_message,
+                e.status,
+                error_data if "error_data" in locals() else None,
+            )
+        except aiohttp.ClientError as e:
+            raise DatalabAPIError(f"Request failed: {str(e)}")
+
+    async def _poll_result(
+        self, check_url: str, max_polls: int = 300, poll_interval: int = 1
+    ) -> Dict[str, Any]:
+        """Poll for result completion"""
+        full_url = (
+            check_url
+            if check_url.startswith("http")
+            else f"{self.base_url}/{check_url.lstrip('/')}"
+        )
+
+        for i in range(max_polls):
+            data = await self._make_request("GET", full_url)
+
+            if data.get("status") == "complete":
+                return data
+
+            if not data.get("success", True) and not data.get("status") == "processing":
+                raise DatalabAPIError(
+                    f"Processing failed: {data.get('error', 'Unknown error')}"
+                )
+
+            await asyncio.sleep(poll_interval)
+
+        raise DatalabTimeoutError(
+            f"Polling timed out after {max_polls * poll_interval} seconds"
+        )
+
+    def _prepare_file_data(self, file_path: Union[str, Path]) -> tuple:
+        """Prepare file data for upload"""
+        file_path = Path(file_path)
+
+        if not file_path.exists():
+            raise DatalabFileError(f"File not found: {file_path}")
+
+        # Determine MIME type
+        mime_type, _ = mimetypes.guess_type(str(file_path))
+        if not mime_type:
+            # Try to detect from extension
+            extension = file_path.suffix.lower()
+            mime_type = MIMETYPE_MAP.get(extension, "application/octet-stream")
+
+        return file_path.name, file_path.read_bytes(), mime_type
+
+    # Convenient endpoint-specific methods
+    async def convert(
+        self,
+        file_path: Union[str, Path],
+        options: Optional[ProcessingOptions] = None,
+        save_output: Optional[Union[str, Path]] = None,
+    ) -> ConversionResult:
+        """Convert a document using the marker endpoint"""
+        if options is None:
+            options = ProcessingOptions()
+
+        filename, file_data, mime_type = self._prepare_file_data(file_path)
+
+        form_data = aiohttp.FormData()
+        form_data.add_field(
+            "file", file_data, filename=filename, content_type=mime_type
+        )
+
+        for key, value in options.to_form_data().items():
+            if isinstance(value, tuple):
+                form_data.add_field(key, str(value[1]))
+            else:
+                form_data.add_field(key, str(value))
+
+        initial_data = await self._make_request(
+            "POST", "/api/v1/marker", data=form_data
+        )
+
+        if not initial_data.get("success"):
+            raise DatalabAPIError(
+                f"Request failed: {initial_data.get('error', 'Unknown error')}"
+            )
+
+        result_data = await self._poll_result(initial_data["request_check_url"])
+
+        result = ConversionResult(
+            success=result_data.get("success", False),
+            output_format=result_data.get("output_format", options.output_format),
+            markdown=result_data.get("markdown"),
+            html=result_data.get("html"),
+            json=result_data.get("json"),
+            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"),
+        )
+
+        # Save output if requested
+        if save_output and result.success:
+            output_path = Path(save_output)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            result.save_output(output_path)
+
+        return result
+
+    async def ocr(
+        self,
+        file_path: Union[str, Path],
+        max_pages: Optional[int] = None,
+        save_output: Optional[Union[str, Path]] = None,
+    ) -> OCRResult:
+        """Perform OCR on a document"""
+        filename, file_data, mime_type = self._prepare_file_data(file_path)
+
+        form_data = aiohttp.FormData()
+        form_data.add_field(
+            "file", file_data, filename=filename, content_type=mime_type
+        )
+
+        if max_pages is not None:
+            form_data.add_field("max_pages", str(max_pages))
+
+        initial_data = await self._make_request("POST", "/api/v1/ocr", data=form_data)
+
+        if not initial_data.get("success"):
+            raise DatalabAPIError(
+                f"Request failed: {initial_data.get('error', 'Unknown error')}"
+            )
+
+        result_data = await self._poll_result(initial_data["request_check_url"])
+
+        result = OCRResult(
+            success=result_data.get("success", False),
+            pages=result_data.get("pages", []),
+            error=result_data.get("error"),
+            page_count=result_data.get("page_count"),
+            status=result_data.get("status", "complete"),
+        )
+
+        # Save output if requested
+        if save_output and result.success:
+            output_path = Path(save_output)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            result.save_output(output_path)
+
+        return result
+
+
+class DatalabClient:
+    """Synchronous wrapper around AsyncDatalabClient"""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str = settings.DATALAB_HOST,
+        timeout: int = 300,
+    ):
+        """
+        Initialize the Datalab client
+
+        Args:
+            api_key: Your Datalab API key
+            base_url: Base URL for the API (default: https://www.datalab.to)
+            timeout: Default timeout for requests in seconds
+        """
+        self._async_client = AsyncDatalabClient(api_key, base_url, timeout)
+
+    def _run_async(self, coro):
+        """Run async coroutine in sync context"""
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        return loop.run_until_complete(self._async_wrapper(coro))
+
+    async def _async_wrapper(self, coro):
+        """Wrapper to ensure session management"""
+        async with self._async_client:
+            return await coro
+
+    def convert(
+        self,
+        file_path: Union[str, Path],
+        options: Optional[ProcessingOptions] = None,
+        save_output: Optional[Union[str, Path]] = None,
+    ) -> ConversionResult:
+        """Convert a document using the marker endpoint (sync version)"""
+        return self._run_async(
+            self._async_client.convert(file_path, options, save_output)
+        )
+
+    def ocr(
+        self,
+        file_path: Union[str, Path],
+        max_pages: Optional[int] = None,
+        save_output: Optional[Union[str, Path]] = None,
+    ) -> OCRResult:
+        """Perform OCR on a document (sync version)"""
+        return self._run_async(
+            self._async_client.ocr(file_path, max_pages, save_output)
+        )

datalab_sdk/exceptions.py

@@ -0,0 +1,38 @@
+"""
+Datalab SDK exceptions
+"""
+
+
+class DatalabError(Exception):
+    """Base exception for Datalab SDK errors"""
+
+    pass
+
+
+class DatalabAPIError(DatalabError):
+    """Exception raised when the API returns an error response"""
+
+    def __init__(
+        self, message: str, status_code: int = None, response_data: dict = None
+    ):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_data = response_data
+
+
+class DatalabTimeoutError(DatalabError):
+    """Exception raised when a request times out"""
+
+    pass
+
+
+class DatalabFileError(DatalabError):
+    """Exception raised when there's an issue with file operations"""
+
+    pass
+
+
+class DatalabValidationError(DatalabError):
+    """Exception raised when input validation fails"""
+
+    pass

datalab_sdk/mimetypes.py

@@ -0,0 +1,18 @@
+MIMETYPE_MAP = {
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".tiff": "image/tiff",
+    ".webp": "image/webp",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".doc": "application/msword",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".xls": "application/vnd.ms-excel",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".html": "text/html",
+    ".epub": "application/epub+zip",
+}
+SUPPORTED_EXTENSIONS = list(MIMETYPE_MAP.keys())

datalab_sdk/models.py

@@ -0,0 +1,155 @@
+"""
+Datalab SDK data models
+"""
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Any, Union
+from pathlib import Path
+import json
+import base64
+
+
+@dataclass
+class ProcessingOptions:
+    """Options for document processing"""
+
+    # Common options
+    max_pages: Optional[int] = None
+    output_format: str = "markdown"  # markdown, json, html
+    skip_cache: bool = True
+
+    # Marker specific options
+    force_ocr: bool = False
+    format_lines: bool = False
+    paginate: bool = False
+    use_llm: bool = False
+    strip_existing_ocr: bool = False
+    disable_image_extraction: bool = False
+    page_range: Optional[str] = None
+    block_correction_prompt: Optional[str] = None
+    additional_config: Optional[Dict[str, Any]] = None
+    page_schema: Optional[Dict[str, Any]] = None
+
+    # Table recognition options
+    skip_table_detection: bool = False
+    detect_cell_boxes: bool = False
+
+    def to_form_data(self) -> Dict[str, Any]:
+        """Convert to form data format for API requests"""
+        form_data = {}
+
+        # Add non-None values
+        for key, value in self.__dict__.items():
+            if value is not None:
+                if isinstance(value, bool):
+                    form_data[key] = (None, value)
+                elif isinstance(value, (dict, list)):
+                    form_data[key] = (None, json.dumps(value, indent=2))
+                else:
+                    form_data[key] = (None, value)
+
+        return form_data
+
+
+@dataclass
+class ConversionResult:
+    """Result from document conversion (marker endpoint)"""
+
+    success: bool
+    output_format: str
+    markdown: Optional[str] = None
+    html: Optional[str] = None
+    json: 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"
+
+    def save_output(
+        self, output_path: Union[str, Path], save_images: bool = True
+    ) -> None:
+        """Save the conversion output to files"""
+        output_path = Path(output_path)
+
+        # Save main content
+        if self.markdown:
+            with open(output_path.with_suffix(".md"), "w", encoding="utf-8") as f:
+                f.write(self.markdown)
+
+        if self.html:
+            with open(output_path.with_suffix(".html"), "w", encoding="utf-8") as f:
+                f.write(self.html)
+
+        if self.json:
+            with open(output_path.with_suffix(".json"), "w", encoding="utf-8") as f:
+                json.dump(self.json, f, indent=2)
+
+        # Save images if present
+        if save_images and self.images:
+            images_dir = output_path.parent
+            images_dir.mkdir(exist_ok=True)
+
+            for filename, base64_data in self.images.items():
+                image_path = images_dir / filename
+                with open(image_path, "wb") as f:
+                    f.write(base64.b64decode(base64_data))
+
+        # Save metadata if present
+        if self.metadata:
+            with open(
+                output_path.with_suffix(".metadata.json"), "w", encoding="utf-8"
+            ) as f:
+                json.dump(self.metadata, f, indent=2)
+
+
+@dataclass
+class OCRResult:
+    """Result from OCR processing"""
+
+    success: bool
+    pages: List[Dict[str, Any]]
+    error: Optional[str] = None
+    page_count: Optional[int] = None
+    status: str = "complete"
+
+    def get_text(self, page_num: Optional[int] = None) -> str:
+        """Extract text from OCR results"""
+        if page_num is not None:
+            # Get text from specific page
+            page = next((p for p in self.pages if p.get("page") == page_num), None)
+            if page:
+                return "\n".join([line["text"] for line in page.get("text_lines", [])])
+            return ""
+        else:
+            # Get all text
+            all_text = []
+            for page in self.pages:
+                page_text = "\n".join(
+                    [line["text"] for line in page.get("text_lines", [])]
+                )
+                all_text.append(page_text)
+            return "\n\n".join(all_text)
+
+    def save_output(self, output_path: Union[str, Path]) -> None:
+        """Save the OCR output to a text file"""
+        output_path = Path(output_path)
+
+        # Save as text file
+        text_content = self.get_text()
+        with open(output_path.with_suffix(".txt"), "w", encoding="utf-8") as f:
+            f.write(text_content)
+
+        # Save detailed OCR data as JSON
+        with open(output_path.with_suffix(".ocr.json"), "w", encoding="utf-8") as f:
+            json.dump(
+                {
+                    "success": self.success,
+                    "pages": self.pages,
+                    "error": self.error,
+                    "page_count": self.page_count,
+                    "status": self.status,
+                },
+                f,
+                indent=2,
+            )

datalab_sdk/settings.py

@@ -0,0 +1,15 @@
+from pydantic_settings import BaseSettings
+import os
+
+
+class Settings(BaseSettings):
+    # Paths
+    BASE_DIR: str = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    LOGLEVEL: str = "DEBUG"
+
+    # Base settings
+    DATALAB_API_KEY: str | None = None
+    DATALAB_HOST: str = "https://www.datalab.to"
+
+
+settings = Settings()