vlmparse 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

vlmparse/build_doc.py

@@ -1,10 +1,13 @@
 import re
+from pathlib import Path
 
 import numpy as np
 import PIL
 import pypdfium2 as pdfium
 from loguru import logger
 
+from .constants import PDF_EXTENSION
+
 
 def convert_pdfium(file_path, dpi):
     pdf = pdfium.PdfDocument(file_path)
@@ -64,7 +67,10 @@ def resize_image(image, max_image_size):
 
 
 def get_page_count(file_path):
-    pdf = pdfium.PdfDocument(file_path)
-    count = len(pdf)
-    pdf.close()
-    return count
+    if Path(file_path).suffix.lower() == PDF_EXTENSION:
+        pdf = pdfium.PdfDocument(file_path)
+        count = len(pdf)
+        pdf.close()
+        return count
+    else:
+        return 1

vlmparse/clients/deepseekocr.py

@@ -1,7 +1,155 @@
+import re
+from typing import ClassVar, Literal
+
+from loguru import logger
+from PIL import Image
 from pydantic import Field
 
-from vlmparse.clients.openai_converter import OpenAIConverterConfig
+from vlmparse.clients.openai_converter import (
+    OpenAIConverterClient,
+    OpenAIConverterConfig,
+)
+from vlmparse.data_model.box import BoundingBox
+from vlmparse.data_model.document import Item, Page
 from vlmparse.servers.docker_server import VLLMDockerServerConfig
+from vlmparse.utils import to_base64
+
+
+def re_match(text):
+    pattern = r"(<\|ref\|>(.*?)<\|/ref\|><\|det\|>(.*?)<\|/det\|>)"
+    matches = re.findall(pattern, text, re.DOTALL)
+
+    matches_image = []
+    matches_other = []
+    for a_match in matches:
+        if "<|ref|>image<|/ref|>" in a_match[0]:
+            matches_image.append(a_match[0])
+        else:
+            matches_other.append(a_match[0])
+    return matches, matches_image, matches_other
+
+
+def extract_coordinates_and_label(ref_text):
+    try:
+        label_type = ref_text[1]
+        matches = re.findall(r"\[(\d+),\s*(\d+),\s*(\d+),\s*(\d+)\]", ref_text[2])
+        cor_list = [[int(x) for x in m] for m in matches]
+    except Exception as e:
+        logger.warning(f"Error parsing coordinates: {e}")
+        return None
+
+    return (label_type, cor_list)
+
+
+class DeepSeekOCRConverterClient(OpenAIConverterClient):
+    """Client for DeepSeekOCR with specific post-processing."""
+
+    PROMPTS: ClassVar[dict] = {
+        "layout": "<|grounding|>Convert the document to markdown.",
+        "ocr": "Free OCR.",
+        "image_description": "Describe this image in detail.",
+    }
+
+    def extract_items(self, image: Image.Image, matches: list) -> list[Item]:
+        items = []
+        width, height = image.size
+
+        for match in matches:
+            # match is tuple: (full_str, label, coords_str)
+            result = extract_coordinates_and_label(match)
+            if not result:
+                continue
+
+            category, coords = result
+            if not coords:
+                continue
+
+            # Create boxes
+            boxes = []
+            for point in coords:
+                if len(point) != 4:
+                    continue
+                x1, y1, x2, y2 = point
+                # Scale to image size (0-999 -> pixel)
+                x1 = (x1 / 999) * width
+                y1 = (y1 / 999) * height
+                x2 = (x2 / 999) * width
+                y2 = (y2 / 999) * height
+
+                boxes.append(
+                    BoundingBox(
+                        l=min(x1, x2), t=min(y1, y2), r=max(x1, x2), b=max(y1, y2)
+                    )
+                )
+
+            if not boxes:
+                continue
+
+            # Merge if multiple boxes for one item
+            try:
+                final_box = (
+                    BoundingBox.merge_boxes(boxes) if len(boxes) > 1 else boxes[0]
+                )
+            except Exception as e:
+                logger.warning(f"Error merging boxes: {e}")
+                continue
+
+            items.append(Item(category=category, text=match[1], box=final_box))
+
+        return items
+
+    async def async_call_inside_page(self, page: Page) -> Page:
+        # Prepare messages as in parent class
+        image = page.image
+
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/png;base64,{to_base64(image)}"
+                        },
+                    },
+                    {"type": "text", "text": self.PROMPTS[self.config.prompt_mode]},
+                ],
+            },
+        ]
+
+        # Get raw response using parent's method
+        response = await self._get_chat_completion(messages)
+        logger.info("Response length: " + str(len(response)))
+        page.raw_response = response
+
+        if self.config.prompt_mode == "layout":
+            # Post-processing
+            matches, matches_image, matches_other = re_match(response)
+
+            # Extract items (bounding boxes)
+            page.items = self.extract_items(page.image, matches)
+
+            # Clean text
+            outputs = response
+
+            # Replace image references with a placeholder
+            for a_match_image in matches_image:
+                outputs = outputs.replace(a_match_image, "![image]")
+
+            # Replace other references (text grounding) and cleanup
+            for a_match_other in matches_other:
+                outputs = (
+                    outputs.replace(a_match_other, "")
+                    .replace("\\coloneqq", ":=")
+                    .replace("\\eqqcolon", "=:")
+                )
+        else:
+            outputs = response
+
+        page.text = outputs.strip()
+        logger.debug(page.text)
+
+        return page
 
 
 class DeepSeekOCRDockerServerConfig(VLLMDockerServerConfig):
@@ -32,10 +180,11 @@ class DeepSeekOCRConverterConfig(OpenAIConverterConfig):
 
     model_name: str = "deepseek-ai/DeepSeek-OCR"
     aliases: list[str] = Field(default_factory=lambda: ["deepseekocr"])
-    preprompt: str | None = None
-    postprompt: str | None = "<|grounding|>Convert the document to markdown."
+
+    prompt_mode: Literal["layout", "ocr"] = "ocr"
     completion_kwargs: dict | None = {
         "temperature": 0.0,
+        "max_tokens": 8181,
         "extra_body": {
             "skip_special_tokens": False,
             # args used to control custom logits processor
@@ -47,6 +196,8 @@ class DeepSeekOCRConverterConfig(OpenAIConverterConfig):
             },
         },
     }
-    max_image_size: int | None = 1540
     dpi: int = 200
     aliases: list[str] = Field(default_factory=lambda: ["deepseekocr"])
+
+    def get_client(self, **kwargs) -> "DeepSeekOCRConverterClient":
+        return DeepSeekOCRConverterClient(config=self, **kwargs)

vlmparse/clients/docling.py

@@ -34,7 +34,7 @@ class DoclingDockerServerConfig(DockerServerConfig):
             "LOG_LEVEL": "DEBUG",  # Enable verbose logging
             # Performance Tuning
             # "UVICORN_WORKERS": "4",  # Increase web server workers (Default: 1)
-            # "DOCLING_SERVE_ENG_LOC_NUM_WORKERS": "4",  # Increase processing workers (Default: 2)
+            "DOCLING_SERVE_ENG_LOC_NUM_WORKERS": "16",  # Increase processing workers (Default: 2)
             "DOCLING_NUM_THREADS": "32",  # Increase torch threads (Default: 4)
         }
     )
@@ -62,8 +62,8 @@ class DoclingDockerServerConfig(DockerServerConfig):
 class DoclingConverterConfig(ConverterConfig):
     """Configuration for Docling converter client."""
 
+    base_url: str
     model_name: str = "docling"
-    base_url: str = "http://localhost:5001"
     timeout: int = 300
     api_kwargs: dict = {"output_format": "markdown", "image_export_mode": "referenced"}
 

vlmparse/clients/dotsocr.py

@@ -8,6 +8,7 @@ from PIL import Image
 from pydantic import Field
 
 from vlmparse.clients.openai_converter import (
+    LLMParams,
     OpenAIConverterClient,
     OpenAIConverterConfig,
 )
@@ -28,6 +29,7 @@ class DotsOCRDockerServerConfig(DockerServerConfig):
     dockerfile_dir: str = str(DOCKERFILE_DIR / "dotsocr")
     command_args: list[str] = Field(
         default_factory=lambda: [
+            "/workspace/weights/DotsOCR",
             "--tensor-parallel-size",
             "1",
             "--gpu-memory-utilization",
@@ -44,12 +46,19 @@ class DotsOCRDockerServerConfig(DockerServerConfig):
             # "16384",
         ]
     )
-    add_model_key_to_server: bool = False
+    add_model_key_to_server: bool = True
     aliases: list[str] = Field(default_factory=lambda: ["dotsocr"])
 
     @property
     def client_config(self):
-        return DotsOCRConverterConfig(llm_params=self.llm_params)
+        return DotsOCRConverterConfig(
+            llm_params=LLMParams(
+                base_url=f"http://localhost:{self.docker_port}{self.get_base_url_suffix()}",
+            )
+        )
+
+    def get_base_url_suffix(self) -> str:
+        return "/v1"
 
 
 class DotsOCRConverterConfig(OpenAIConverterConfig):

vlmparse/clients/mineru.py

@@ -1,6 +1,5 @@
 import asyncio
 import io
-import os
 
 import orjson
 from loguru import logger
@@ -20,18 +19,21 @@ class MinerUDockerServerConfig(DockerServerConfig):
     docker_image: str = "pulsia/mineru25apipulsia:latest"
     docker_port: int = 4299
     container_port: int = 8000
+    server_ready_indicators: list[str] = Field(
+        default_factory=lambda: ["Uvicorn running"]
+    )
 
     @property
     def client_config(self):
-        return MinerUConverterConfig(api_url=f"http://localhost:{self.docker_port}")
+        return MinerUConverterConfig(base_url=f"http://localhost:{self.docker_port}")
 
 
 class MinerUConverterConfig(ConverterConfig):
     """Configuration for MinerU API converter."""
 
-    base_url: str = Field(
-        default_factory=lambda: os.getenv("MINERU_API_URL", "http://localhost:4299")
-    )
+    base_url: str
+    model_name: str = "opendatalab/MinerU2.5-2509-1.2B"
+    aliases: list[str] = Field(default_factory=lambda: ["mineru25"])
     timeout: int = 600
 
     def get_client(self, **kwargs) -> "MinerUConverter":
@@ -54,13 +56,12 @@ class MinerUConverter(BaseConverter):
         super().__init__(config=config, **kwargs)
         from httpx import AsyncClient
 
-        self.client = AsyncClient(base_url=config.api_url, timeout=config.timeout)
+        self.client = AsyncClient(base_url=config.base_url, timeout=config.timeout)
 
     async def _async_inference_with_api(self, image) -> list:
         """Run async inference with MinerU API."""
 
         img_byte_arr = await asyncio.to_thread(to_bytes_io, image)
-
         response = await self.client.post(
             "process-image",
             files={"image": ("image.png", img_byte_arr, "image/png")},

vlmparse/clients/openai_converter.py

@@ -92,6 +92,7 @@ class OpenAIConverterClient(BaseConverter):
             base_url=self.config.llm_params.base_url,
             api_key=self.config.llm_params.api_key,
             timeout=self.config.llm_params.timeout,
+            max_retries=self.config.llm_params.max_retries,
         )
 
     async def _get_chat_completion(

vlmparse/constants.py

@@ -0,0 +1,2 @@
+IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png", ".tiff", ".tif", ".bmp", ".gif", ".webp"]
+PDF_EXTENSION = ".pdf"

vlmparse/converter.py

@@ -6,10 +6,12 @@ from pathlib import Path
 from typing import Literal
 
 from loguru import logger
+from PIL import Image
 from pydantic import Field
 
 from .base_model import VLMParseBaseModel
 from .build_doc import convert_specific_page_to_image, get_page_count, resize_image
+from .constants import IMAGE_EXTENSIONS, PDF_EXTENSION
 from .data_model.document import Document, Page, ProcessingError
 
 # Add a lock to ensure PDFium is accessed by only one thread/task at a time
@@ -50,12 +52,24 @@ class BaseConverter:
         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,
+        if Path(file_path).suffix.lower() in IMAGE_EXTENSIONS:
+            image = Image.open(file_path)
+            if image.mode != "RGB":
+                image = image.convert("L").convert("RGB")
+
+        elif Path(file_path).suffix.lower() == PDF_EXTENSION:
+            with PDFIUM_LOCK:
+                image = convert_specific_page_to_image(
+                    file_path,
+                    page_idx,
+                    dpi=self.config.dpi,
+                )
+
+        else:
+            raise ValueError(
+                f"Unsupported file extension: {Path(file_path).suffix.lower()}"
             )
+
         image = resize_image(image, self.config.max_image_size)
         page.buffer_image = image
         return page

vlmparse/converter_with_server.py

@@ -42,13 +42,13 @@ class ConverterWithServer:
             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:
+                if self.port is not None:
+                    docker_config.docker_port = self.port
                 docker_config.gpu_device_ids = gpu_device_ids
-                server = docker_config.get_server(auto_stop=True)
-                server.start()
+                self.server = docker_config.get_server(auto_stop=True)
+                self.server.start()
 
                 self.client = docker_config.get_client()
             else:
@@ -56,6 +56,7 @@ class ConverterWithServer:
 
         else:
             client_config = converter_config_registry.get(self.model, uri=self.uri)
+
             self.client = client_config.get_client()
 
     def parse(

vlmparse/registries.py

@@ -108,6 +108,7 @@ for gemini_model in [
     "gemini-2.5-flash",
     "gemini-2.5-flash-lite",
     "gemini-3-pro-preview",
+    "gemini-3-flash-preview",
 ]:
     converter_config_registry.register(
         gemini_model,
@@ -120,12 +121,9 @@ for gemini_model in [
         ),
     )
 for openai_model in [
-    "gpt-5.1",
-    "gpt-5.1-mini",
-    "gpt-5.1-nano",
+    "gpt-5.2",
     "gpt-5",
     "gpt-5-mini",
-    "gpt-5-nano",
 ]:
     converter_config_registry.register(
         openai_model,

vlmparse/servers/docker_server.py

@@ -78,7 +78,7 @@ class VLLMDockerServerConfig(DockerServerConfig):
         from vlmparse.clients.openai_converter import LLMParams
 
         return LLMParams(
-            base_url=f"http://localhost:{self.docker_port}/v1",
+            base_url=f"http://localhost:{self.docker_port}{self.get_base_url_suffix()}",
             model_name=self.default_model_name,
         )
 

vlmparse/servers/utils.py

@@ -3,9 +3,8 @@ import time
 from contextlib import contextmanager
 from pathlib import Path
 
-from loguru import logger
-
 import docker
+from loguru import logger
 
 
 def _ensure_image_exists(
@@ -230,6 +229,8 @@ def get_model_from_uri(uri: str) -> str:
     for container in containers:
         c_uri = container.labels.get("vlmparse_uri")
         c_model = container.labels.get("vlmparse_model_name")
+        if c_uri is not None:
+            c_uri = c_uri.replace("localhost", "0.0.0.0")
 
         # Check if user URI matches container URI (ignoring /v1 suffix if missing)
         if c_uri and (

vlmparse/utils.py

@@ -28,12 +28,12 @@ def get_file_paths(inputs: str | list[str]):
         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))
+            file_paths.extend(glob(os.path.join(pattern, "*.*"), 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")]
+    file_paths = [f for f in file_paths if os.path.exists(f) and os.path.isfile(f)]
 
     if not file_paths:
         logger.error("No PDF files found matching the inputs patterns")

{vlmparse-0.1.3.dist-info → vlmparse-0.1.5.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: vlmparse
-Version: 0.1.3
-Requires-Python: >=3.12.0
+Version: 0.1.5
+Requires-Python: >=3.11.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: devtools>=0.12.2
@@ -72,6 +72,19 @@ Supported Converters:
 
 ## Installation
 
+Simplest solution with only the cli: 
+
+```bash
+uv tool install vlmparse
+```
+
+If you want to run the granite-docling model or use the streamlit viewing app:
+
+```bash
+uv tool install vlmparse[docling_core,st_app]
+```
+
+If you prefer cloning the repository and using the local version:
 ```bash
 uv sync
 ```
@@ -86,10 +99,11 @@ Activate the virtual environment:
 ```bash
 source .venv/bin/activate
 ```
-Other solution: append uv run to all the commands below.
 
 ## CLI Usage
 
+Note that you can bypass the previous installation step and just add uvx before each of the commands below.
+
 ### Convert PDFs
 
 With a general VLM (requires setting your api key as an environment variable):

vlmparse-0.1.5.dist-info/RECORD

@@ -0,0 +1,36 @@
+vlmparse/base_model.py,sha256=4U4UPe8SNArliKnUf8pp8zQugWYsnhg9okylt7mrW1U,381
+vlmparse/build_doc.py,sha256=LAWrnFrqamN5PwJo57AUtQOPrMFGnCGw4gBjEKZ6pYo,2127
+vlmparse/cli.py,sha256=tQma1IkOsFnqPKqqHVO1PJh18n1w82gp4ewA7oraJkE,15855
+vlmparse/constants.py,sha256=7-47S01n4MI2ebR09bpdOo3_P16d-z-NVGsm6KJP8ls,110
+vlmparse/converter.py,sha256=F0JSY9sFYUggCvaUCb27kKGJJpnZKW2FStMDVJoIOeQ,7383
+vlmparse/converter_with_server.py,sha256=G393O7vU_lJz6Vz-qYVkrjFhf0Vmpjjl8OjPKQe2blU,3928
+vlmparse/registries.py,sha256=6bEUKTkTjc8C7c1R1ZvAHSF5NCXmAuhNpw0qNnuQ7-A,5818
+vlmparse/utils.py,sha256=rcVrtPiQVj_8HAmFQOu___72uYIapp_X89yxrMNCBow,1236
+vlmparse/clients/chandra.py,sha256=zfu-A6Slh-fIAyrtrlVoCb6QHLBimnimefap_K9YwYw,9775
+vlmparse/clients/deepseekocr.py,sha256=rQvaOaPPoDiZ0MzXqfqqH9BgUBfjmlfHu3NlMjSDgiQ,6501
+vlmparse/clients/docling.py,sha256=SAkLsqseuWfkuiel8FWR1G0Z5s-SZU3dE2JbsOvF4SA,5328
+vlmparse/clients/dotsocr.py,sha256=w2T-xkhlw1AfT-CUYoF0ectr2jDYHe9239B24XKB1UQ,10139
+vlmparse/clients/granite_docling.py,sha256=EQpsv5qSJG0HtMSacmJStER2sq4TGf1EMU5_NmJsl4g,4634
+vlmparse/clients/hunyuanocr.py,sha256=Xw0Q1l-3pQzaEgFngnfM8vrSWpnT3I99QvDaGZ8XooM,1712
+vlmparse/clients/lightonocr.py,sha256=wx1Im8Z3wlRWwYbPqnSd3LqTtdAU8CnX5mzu1BuCUY8,1314
+vlmparse/clients/mineru.py,sha256=bilDPcUoLk2rcFVqMk4q2Hx2txilc3GDUbjAEoMM_BI,3671
+vlmparse/clients/nanonetocr.py,sha256=BT5vaeerCsK5agvOaHK3NvLUqWd1FfDmrMmDYbp646I,1543
+vlmparse/clients/olmocr.py,sha256=mQEDpfyLY8a80Zlps5mG0QaWytIgnNQZVEVWKWjPIjk,1849
+vlmparse/clients/openai_converter.py,sha256=j2H0iAQTADRRpu1Zy1b-1OFfWyXuqCvrQKy2UcwggTA,5696
+vlmparse/clients/paddleocrvl.py,sha256=tmaqg3boV4edywiiiNiNiI3dBHi111wz4dFb52OISXw,1376
+vlmparse/clients/prompts.py,sha256=-J60lqxgRzlkQ9VsQLxmWsIMaDt-gNqWqWoqHIw9CLc,4228
+vlmparse/clients/pipe_utils/cleaner.py,sha256=oxBkBTOkluN1lmeNbzajRIe0_D__ZGwUOBaI_Ph0uxE,2396
+vlmparse/clients/pipe_utils/html_to_md_conversion.py,sha256=cFFqzD2jCNw_968_eu3Wt--Ox7iJj2Rn5UoP_DZWosU,4112
+vlmparse/clients/pipe_utils/utils.py,sha256=935ecIO446I0pstszE_1nrIPHn1Ffrxunq7fVd0dsd8,315
+vlmparse/data_model/box.py,sha256=lJsh4qhjgYXZF5vTSJ1qMXD5GVlBi2_SBedBMlfJikU,16868
+vlmparse/data_model/document.py,sha256=pdCZvWzRFkez53ZJpNaB4ezUW-OVUlbR3_SBmmgVzGQ,4217
+vlmparse/servers/docker_server.py,sha256=qOoZcWSHrK7kK7tAL61RJSW-Jmee93It2SEfWG3jGrc,6633
+vlmparse/servers/utils.py,sha256=qy2-rnQTCQKt6CeTV5H74tvRTXyzBV2KswQiYW8Tf-k,8908
+vlmparse/st_viewer/fs_nav.py,sha256=7GNH68h2Loh5pQ64Pe72-D2cs2BLhqRXevEmKdFmPX0,1616
+vlmparse/st_viewer/st_viewer.py,sha256=m2rQTtk5rlwErNmivNAg-4rkHkvNkvLhoJZxFQi7Dwk,2105
+vlmparse-0.1.5.dist-info/licenses/LICENSE,sha256=3TKJHk8hPBR5dbLWZ3IpfCftl-_m-iyBwpYQGZYxj14,1080
+vlmparse-0.1.5.dist-info/METADATA,sha256=LN4W1cvXJvL22hwLAgeSwd3PGTmlrt6lgqNi-tL9pes,5446
+vlmparse-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vlmparse-0.1.5.dist-info/entry_points.txt,sha256=gD5berP6HwE2wNIkls-Lw5goiceA8uMgPEd7ifnFJXs,47
+vlmparse-0.1.5.dist-info/top_level.txt,sha256=k4ni-GNH_iAX7liQEsk_KY_c3xgZgt8k9fsSs9IXLXs,9
+vlmparse-0.1.5.dist-info/RECORD,,