vlmparse 0.1.0__py3-none-any.whl

vlmparse/base_model.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, ConfigDict
+
+
+class VLMParseBaseModel(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        validate_assignment=True,
+        strict=True,
+        extra="allow",
+    )
+
+    def __repr__(self):
+        from devtools import PrettyFormat
+
+        pformat = PrettyFormat()
+        return pformat(self, highlight=False)

vlmparse/build_doc.py

@@ -0,0 +1,70 @@
+import re
+
+import numpy as np
+import PIL
+import pypdfium2 as pdfium
+from loguru import logger
+
+
+def convert_pdfium(file_path, dpi):
+    pdf = pdfium.PdfDocument(file_path)
+    pil_images = []
+    for page in pdf:
+        pil_images.append(page.render(scale=dpi / 72).to_pil())
+
+    pdf.close()
+    return pil_images
+
+
+def custom_ceil(a, precision=0):
+    return np.round(a + 0.5 * 10 ** (-precision), precision)
+
+
+def convert_pdfium_to_images(file_path, dpi=175):
+    try:
+        images = convert_pdfium(file_path, dpi=dpi)
+        images = [
+            img.convert("L").convert("RGB") if img.mode != "RGB" else img
+            for img in images
+        ]
+
+    except PIL.Image.DecompressionBombError as e:
+        logger.exception(f"Got problem size document with {file_path}")
+        cur_size, limit_size = map(int, re.findall(r"\d+", str(e)))
+        factor = custom_ceil(cur_size / limit_size, precision=1)
+        logger.warning(
+            f"Try again by reducing DPI for doc {file_path} from {dpi} to {dpi//factor}"
+        )
+        dpi = dpi // factor
+        images = convert_pdfium(file_path, dpi=dpi)
+
+    return images
+
+
+def convert_specific_page_to_image(file_path, page_number, dpi=175):
+    pdf = pdfium.PdfDocument(file_path)
+    page = pdf.get_page(page_number)
+    image = page.render(scale=dpi / 72).to_pil()
+    image = image.convert("L").convert("RGB") if image.mode != "RGB" else image
+    pdf.close()
+    return image
+
+
+def resize_image(image, max_image_size):
+    if max_image_size is not None:
+        ratio = max_image_size / max(image.size)
+        if ratio < 1:
+            new_size = (
+                int(image.size[0] * ratio),
+                int(image.size[1] * ratio),
+            )
+            image = image.resize(new_size)
+            logger.info(f"Resized image to {new_size}")
+    return image
+
+
+def get_page_count(file_path):
+    pdf = pdfium.PdfDocument(file_path)
+    count = len(pdf)
+    pdf.close()
+    return count

vlmparse/cli.py

@@ -0,0 +1,409 @@
+from typing import Literal
+
+from loguru import logger
+
+
+class DParseCLI:
+    def serve(self, model: str, port: int | None = None, gpus: str | None = None):
+        """Deploy a VLLM server in a Docker container.
+
+        Args:
+            model: Model name
+            port: VLLM server port (default: 8056)
+            gpus: Comma-separated GPU device IDs (e.g., "0" or "0,1,2"). If not specified, all GPUs will be used.
+        """
+        if port is None:
+            port = 8056
+
+        from vlmparse.registries import docker_config_registry
+
+        docker_config = docker_config_registry.get(model)
+        if docker_config is None:
+            logger.warning(
+                f"No Docker configuration found for model: {model}, using default configuration"
+            )
+            return
+
+        docker_config.docker_port = port
+
+        # Only override GPU configuration if explicitly specified
+        # This preserves CPU-only settings from the config
+        if gpus is not None:
+            docker_config.gpu_device_ids = [g.strip() for g in str(gpus).split(",")]
+        server = docker_config.get_server(auto_stop=False)
+
+        # Deploy server and leave it running (cleanup=False)
+        logger.info(
+            f"Deploying VLLM server for {docker_config.model_name} on port {port}..."
+        )
+
+        base_url, container = server.start()
+
+        logger.info(f"✓ VLLM server ready at {base_url}")
+        logger.info(f"✓ Container ID: {container.id}")
+        logger.info(f"✓ Container name: {container.name}")
+
+    def convert(
+        self,
+        inputs: str | list[str],
+        out_folder: str = ".",
+        model: str | None = None,
+        uri: str | None = None,
+        gpus: str | None = None,
+        mode: Literal["document", "md", "md_page"] = "document",
+        with_vllm_server: bool = False,
+        concurrency: int = 10,
+        dpi: int | None = None,
+    ):
+        """Parse PDF documents and save results.
+
+        Args:
+            inputs: List of folders to process
+            out_folder: Output folder for parsed documents
+            pipe: Converter type ("vllm", "openai", or "lightonocr", default: "vllm")
+            model: Model name. If not specified, the model will be inferred from the URI.
+            uri: URI of the server, if not specified and the pipe is vllm, a local server will be deployed
+            gpus: Comma-separated GPU device IDs (e.g., "0" or "0,1,2"). If not specified, all GPUs will be used.
+            mode: Output mode - "document" (save as JSON zip), "md" (save as markdown file), "md_page" (save as folder of markdown pages)
+            with_vllm_server: If True, a local VLLM server will be deployed if the model is not found in the registry. Note that if the model is in the registry and the uri is None, the server will be anyway deployed.
+            dpi: DPI to use for the conversion. If not specified, the default DPI will be used.
+        """
+        from vlmparse.converter_with_server import ConverterWithServer
+
+        converter_with_server = ConverterWithServer(
+            model=model,
+            uri=uri,
+            gpus=gpus,
+            with_vllm_server=with_vllm_server,
+            concurrency=concurrency,
+        )
+
+        return converter_with_server.parse(
+            inputs=inputs, out_folder=out_folder, mode=mode, dpi=dpi
+        )
+        # from vlmparse.registries import converter_config_registry
+
+        # # Infer model from URI if provided
+        # if uri is not None and model is None:
+        #     import docker
+
+        #     try:
+        #         docker_client = docker.from_env()
+        #         containers = docker_client.containers.list()
+        #         for container in containers:
+        #             # Check both exact match and match with/without trailing slash
+        #             container_uri = container.labels.get("vlmparse_uri", "")
+        #             if container_uri and (
+        #                 container_uri == uri
+        #                 or container_uri.rstrip("/") == uri.rstrip("/")
+        #             ):
+        #                 inferred_model = container.labels.get("vlmparse_model_name")
+        #                 if inferred_model:
+        #                     logger.info(
+        #                         f"Inferred model {inferred_model} from URI {uri}"
+        #                     )
+        #                     model = inferred_model
+        #                     break
+        #     except Exception:
+        #         # If Docker is not available or fails, just proceed with provided arguments
+        #         pass
+
+        # if mode not in ["document", "md", "md_page"]:
+        #     logger.error(f"Invalid mode: {mode}. Must be one of: document, md, md_page")
+        #     return
+
+        # # Expand file paths from glob patterns
+        # file_paths = []
+        # if isinstance(inputs, str):
+        #     inputs = [inputs]
+        # for pattern in inputs:
+        #     if "*" in pattern or "?" in pattern:
+        #         file_paths.extend(glob(pattern, recursive=True))
+        #     elif os.path.isdir(pattern):
+        #         file_paths.extend(glob(os.path.join(pattern, "*.pdf"), recursive=True))
+        #     elif os.path.isfile(pattern):
+        #         file_paths.append(pattern)
+        #     else:
+        #         logger.error(f"Invalid input: {pattern}")
+
+        # # Filter to only existing PDF files
+        # file_paths = [f for f in file_paths if os.path.exists(f) and f.endswith(".pdf")]
+
+        # if not file_paths:
+        #     logger.error("No PDF files found matching the inputs patterns")
+        #     return
+
+        # logger.info(f"Processing {len(file_paths)} files with {model} converter")
+
+        # gpu_device_ids = None
+        # if gpus is not None:
+        #     gpu_device_ids = [g.strip() for g in gpus.split(",")]
+
+        # if uri is None:
+        #     from vlmparse.registries import docker_config_registry
+
+        #     docker_config = docker_config_registry.get(model, default=with_vllm_server)
+
+        #     if docker_config is not None:
+        #         docker_config.gpu_device_ids = gpu_device_ids
+        #         server = docker_config.get_server(auto_stop=True)
+        #         server.start()
+
+        #         client = docker_config.get_client(
+        #             save_folder=out_folder, save_mode=mode
+        #         )
+        #     else:
+        #         client = converter_config_registry.get(model).get_client(
+        #             save_folder=out_folder, save_mode=mode
+        #         )
+
+        # else:
+        #     client_config = converter_config_registry.get(model, uri=uri)
+        #     client = client_config.get_client(save_folder=out_folder, save_mode=mode)
+        # client.num_concurrent_files = concurrency
+        # client.num_concurrent_pages = concurrency
+        # if dpi is not None:
+        #     client.config.dpi = int(dpi)
+        # documents = client.batch(file_paths)
+
+        # if documents is not None:
+        #     logger.info(f"Processed {len(documents)} documents to {out_folder}")
+        # else:
+        #     logger.info(f"Processed {len(file_paths)} documents to {out_folder}")
+
+    def list(self):
+        """List all containers whose name begins with vlmparse."""
+        import docker
+
+        try:
+            client = docker.from_env()
+            containers = client.containers.list()
+
+            if not containers:
+                logger.info("No running containers found")
+                return
+
+            # Filter for containers whose name begins with "vlmparse"
+            vlmparse_containers = [
+                container
+                for container in containers
+                if container.name.startswith("vlmparse")
+            ]
+
+            if not vlmparse_containers:
+                logger.info("No vlmparse containers found")
+                return
+
+            # Prepare table data
+            table_data = []
+            for container in vlmparse_containers:
+                # Extract port mappings
+                ports = []
+                if container.ports:
+                    for _, host_bindings in container.ports.items():
+                        if host_bindings:
+                            for binding in host_bindings:
+                                ports.append(f"{binding['HostPort']}")
+
+                port_str = ", ".join(set(ports)) if ports else "N/A"
+                uri = container.labels.get("vlmparse_uri", "N/A")
+                gpu = container.labels.get("vlmparse_gpus", "N/A")
+
+                table_data.append(
+                    [
+                        container.name,
+                        container.status,
+                        port_str,
+                        gpu,
+                        uri,
+                    ]
+                )
+
+            # Display as table
+            from tabulate import tabulate
+
+            headers = ["Name", "Status", "Port(s)", "GPU", "URI"]
+            table = tabulate(table_data, headers=headers, tablefmt="grid")
+
+            logger.info(f"\nFound {len(vlmparse_containers)} vlmparse container(s):\n")
+            print(table)
+
+        except docker.errors.DockerException as e:
+            logger.error(f"Failed to connect to Docker: {e}")
+            logger.error(
+                "Make sure Docker is running and you have the necessary permissions"
+            )
+
+    def stop(self, container: str | None = None):
+        """Stop a Docker container by its ID or name.
+
+        Args:
+            container: Container ID or name to stop. If not specified, automatically stops the container if only one vlmparse container is running.
+        """
+        import docker
+
+        try:
+            client = docker.from_env()
+
+            # If no container specified, try to auto-select
+            if container is None:
+                containers = client.containers.list()
+                vlmparse_containers = [
+                    c for c in containers if c.name.startswith("vlmparse")
+                ]
+
+                if len(vlmparse_containers) == 0:
+                    logger.error("No vlmparse containers found")
+                    return
+                elif len(vlmparse_containers) > 1:
+                    logger.error(
+                        f"Multiple vlmparse containers found ({len(vlmparse_containers)}). "
+                        "Please specify a container ID or name:"
+                    )
+                    for c in vlmparse_containers:
+                        logger.info(f"  - {c.name} ({c.short_id})")
+                    return
+                else:
+                    target_container = vlmparse_containers[0]
+            else:
+                # Try to get the specified container
+                try:
+                    target_container = client.containers.get(container)
+                except docker.errors.NotFound:
+                    logger.error(f"Container not found: {container}")
+                    return
+
+            # Stop the container
+            logger.info(
+                f"Stopping container: {target_container.name} ({target_container.short_id})"
+            )
+            target_container.stop()
+            logger.info("✓ Container stopped successfully")
+
+        except docker.errors.DockerException as e:
+            logger.error(f"Failed to connect to Docker: {e}")
+            logger.error(
+                "Make sure Docker is running and you have the necessary permissions"
+            )
+
+    def log(self, container: str | None = None, follow: bool = True, tail: int = 500):
+        """Show logs from a Docker container.
+
+        Args:
+            container: Container ID or name. If not specified, automatically selects the container if only one vlmparse container is running.
+            follow: If True, follow log output (stream logs in real-time)
+            tail: Number of lines to show from the end of the logs
+        """
+        import docker
+
+        try:
+            client = docker.from_env()
+
+            # If no container specified, try to auto-select
+            if container is None:
+                containers = client.containers.list()
+                vlmparse_containers = [
+                    c for c in containers if c.name.startswith("vlmparse")
+                ]
+
+                if len(vlmparse_containers) == 0:
+                    logger.error("No vlmparse containers found")
+                    return
+                elif len(vlmparse_containers) > 1:
+                    logger.error(
+                        f"Multiple vlmparse containers found ({len(vlmparse_containers)}). "
+                        "Please specify a container ID or name:"
+                    )
+                    for c in vlmparse_containers:
+                        logger.info(f"  - {c.name} ({c.short_id})")
+                    return
+                else:
+                    target_container = vlmparse_containers[0]
+                    logger.info(
+                        f"Showing logs for: {target_container.name} ({target_container.short_id})"
+                    )
+            else:
+                # Try to get the specified container
+                try:
+                    target_container = client.containers.get(container)
+                except docker.errors.NotFound:
+                    logger.error(f"Container not found: {container}")
+                    return
+
+            # Get and display logs
+            if follow:
+                logger.info("Following logs (press Ctrl+C to stop)...")
+                try:
+                    for log_line in target_container.logs(
+                        stream=True, follow=True, tail=tail
+                    ):
+                        print(log_line.decode("utf-8", errors="replace"), end="")
+                except KeyboardInterrupt:
+                    logger.info("\nStopped following logs")
+            else:
+                logs = target_container.logs().decode("utf-8", errors="replace")
+                print(logs)
+
+        except docker.errors.DockerException as e:
+            logger.error(f"Failed to connect to Docker: {e}")
+            logger.error(
+                "Make sure Docker is running and you have the necessary permissions"
+            )
+
+    def list_register(self):
+        """List all model keys registered in client and server registries."""
+        from vlmparse.registries import (
+            converter_config_registry,
+            docker_config_registry,
+        )
+
+        client_models = sorted(converter_config_registry.list_models())
+        server_models = sorted(docker_config_registry.list_models())
+
+        print("\nClient Models Registry:")
+        for model in client_models:
+            print(f"  - {model}")
+
+        print("\nServer Models Registry:")
+        for model in server_models:
+            print(f"  - {model}")
+
+    def view(self, folder):
+        import subprocess
+        import sys
+
+        from streamlit import runtime
+
+        from vlmparse.st_viewer.st_viewer import __file__ as st_viewer_file
+        from vlmparse.st_viewer.st_viewer import run_streamlit
+
+        if runtime.exists():
+            run_streamlit(folder)
+        else:
+            try:
+                subprocess.run(
+                    [
+                        sys.executable,
+                        "-m",
+                        "streamlit",
+                        "run",
+                        st_viewer_file,
+                        "--",
+                        folder,
+                    ],
+                    check=True,
+                )
+            except KeyboardInterrupt:
+                print("\nStreamlit app terminated by user.")
+            except subprocess.CalledProcessError as e:
+                print(f"Error while running Streamlit: {e}")
+
+
+def main():
+    import fire
+
+    fire.Fire(DParseCLI)
+
+
+if __name__ == "__main__":
+    main()

vlmparse/converter.py

@@ -0,0 +1,179 @@
+import asyncio
+import threading
+import time
+import traceback
+from pathlib import Path
+from typing import Literal
+
+from loguru import logger
+from pydantic import Field
+
+from .base_model import VLMParseBaseModel
+from .build_doc import convert_specific_page_to_image, get_page_count, resize_image
+from .data_model.document import Document, Page, ProcessingError
+
+# Add a lock to ensure PDFium is accessed by only one thread/task at a time
+PDFIUM_LOCK = threading.Lock()
+
+
+class ConverterConfig(VLMParseBaseModel):
+    aliases: list[str] = Field(default_factory=list)
+    dpi: int = 175
+    max_image_size: int | None = 4000
+
+    def get_client(self, **kwargs) -> "BaseConverter":
+        return BaseConverter(config=self, **kwargs)
+
+
+class BaseConverter:
+    def __init__(
+        self,
+        config: ConverterConfig,
+        num_concurrent_files: int = 10,
+        num_concurrent_pages: int = 10,
+        save_folder: str | None = None,
+        save_mode: Literal["document", "md", "md_page"] = "document",
+        debug: bool = False,
+        return_documents_in_batch_mode: bool = False,
+        save_page_images: bool = False,
+    ):
+        self.config = config
+        self.num_concurrent_files = num_concurrent_files
+        self.num_concurrent_pages = num_concurrent_pages
+        self.save_folder = save_folder
+        self.save_mode = save_mode
+        self.debug = debug
+        self.return_documents_in_batch_mode = return_documents_in_batch_mode
+        self.save_page_images = save_page_images
+
+    async def async_call_inside_page(self, page: Page) -> Page:
+        raise NotImplementedError
+
+    def add_page_image(self, page: Page, file_path, page_idx):
+        with PDFIUM_LOCK:
+            image = convert_specific_page_to_image(
+                file_path,
+                page_idx,
+                dpi=self.config.dpi,
+            )
+        image = resize_image(image, self.config.max_image_size)
+        page.buffer_image = image
+        return page
+
+    async def async_call(self, file_path: str | Path) -> Document:
+        tic = time.perf_counter()
+        document = Document(file_path=str(file_path))
+        try:
+            num_pages = get_page_count(file_path)
+            document.pages = [Page() for _ in range(num_pages)]
+
+            semaphore = asyncio.Semaphore(self.num_concurrent_pages)
+
+            async def worker(page_idx: int, page: Page):
+                async with semaphore:
+                    try:
+                        page = await asyncio.to_thread(
+                            self.add_page_image, page, file_path, page_idx
+                        )
+
+                        tic = time.perf_counter()
+                        page = await self.async_call_inside_page(page)
+                        toc = time.perf_counter()
+                        page.latency = toc - tic
+                        logger.debug(f"Time taken: {page.latency} seconds")
+                    except KeyboardInterrupt:
+                        raise
+                    except Exception:
+                        if self.debug:
+                            raise
+                        else:
+                            logger.exception(traceback.format_exc())
+                            page.error = ProcessingError.from_class(self)
+                    if not self.save_page_images:
+                        page.buffer_image = dict(
+                            file_path=str(file_path),
+                            page_idx=page_idx,
+                            dpi=self.config.dpi,
+                            max_image_size=self.config.max_image_size,
+                        )
+
+            tasks = [
+                asyncio.create_task(worker(i, page))
+                for i, page in enumerate(document.pages)
+            ]
+            await asyncio.gather(*tasks)
+        except KeyboardInterrupt:
+            raise
+        except Exception:
+            if self.debug:
+                raise
+            else:
+                logger.exception(traceback.format_exc())
+                document.error = ProcessingError.from_class(self)
+                return document
+        toc = time.perf_counter()
+        document.latency = toc - tic
+        logger.debug(f"Time taken to process the document: {document.latency} seconds")
+        if self.save_folder is not None:
+            self._save_document(document)
+
+        return document
+
+    def _save_document(self, document: Document):
+        """Save document according to save_mode."""
+        if document.is_error:
+            save_folder = Path(self.save_folder) / "errors"
+
+        else:
+            save_folder = Path(self.save_folder) / "results"
+
+        save_folder.mkdir(parents=True, exist_ok=True)
+        doc_name = Path(document.file_path).stem
+
+        if self.save_mode == "document":
+            zip_path = save_folder / f"{doc_name}.zip"
+            document.to_zip(zip_path)
+            logger.info(f"Saved document to {zip_path}")
+
+        elif self.save_mode == "md":
+            md_path = save_folder / f"{doc_name}.md"
+            text_content = "\n\n".join([page.text or "" for page in document.pages])
+            with open(md_path, "w", encoding="utf-8") as f:
+                f.write(text_content)
+            logger.info(f"Saved markdown to {md_path}")
+
+        elif self.save_mode == "md_page":
+            doc_folder = save_folder / doc_name
+            doc_folder.mkdir(parents=True, exist_ok=True)
+            for i, page in enumerate(document.pages, start=1):
+                page_text = page.text if page.text else ""
+                page_path = doc_folder / f"page_{i:04d}.md"
+                with open(page_path, "w", encoding="utf-8") as f:
+                    f.write(page_text)
+            logger.info(f"Saved {len(document.pages)} pages to {doc_folder}")
+
+        else:
+            logger.warning(f"Unknown save_mode: {self.save_mode}, skipping save")
+
+    def __call__(self, file_path: str | Path):
+        return asyncio.run(self.async_call(file_path))
+
+    async def async_batch(self, file_paths: list[str | Path]) -> list[Document] | None:
+        """Process multiple files concurrently with semaphore limit."""
+        semaphore = asyncio.Semaphore(self.num_concurrent_files)
+
+        async def worker(file_path: str | Path) -> Document:
+            async with semaphore:
+                if self.return_documents_in_batch_mode:
+                    return await self.async_call(file_path)
+                else:
+                    await self.async_call(file_path)
+
+        tasks = [asyncio.create_task(worker(file_path)) for file_path in file_paths]
+        documents = await asyncio.gather(*tasks)
+        if self.return_documents_in_batch_mode:
+            return documents
+
+    def batch(self, file_paths: list[str | Path]) -> list[Document] | None:
+        """Synchronous wrapper for async_batch."""
+        return asyncio.run(self.async_batch(file_paths))

vlmparse/converter_with_server.py

@@ -0,0 +1,122 @@
+import datetime
+import os
+from pathlib import Path
+from typing import Literal
+
+from loguru import logger
+
+from vlmparse.servers.utils import get_model_from_uri
+from vlmparse.utils import get_file_paths
+
+
+class ConverterWithServer:
+    def __init__(
+        self,
+        model: str,
+        uri: str | None = None,
+        gpus: str | None = None,
+        port: int | None = None,
+        with_vllm_server: bool = False,
+        concurrency: int = 10,
+    ):
+        from vlmparse.registries import (
+            converter_config_registry,
+            docker_config_registry,
+        )
+
+        self.model = model
+        self.uri = uri
+        self.port = port
+        self.gpus = gpus
+        self.with_vllm_server = with_vllm_server
+        self.concurrency = concurrency
+
+        if self.uri is not None and self.model is None:
+            self.model = get_model_from_uri(self.uri)
+
+        gpu_device_ids = None
+        if self.gpus is not None:
+            gpu_device_ids = [g.strip() for g in self.gpus.split(",")]
+
+        if self.uri is None:
+            docker_config = docker_config_registry.get(
+                self.model, default=self.with_vllm_server
+            )
+            if self.port is not None:
+                docker_config.docker_port = self.port
+
+            if docker_config is not None:
+                docker_config.gpu_device_ids = gpu_device_ids
+                server = docker_config.get_server(auto_stop=True)
+                server.start()
+
+                self.client = docker_config.get_client()
+            else:
+                self.client = converter_config_registry.get(self.model).get_client()
+
+        else:
+            client_config = converter_config_registry.get(self.model, uri=self.uri)
+            self.client = client_config.get_client()
+
+    def parse(
+        self,
+        inputs: str | list[str],
+        out_folder: str = ".",
+        mode: Literal["document", "md", "md_page"] = "document",
+        dpi: int | None = None,
+        debug: bool = False,
+        retrylast: bool = False,
+    ):
+        file_paths = get_file_paths(inputs)
+        assert (
+            out_folder is not None
+        ), "out_folder must be provided if retrylast is True"
+        if retrylast:
+            retry = Path(out_folder)
+            previous_runs = sorted(os.listdir(retry))
+            if len(previous_runs) > 0:
+                retry = retry / previous_runs[-1]
+            else:
+                raise ValueError(
+                    "No previous runs found, do not use the retrylast flag"
+                )
+            already_processed = [
+                f.removesuffix(".zip") for f in os.listdir(retry / "results")
+            ]
+            file_paths = [
+                f
+                for f in file_paths
+                if Path(f).name.removesuffix(".pdf") not in already_processed
+            ]
+
+            logger.debug(f"Number of files after filtering: {len(file_paths)}")
+
+        else:
+            out_folder = Path(out_folder) / (
+                datetime.datetime.now().strftime("%Y-%m-%dT%Hh%Mm%Ss")
+            )
+
+        if dpi is not None:
+            self.client.config.dpi = int(dpi)
+
+        if debug:
+            self.client.debug = debug
+
+        self.client.save_folder = out_folder
+        self.client.save_mode = mode
+        self.client.num_concurrent_files = self.concurrency if not debug else 1
+        self.client.num_concurrent_pages = self.concurrency if not debug else 1
+
+        logger.info(f"Processing {len(file_paths)} files with {self.model} converter")
+
+        documents = self.client.batch(file_paths)
+
+        if documents is not None:
+            logger.info(f"Processed {len(documents)} documents to {out_folder}")
+        else:
+            logger.info(f"Processed {len(file_paths)} documents to {out_folder}")
+
+        return documents
+
+    def get_out_folder(self) -> Path:
+        return self.client.save_folder

vlmparse/registries.py

@@ -0,0 +1,174 @@
+import os
+from collections.abc import Callable
+
+from vlmparse.clients.chandra import ChandraConverterConfig, ChandraDockerServerConfig
+from vlmparse.clients.deepseekocr import (
+    DeepSeekOCRConverterConfig,
+    DeepSeekOCRDockerServerConfig,
+)
+from vlmparse.clients.docling import DoclingConverterConfig, DoclingDockerServerConfig
+from vlmparse.clients.dotsocr import DotsOCRConverterConfig, DotsOCRDockerServerConfig
+from vlmparse.clients.granite_docling import (
+    GraniteDoclingConverterConfig,
+    GraniteDoclingDockerServerConfig,
+)
+from vlmparse.clients.hunyuanocr import (
+    HunyuanOCRConverterConfig,
+    HunyuanOCRDockerServerConfig,
+)
+from vlmparse.clients.lightonocr import (
+    LightOnOCRConverterConfig,
+    LightOnOCRDockerServerConfig,
+)
+from vlmparse.clients.mineru import MinerUConverterConfig, MinerUDockerServerConfig
+from vlmparse.clients.nanonetocr import (
+    NanonetOCR2ConverterConfig,
+    NanonetOCR2DockerServerConfig,
+)
+from vlmparse.clients.olmocr import OlmOCRConverterConfig, OlmOCRDockerServerConfig
+from vlmparse.clients.openai_converter import LLMParams, OpenAIConverterConfig
+from vlmparse.clients.paddleocrvl import (
+    PaddleOCRVLConverterConfig,
+    PaddleOCRVLDockerServerConfig,
+)
+from vlmparse.servers.docker_server import DEFAULT_MODEL_NAME, docker_config_registry
+
+
+def get_default(cls, field_name):
+    field_info = cls.model_fields.get(field_name)
+    if field_info is None:
+        return [] if field_name == "aliases" else None
+    if field_info.default_factory:
+        return field_info.default_factory()
+    return field_info.default
+
+
+for server_config_cls in [
+    ChandraDockerServerConfig,
+    LightOnOCRDockerServerConfig,
+    DotsOCRDockerServerConfig,
+    PaddleOCRVLDockerServerConfig,
+    NanonetOCR2DockerServerConfig,
+    HunyuanOCRDockerServerConfig,
+    DoclingDockerServerConfig,
+    OlmOCRDockerServerConfig,
+    MinerUDockerServerConfig,
+    DeepSeekOCRDockerServerConfig,
+    GraniteDoclingDockerServerConfig,
+]:
+    aliases = get_default(server_config_cls, "aliases") or []
+    model_name = get_default(server_config_cls, "model_name")
+    names = [n for n in aliases + [model_name] if isinstance(n, str)]
+    for name in names:
+        docker_config_registry.register(name, lambda cls=server_config_cls: cls())
+
+
+class ConverterConfigRegistry:
+    """Registry for mapping model names to their Docker configurations."""
+
+    def __init__(self):
+        self._registry = dict()
+
+    def register(
+        self,
+        model_name: str,
+        config_factory: Callable[[str], OpenAIConverterConfig | None],
+    ):
+        """Register a config factory for a model name."""
+        self._registry[model_name] = config_factory
+
+    def get(
+        self, model_name: str, uri: str | None = None
+    ) -> OpenAIConverterConfig | None:
+        """Get config for a model name. Returns default if not registered."""
+        if model_name in self._registry:
+            return self._registry[model_name](uri=uri)
+        # Fallback to OpenAIConverterConfig for unregistered models
+        if uri is not None:
+            return OpenAIConverterConfig(
+                llm_params=LLMParams(base_url=uri, model_name=model_name)
+            )
+        return OpenAIConverterConfig(llm_params=LLMParams(model_name=model_name))
+
+    def list_models(self) -> list[str]:
+        """List all registered model names."""
+        return list(self._registry.keys())
+
+
+# Global registry instance
+converter_config_registry = ConverterConfigRegistry()
+GOOGLE_API_BASE_URL = (
+    os.getenv("GOOGLE_API_BASE_URL")
+    or "https://generativelanguage.googleapis.com/v1beta/openai/"
+)
+
+
+for gemini_model in [
+    "gemini-2.5-pro",
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-lite",
+    "gemini-3-pro-preview",
+]:
+    converter_config_registry.register(
+        gemini_model,
+        lambda uri=None, model=gemini_model: OpenAIConverterConfig(
+            llm_params=LLMParams(
+                model_name=model,
+                base_url=GOOGLE_API_BASE_URL if uri is None else uri,
+                api_key=os.getenv("GOOGLE_API_KEY"),
+            )
+        ),
+    )
+for openai_model in [
+    "gpt-5.1",
+    "gpt-5.1-mini",
+    "gpt-5.1-nano",
+    "gpt-5",
+    "gpt-5-mini",
+    "gpt-5-nano",
+]:
+    converter_config_registry.register(
+        openai_model,
+        lambda uri=None, model=openai_model: OpenAIConverterConfig(
+            llm_params=LLMParams(
+                model_name=model,
+                base_url=None,
+                api_key=os.getenv("OPENAI_API_KEY"),
+            )
+        ),
+    )
+
+for converter_config_cls in [
+    ChandraConverterConfig,
+    LightOnOCRConverterConfig,
+    DotsOCRConverterConfig,
+    PaddleOCRVLConverterConfig,
+    NanonetOCR2ConverterConfig,
+    HunyuanOCRConverterConfig,
+    DeepSeekOCRConverterConfig,
+    GraniteDoclingConverterConfig,
+    OlmOCRConverterConfig,
+]:
+    aliases = get_default(converter_config_cls, "aliases") or []
+    model_name = get_default(converter_config_cls, "model_name")
+    names = [n for n in aliases + [model_name] if isinstance(n, str)]
+    for name in names:
+        converter_config_registry.register(
+            name,
+            lambda uri, cls=converter_config_cls: cls(
+                llm_params=LLMParams(
+                    base_url=uri,
+                    model_name=DEFAULT_MODEL_NAME,
+                    api_key="",
+                )
+            ),
+        )
+for converter_config_cls in [MinerUConverterConfig, DoclingConverterConfig]:
+    aliases = get_default(converter_config_cls, "aliases") or []
+    model_name = get_default(converter_config_cls, "model_name")
+    names = [n for n in aliases + [model_name] if isinstance(n, str)]
+    for name in names:
+        converter_config_registry.register(
+            name,
+            lambda uri, cls=converter_config_cls: cls(base_url=uri),
+        )

vlmparse/utils.py

@@ -0,0 +1,41 @@
+import base64
+import os
+from glob import glob
+from io import BytesIO
+
+from loguru import logger
+from PIL import Image
+
+
+def to_base64(image: Image, extension="PNG"):
+    img_byte_arr = BytesIO()
+    image.save(img_byte_arr, format=extension)
+    img_byte_arr = img_byte_arr.getvalue()
+    return base64.b64encode(img_byte_arr).decode("utf-8")
+
+
+def from_base64(base64_str: str):
+    image_data = base64.b64decode(base64_str)
+    return Image.open(BytesIO(image_data))
+
+
+def get_file_paths(inputs: str | list[str]):
+    # Expand file paths from glob patterns
+    file_paths = []
+    if isinstance(inputs, str):
+        inputs = [inputs]
+    for pattern in inputs:
+        if "*" in pattern or "?" in pattern:
+            file_paths.extend(glob(pattern, recursive=True))
+        elif os.path.isdir(pattern):
+            file_paths.extend(glob(os.path.join(pattern, "*.pdf"), recursive=True))
+        elif os.path.isfile(pattern):
+            file_paths.append(pattern)
+        else:
+            logger.error(f"Invalid input: {pattern}")
+    file_paths = [f for f in file_paths if os.path.exists(f) and f.endswith(".pdf")]
+
+    if not file_paths:
+        logger.error("No PDF files found matching the inputs patterns")
+
+    return file_paths

vlmparse-0.1.0.dist-info/METADATA

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: vlmparse
+Version: 0.1.0
+Requires-Python: >=3.12.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: devtools>=0.12.2
+Requires-Dist: docker>=7.1.0
+Requires-Dist: html-to-markdown>=1.9.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: nest-asyncio>=1.6.0
+Requires-Dist: numpy>=2.3.2
+Requires-Dist: openai>=1.102.0
+Requires-Dist: orjson>=3.11.3
+Requires-Dist: pillow>=11.3.0
+Requires-Dist: pydantic
+Requires-Dist: pypdfium2>=4.30.0
+Requires-Dist: fire>=0.7.1
+Requires-Dist: lxml>=6.0.2
+Requires-Dist: tabulate>=0.9.0
+Provides-Extra: dev
+Requires-Dist: jupyter; extra == "dev"
+Provides-Extra: docling-core
+Requires-Dist: docling-core; extra == "docling-core"
+Provides-Extra: st-app
+Requires-Dist: streamlit>=1.49.0; extra == "st-app"
+Provides-Extra: bench
+Requires-Dist: html-to-markdown>=1.9.0; extra == "bench"
+Requires-Dist: loguru>=0.7.3; extra == "bench"
+Requires-Dist: nest-asyncio>=1.6.0; extra == "bench"
+Requires-Dist: numpy>=2.3.2; extra == "bench"
+Requires-Dist: pillow>=11.3.0; extra == "bench"
+Requires-Dist: pydantic; extra == "bench"
+Requires-Dist: rapidfuzz>=3.14.0; extra == "bench"
+Requires-Dist: unidecode>=1.4.0; extra == "bench"
+Requires-Dist: fire>=0.7.1; extra == "bench"
+Requires-Dist: lxml>=6.0.2; extra == "bench"
+Requires-Dist: datasets>=4.4.1; extra == "bench"
+Requires-Dist: openpyxl>=3.1.5; extra == "bench"
+Requires-Dist: joblib>=1.5.2; extra == "bench"
+Requires-Dist: playwright; extra == "bench"
+Requires-Dist: fuzzysearch>=0.8.1; extra == "bench"
+Provides-Extra: test
+Requires-Dist: pre-commit; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Requires-Dist: ruff; extra == "test"
+Requires-Dist: isort; extra == "test"
+Requires-Dist: pre-commit; extra == "test"
+Dynamic: license-file
+
+# vlmparse
+
+A unified wrapper for Vision Language Models (VLM) and OCR solutions to parse PDF documents into Markdown.
+
+Features:
+
+- ⚡ Async/concurrent processing for high throughput
+- 🐳 Automatic Docker server management for local models
+- 🔄 Unified interface across all VLM/OCR providers
+- 📊 Built-in result visualization with Streamlit
+
+Supported Converters:
+
+- **Open Source Small VLMs**: `lightonocr`, `mineru2.5`, `hunyuanocr`, `paddleocrvl`, `granite-docling`, `olmocr2-fp8`, `dotsocr`, `chandra`, `deepseekocr`, `nanonets/Nanonets-OCR2-3B`
+- **Open Source Generalist VLMs**: such as the Qwen family.
+- **Pipelines**: `docling`
+- **Proprietary LLMs**: `gemini`, `gpt`
+
+## Installation
+
+```bash
+uv sync
+```
+
+With optional dependencies:
+
+```bash
+uv sync --all-extras
+```
+
+Activate the virtual environment:
+```bash
+source .venv/bin/activate
+```
+Other solution: append uv run to all the commands below.
+
+## CLI Usage
+
+### Convert PDFs
+
+With a general VLM (requires setting your api key as an environment variable):
+
+```bash
+vlmparse convert --input "*.pdf" --out_folder ./output --model gemini-2.5-flash-lite
+```
+
+Convert with auto deployment of a small vlm (or any huggingface VLM model, requires a gpu + docker installation):
+
+```bash
+vlmparse convert --input "*.pdf" --out_folder ./output --model nanonets/Nanonets-OCR2-3B
+```
+
+### Deploy a local model server
+
+Deployment (requires a gpu + docker installation):
+- You need a gpu dedicated for this.
+- Check that the port is not used by another service.
+
+```bash
+vlmparse serve --model lightonocr --port 8000 --gpus 1
+```
+
+then convert:
+
+```bash
+vlmparse convert --input "*.pdf" --out_folder ./output --model lightonocr --uri http://localhost:8000/v1
+```
+
+You can also list all running servers:
+
+```bash
+vlmparse list
+```
+
+Show logs of a server (if only one server is running, the container name is not needed):
+```bash
+vlmparse log <container_name>
+```
+
+Stop a server (if only one server is running, the container name is not needed):
+```bash
+vlmparse stop <container_name>
+```
+
+### View conversion results with Streamlit
+
+```bash
+vlmparse view ./output
+```
+
+## Configuration
+
+Set API keys as environment variables:
+
+```bash
+export GOOGLE_API_KEY="your-key"
+export OPENAI_API_KEY="your-key"
+```
+
+## Python API
+
+Client interface:
+
+```python
+from vlmparse.registries import converter_config_registry
+
+# Get a converter configuration
+config = converter_config_registry.get("gemini-2.5-flash-lite")
+client = config.get_client()
+
+# Convert a single PDF
+document = client("path/to/document.pdf")
+print(document.to_markdown())
+
+# Batch convert multiple PDFs
+documents = client.batch(["file1.pdf", "file2.pdf"])
+```
+
+Docker server interface:
+
+```python
+from vlmparse.registries import docker_config_registry
+
+config = docker_config_registry.get("lightonocr")
+server = config.get_server()
+server.start()
+
+# Client calls...
+
+server.stop()
+```

vlmparse-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+vlmparse/base_model.py,sha256=4U4UPe8SNArliKnUf8pp8zQugWYsnhg9okylt7mrW1U,381
+vlmparse/build_doc.py,sha256=9evdU6GwVAZU15dZ1Qght6hNo_QxBQN8X3gmYdU2ltg,1965
+vlmparse/cli.py,sha256=tQma1IkOsFnqPKqqHVO1PJh18n1w82gp4ewA7oraJkE,15855
+vlmparse/converter.py,sha256=5wTA_cFyDMDSY8YgLzZV9SVBKmHjEbJCW8KPoJjmVVA,6880
+vlmparse/converter_with_server.py,sha256=9yoqfv8akB0xZZ7Snjq3aHW5NPNam2AgbK7_rfFqNkk,3909
+vlmparse/registries.py,sha256=TdSR1fx1Tz3roGk4Tk5ckIK6Iz-e4UD4erWUk96fFpQ,5846
+vlmparse/utils.py,sha256=jZWbNMwpZSZL--ZzvL8wPG_7mwpw9Pi36qTO9TjvHZU,1239
+vlmparse-0.1.0.dist-info/licenses/LICENSE,sha256=3TKJHk8hPBR5dbLWZ3IpfCftl-_m-iyBwpYQGZYxj14,1080
+vlmparse-0.1.0.dist-info/METADATA,sha256=4xxtT6rE3pJyqfqbVjl8Llj7C5Az99TeusxXmMHzMMQ,4788
+vlmparse-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vlmparse-0.1.0.dist-info/entry_points.txt,sha256=gD5berP6HwE2wNIkls-Lw5goiceA8uMgPEd7ifnFJXs,47
+vlmparse-0.1.0.dist-info/top_level.txt,sha256=k4ni-GNH_iAX7liQEsk_KY_c3xgZgt8k9fsSs9IXLXs,9
+vlmparse-0.1.0.dist-info/RECORD,,

vlmparse-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vlmparse-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vlmparse = vlmparse.cli:main

vlmparse-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 WisTex TechSero Ltd. Co.
+
+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.

vlmparse-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+vlmparse