vlmparse 0.1.3__tar.gz → 0.1.4__tar.gz

{vlmparse-0.1.3/vlmparse.egg-info → vlmparse-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vlmparse
-Version: 0.1.3
+Version: 0.1.4
 Requires-Python: >=3.12.0
 Description-Content-Type: text/markdown
 License-File: LICENSE

{vlmparse-0.1.3 → vlmparse-0.1.4}/pyproject.toml

@@ -8,7 +8,7 @@ version = "0.1.0"
 
 [project]
 name = "vlmparse"
-version = "0.1.3"
+version = "0.1.4"
 authors = []
 description = ""
 readme = "README.md"

{vlmparse-0.1.3 → vlmparse-0.1.4}/tests/test_all_converters_mocked.py

@@ -106,6 +106,31 @@ class TestConverterConfigs:
         # Verify API was called
         assert mock_openai_client.chat.completions.create.call_count == 2
 
+    def test_converter_image_processing(self, datadir, mock_openai_client):
+        """Test processing of a single image file."""
+        model_name = "gemini-2.5-flash-lite"
+        image_path = datadir / "page_with_formula.png"
+
+        config = converter_config_registry.get(model_name)
+        converter = config.get_client()
+
+        # Process image
+        document = converter(image_path)
+
+        # Verify document structure
+        assert isinstance(document, Document)
+        assert document.file_path == str(image_path)
+        assert len(document.pages) == 1, f"Expected 1 page, got {len(document.pages)}"
+
+        # Verify page
+        page = document.pages[0]
+        assert isinstance(page, Page)
+        assert page.text is not None
+        assert len(page.text) > 0
+
+        # Verify API was called once
+        assert mock_openai_client.chat.completions.create.call_count == 1
+
     def test_dotsocr_ocr_mode(self, file_path, dotsocr_mock_client):
         """Test DotsOCR converter in OCR mode."""
         config = converter_config_registry.get("dotsocr")

{vlmparse-0.1.3 → vlmparse-0.1.4}/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-0.1.4/vlmparse/clients/deepseekocr.py

@@ -0,0 +1,203 @@
+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 (
+    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):
+    """Configuration for DeepSeekOCR model."""
+
+    model_name: str = "deepseek-ai/DeepSeek-OCR"
+    command_args: list[str] = Field(
+        default_factory=lambda: [
+            "--limit-mm-per-prompt",
+            '{"image": 1}',
+            "--async-scheduling",
+            "--logits_processors",
+            "vllm.model_executor.models.deepseek_ocr:NGramPerReqLogitsProcessor",
+            "--no-enable-prefix-caching",
+            "--mm-processor-cache-gb",
+            "0",
+        ]
+    )
+    aliases: list[str] = Field(default_factory=lambda: ["deepseekocr"])
+
+    @property
+    def client_config(self):
+        return DeepSeekOCRConverterConfig(llm_params=self.llm_params)
+
+
+class DeepSeekOCRConverterConfig(OpenAIConverterConfig):
+    """DeepSeekOCR converter - backward compatibility alias."""
+
+    model_name: str = "deepseek-ai/DeepSeek-OCR"
+    aliases: list[str] = Field(default_factory=lambda: ["deepseekocr"])
+
+    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
+            "vllm_xargs": {
+                "ngram_size": 30,
+                "window_size": 90,
+                # whitelist: <td>, </td>
+                "whitelist_token_ids": [128821, 128822],
+            },
+        },
+    }
+    dpi: int = 200
+    aliases: list[str] = Field(default_factory=lambda: ["deepseekocr"])
+
+    def get_client(self, **kwargs) -> "DeepSeekOCRConverterClient":
+        return DeepSeekOCRConverterClient(config=self, **kwargs)

vlmparse-0.1.4/vlmparse/constants.py

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

{vlmparse-0.1.3 → vlmparse-0.1.4}/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-0.1.3 → vlmparse-0.1.4}/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 → vlmparse-0.1.4/vlmparse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vlmparse
-Version: 0.1.3
+Version: 0.1.4
 Requires-Python: >=3.12.0
 Description-Content-Type: text/markdown
 License-File: LICENSE

{vlmparse-0.1.3 → vlmparse-0.1.4}/vlmparse.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ tests/test_table_tests.py
 vlmparse/base_model.py
 vlmparse/build_doc.py
 vlmparse/cli.py
+vlmparse/constants.py
 vlmparse/converter.py
 vlmparse/converter_with_server.py
 vlmparse/registries.py

vlmparse-0.1.3/vlmparse/clients/deepseekocr.py

@@ -1,52 +0,0 @@
-from pydantic import Field
-
-from vlmparse.clients.openai_converter import OpenAIConverterConfig
-from vlmparse.servers.docker_server import VLLMDockerServerConfig
-
-
-class DeepSeekOCRDockerServerConfig(VLLMDockerServerConfig):
-    """Configuration for DeepSeekOCR model."""
-
-    model_name: str = "deepseek-ai/DeepSeek-OCR"
-    command_args: list[str] = Field(
-        default_factory=lambda: [
-            "--limit-mm-per-prompt",
-            '{"image": 1}',
-            "--async-scheduling",
-            "--logits_processors",
-            "vllm.model_executor.models.deepseek_ocr:NGramPerReqLogitsProcessor",
-            "--no-enable-prefix-caching",
-            "--mm-processor-cache-gb",
-            "0",
-        ]
-    )
-    aliases: list[str] = Field(default_factory=lambda: ["deepseekocr"])
-
-    @property
-    def client_config(self):
-        return DeepSeekOCRConverterConfig(llm_params=self.llm_params)
-
-
-class DeepSeekOCRConverterConfig(OpenAIConverterConfig):
-    """DeepSeekOCR converter - backward compatibility alias."""
-
-    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."
-    completion_kwargs: dict | None = {
-        "temperature": 0.0,
-        "extra_body": {
-            "skip_special_tokens": False,
-            # args used to control custom logits processor
-            "vllm_xargs": {
-                "ngram_size": 30,
-                "window_size": 90,
-                # whitelist: <td>, </td>
-                "whitelist_token_ids": [128821, 128822],
-            },
-        },
-    }
-    max_image_size: int | None = 1540
-    dpi: int = 200
-    aliases: list[str] = Field(default_factory=lambda: ["deepseekocr"])