vlmparse 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

vlmparse/clients/glmocr.py

@@ -0,0 +1,243 @@
+import asyncio
+import os
+from pathlib import Path
+from typing import Any
+
+import httpx
+import orjson
+from loguru import logger
+from pydantic import Field
+
+from vlmparse.clients.pipe_utils.html_to_md_conversion import html_to_md_keep_tables
+from vlmparse.clients.pipe_utils.utils import clean_response
+from vlmparse.converter import BaseConverter, ConverterConfig
+from vlmparse.data_model.document import BoundingBox, Item, Page
+from vlmparse.servers.docker_compose_server import DockerComposeServerConfig
+from vlmparse.utils import to_base64
+
+DOCKER_PIPELINE_DIR = (
+    Path(__file__).parent.parent.parent / "docker_pipelines" / "glmocr"
+)
+
+
+class GLMOCRDockerServerConfig(DockerComposeServerConfig):
+    """Docker Compose configuration for GLM-OCR server."""
+
+    model_name: str = "GLM-OCR"
+    aliases: list[str] = Field(default_factory=lambda: ["glmocr", "glm-ocr"])
+    compose_file: str = str(DOCKER_PIPELINE_DIR / "compose.yaml")
+    server_service: str = "glmocr-api"
+    compose_services: list[str] = Field(
+        default_factory=lambda: ["glmocr-api", "glmocr-vllm-server"]
+    )
+    gpu_service_names: list[str] = Field(default_factory=lambda: ["glmocr-vllm-server"])
+    docker_port: int = 5002
+    container_port: int = 5002
+    environment: dict[str, str] = Field(
+        default_factory=lambda: {
+            "VLM_BACKEND": "vllm",
+            "API_PORT": "8080",
+        }
+    )
+    environment_services: list[str] = Field(default_factory=lambda: ["glmocr-api"])
+    server_ready_indicators: list[str] = Field(
+        default_factory=lambda: ["Running on", "Application startup complete"]
+    )
+
+    def model_post_init(self, __context):
+        if not self.compose_env:
+            compose_env = {}
+            for key in [
+                "API_IMAGE_TAG_SUFFIX",
+                "VLM_IMAGE_TAG_SUFFIX",
+                "VLM_BACKEND",
+            ]:
+                value = os.getenv(key)
+                if value:
+                    compose_env[key] = value
+            if compose_env:
+                self.compose_env = compose_env
+
+    @property
+    def client_config(self):
+        return GLMOCRConverterConfig(
+            **self._create_client_kwargs(f"http://localhost:{self.docker_port}")
+        )
+
+
+class GLMOCRConverterConfig(ConverterConfig):
+    """Configuration for GLM-OCR API client."""
+
+    model_name: str = "GLM-OCR"
+    aliases: list[str] = Field(default_factory=lambda: ["glmocr", "glm-ocr"])
+    timeout: int = 600
+
+    endpoint_parse: str = "/glmocr/parse"
+
+    # GLM-OCR specific configuration
+
+    # Output format: "json", "markdown", or "both"
+    output_format: str = "both"
+
+    # Enable layout detection (PP-DocLayout)
+    enable_layout: bool = True
+
+    # GLM-OCR model parameters
+    max_tokens: int = 16384
+    temperature: float = 0.01
+    image_format: str = "JPEG"
+    min_pixels: int = 12544
+    max_pixels: int = 71372800
+
+    # Backward-compat escape hatch: if set, applied last to the payload.
+    request_overrides: dict[str, Any] = Field(default_factory=dict)
+
+    def get_client(self, **kwargs) -> "GLMOCRConverter":
+        return GLMOCRConverter(config=self, **kwargs)
+
+
+class GLMOCRConverter(BaseConverter):
+    """GLM-OCR HTTP API converter."""
+
+    config: GLMOCRConverterConfig
+
+    def _build_parse_payload(self, file_content_b64: str) -> dict:
+        """Build the request payload for the GLM-OCR parse endpoint.
+
+        Args:
+            file_content_b64: Base64 encoded image content
+
+        Returns:
+            Dictionary payload for the API request
+        """
+        # Wrap base64 in data URI format as expected by GLM-OCR
+        # Format: data:image/png;base64,<base64_data>
+        data_uri = f"data:image/png;base64,{file_content_b64}"
+
+        payload: dict[str, Any] = {
+            "images": [data_uri]  # GLM-OCR expects a list
+        }
+
+        # Apply any request overrides
+        if self.config.request_overrides:
+            payload.update(self.config.request_overrides)
+
+        return payload
+
+    async def _post_json(self, endpoint: str, payload: dict) -> dict:
+        """Make a POST request to the GLM-OCR API.
+
+        Args:
+            endpoint: API endpoint path
+            payload: Request payload
+
+        Returns:
+            Parsed JSON response
+
+        Raises:
+            RuntimeError: If the API returns an error
+        """
+        headers = {}
+
+        async with httpx.AsyncClient(
+            base_url=self.config.base_url, timeout=self.config.timeout, headers=headers
+        ) as client:
+            response = await client.post(endpoint, json=payload)
+
+        response.raise_for_status()
+        data = response.json()
+
+        # Check for error in response
+        if "error" in data:
+            raise RuntimeError(data.get("error", "Unknown error"))
+
+        return data
+
+    def _apply_markdown(self, page: Page, markdown_text: str | None):
+        """Apply markdown text to the page.
+
+        Args:
+            page: Page object to update
+            markdown_text: Markdown content from GLM-OCR
+        """
+        text = markdown_text or ""
+        text = clean_response(text)
+        text = html_to_md_keep_tables(text)
+        logger.debug(f"Converted markdown text: {text[:100]}...")
+        page.text = text
+
+    def _apply_items(self, page: Page, json_result: list[dict] | None):
+        """Apply structured items to the page from JSON result.
+
+        Args:
+            page: Page object to update
+            json_result: List of detected regions from GLM-OCR
+        """
+        if not json_result:
+            return
+
+        items: list[Item] = []
+
+        for block in json_result:
+            bbox = block.get("bbox_2d")
+            if not bbox or len(bbox) != 4:
+                # If no bbox, skip this item
+                continue
+
+            x1, y1, x2, y2 = bbox
+            text = block.get("content") or ""
+            label = block.get("label") or ""
+
+            items.append(
+                Item(
+                    text=text,
+                    box=BoundingBox(l=x1, t=y1, r=x2, b=y2),
+                    category=label,
+                )
+            )
+
+        page.items = items
+
+    async def async_call_inside_page(self, page: Page) -> Page:
+        """Process a single page through the GLM-OCR API.
+
+        Args:
+            page: Page object containing the image to process
+
+        Returns:
+            Updated Page object with OCR results
+        """
+        image = page.image
+
+        # Convert image to base64
+        file_content_b64 = await asyncio.to_thread(to_base64, image, "PNG")
+
+        # Build request payload
+        payload = self._build_parse_payload(file_content_b64)
+
+        # Call the GLM-OCR API
+        data = await self._post_json(self.config.endpoint_parse, payload)
+
+        # GLM-OCR returns results as a list (one per document)
+        # Since we send one image, we get one document result
+        result = data.get("markdown_result", None)
+
+        if result:
+            # Get markdown output if available
+            markdown_result = result
+            if markdown_result:
+                self._apply_markdown(page, markdown_result)
+
+            # Get JSON output if available and layout detection is enabled
+            json_result = data.get("json_result")
+            if json_result and isinstance(json_result, list) and len(json_result) > 0:
+                # json_result is a list of pages, take the first page
+                page_result = (
+                    json_result[0] if isinstance(json_result[0], list) else json_result
+                )
+                self._apply_items(page, page_result)
+
+            # Store raw response
+            page.raw_response = orjson.dumps(result).decode("utf-8")
+
+        return page

vlmparse/clients/granite_docling.py

@@ -28,7 +28,11 @@ class GraniteDoclingDockerServerConfig(VLLMDockerServerConfig):
 
     @property
     def client_config(self):
-        return GraniteDoclingConverterConfig(llm_params=self.llm_params)
+        return GraniteDoclingConverterConfig(
+            **self._create_client_kwargs(
+                f"http://localhost:{self.docker_port}{self.get_base_url_suffix()}"
+            )
+        )
 
 
 class GraniteDoclingConverterConfig(OpenAIConverterConfig):
@@ -70,49 +74,18 @@ class GraniteDoclingConverter(OpenAIConverterClient):
             }
         ]
 
-        doctags = await self._get_chat_completion_adaptive(
+        doctags, usage = await self._get_chat_completion(
             messages, completion_kwargs=self.config.completion_kwargs
         )
         doctags = clean_response(doctags)
 
         page.raw_response = doctags
         page.text = _doctags_to_markdown(doctags, image)
+        if usage is not None:
+            page.prompt_tokens = usage.prompt_tokens
+            page.completion_tokens = usage.completion_tokens
         return page
 
-    async def _get_chat_completion_adaptive(
-        self, messages: list[dict], completion_kwargs: dict | None
-    ) -> str:
-        """
-        vLLM enforces input+output <= model context length. If `max_tokens` is too
-        high (especially for multimodal prompts), retry with progressively smaller
-        `max_tokens`.
-        """
-        kwargs = (completion_kwargs or {}).copy()
-        max_tokens = kwargs.get("max_tokens") or kwargs.get("max_completion_tokens")
-
-        for _ in range(6):
-            try:
-                return await self._get_chat_completion(
-                    messages, completion_kwargs=kwargs
-                )
-            except Exception as e:
-                msg = str(e)
-                too_large = (
-                    "max_tokens" in msg
-                    and "maximum context length" in msg
-                    and "is too large" in msg
-                )
-                if not too_large or not isinstance(max_tokens, int):
-                    raise
-
-                max_tokens = max(256, int(max_tokens * 0.75))
-                if "max_tokens" in kwargs:
-                    kwargs["max_tokens"] = max_tokens
-                if "max_completion_tokens" in kwargs:
-                    kwargs["max_completion_tokens"] = max_tokens
-
-        return await self._get_chat_completion(messages, completion_kwargs=kwargs)
-
 
 def _doctags_to_markdown(doctags: str, image):
     try:

vlmparse/clients/hunyuanocr.py

@@ -25,7 +25,11 @@ class HunyuanOCRDockerServerConfig(VLLMDockerServerConfig):
 
     @property
     def client_config(self):
-        return HunyuanOCRConverterConfig(llm_params=self.llm_params)
+        return HunyuanOCRConverterConfig(
+            **self._create_client_kwargs(
+                f"http://localhost:{self.docker_port}{self.get_base_url_suffix()}"
+            )
+        )
 
 
 class HunyuanOCRConverterConfig(OpenAIConverterConfig):

vlmparse/clients/lightonocr.py

@@ -25,7 +25,11 @@ class LightOnOCRDockerServerConfig(VLLMDockerServerConfig):
 
     @property
     def client_config(self):
-        return LightOnOCRConverterConfig(llm_params=self.llm_params)
+        return LightOnOCRConverterConfig(
+            **self._create_client_kwargs(
+                f"http://localhost:{self.docker_port}{self.get_base_url_suffix()}"
+            )
+        )
 
 
 class LightOnOCRConverterConfig(OpenAIConverterConfig):
@@ -41,3 +45,21 @@ class LightOnOCRConverterConfig(OpenAIConverterConfig):
     }
     dpi: int = 200
     aliases: list[str] = Field(default_factory=lambda: ["lightonocr"])
+
+
+class LightonOCR21BServerConfig(LightOnOCRDockerServerConfig):
+    model_name: str = "lightonai/LightOnOCR-2-1B"
+    aliases: list[str] = Field(default_factory=lambda: ["lightonocr2"])
+
+    @property
+    def client_config(self):
+        return LightonOCR21BConverterConfig(
+            **self._create_client_kwargs(
+                f"http://localhost:{self.docker_port}{self.get_base_url_suffix()}"
+            )
+        )
+
+
+class LightonOCR21BConverterConfig(LightOnOCRConverterConfig):
+    model_name: str = "lightonai/LightOnOCR-2-1B"
+    aliases: list[str] = Field(default_factory=lambda: ["lightonocr2"])

vlmparse/clients/mineru.py

@@ -31,7 +31,6 @@ class MinerUDockerServerConfig(DockerServerConfig):
 class MinerUConverterConfig(ConverterConfig):
     """Configuration for MinerU API converter."""
 
-    base_url: str
     model_name: str = "opendatalab/MinerU2.5-2509-1.2B"
     aliases: list[str] = Field(default_factory=lambda: ["mineru25"])
     timeout: int = 600

vlmparse/clients/mistral_converter.py

@@ -0,0 +1,85 @@
+import os
+
+import httpx
+import orjson
+from loguru import logger
+from pydantic import Field
+
+from vlmparse.clients.pipe_utils.html_to_md_conversion import html_to_md_keep_tables
+from vlmparse.clients.pipe_utils.utils import clean_response
+from vlmparse.converter import BaseConverter, ConverterConfig
+from vlmparse.data_model.document import Page
+from vlmparse.utils import to_base64
+
+
+class MistralOCRConverterConfig(ConverterConfig):
+    """Configuration for Mistral OCR converter."""
+
+    base_url: str = "https://api.mistral.ai/v1"
+    model_name: str = "mistral-ocr-latest"
+    api_key: str | None = None
+    timeout: int = 300
+    aliases: list[str] = Field(
+        default_factory=lambda: ["mistral-ocr-latest", "mistral-ocr"]
+    )
+
+    def get_client(self, **kwargs) -> "MistralOCRConverter":
+        return MistralOCRConverter(config=self, **kwargs)
+
+
+class MistralOCRConverter(BaseConverter):
+    """Client for Mistral OCR API."""
+
+    config: MistralOCRConverterConfig
+
+    def __init__(self, config: MistralOCRConverterConfig, **kwargs):
+        super().__init__(config=config, **kwargs)
+        if not self.config.api_key:
+            self.config.api_key = os.getenv("MISTRAL_API_KEY")
+        if not self.config.api_key:
+            raise ValueError("MISTRAL_API_KEY environment variable not set")
+        self._base_url = self.config.base_url.rstrip("/")
+
+    async def _async_ocr(self, image) -> httpx.Response:
+        payload = {
+            "model": self.config.model_name,
+            "document": {
+                "type": "image_url",
+                "image_url": f"data:image/png;base64,{to_base64(image)}",
+            },
+        }
+        headers = {"Authorization": f"Bearer {self.config.api_key}"}
+
+        async with httpx.AsyncClient(timeout=self.config.timeout) as client:
+            response = await client.post(
+                f"{self._base_url}/ocr",
+                json=payload,
+                headers=headers,
+            )
+        response.raise_for_status()
+        return response
+
+    async def async_call_inside_page(self, page: Page) -> Page:
+        response = await self._async_ocr(page.image)
+        page.raw_response = response.text
+
+        try:
+            data = response.json()
+        except ValueError:
+            logger.warning("Mistral OCR returned non-JSON response")
+            page.text = clean_response(response.text)
+            return page
+
+        pages = data.get("pages") or []
+        if pages:
+            page_data = pages[0]
+            text = page_data.get("markdown") or page_data.get("text") or ""
+        else:
+            text = (
+                data.get("markdown") or data.get("text") or orjson.dumps(data).decode()
+            )
+
+        text = clean_response(text)
+        text = html_to_md_keep_tables(text)
+        page.text = text
+        return page

vlmparse/clients/nanonetocr.py

@@ -12,7 +12,11 @@ class NanonetOCR2DockerServerConfig(VLLMDockerServerConfig):
 
     @property
     def client_config(self):
-        return NanonetOCR2ConverterConfig(llm_params=self.llm_params)
+        return NanonetOCR2ConverterConfig(
+            **self._create_client_kwargs(
+                f"http://localhost:{self.docker_port}{self.get_base_url_suffix()}"
+            )
+        )
 
 
 class NanonetOCR2ConverterConfig(OpenAIConverterConfig):

vlmparse/clients/olmocr.py

@@ -23,7 +23,11 @@ class OlmOCRDockerServerConfig(VLLMDockerServerConfig):
 
     @property
     def client_config(self):
-        return OlmOCRConverterConfig(llm_params=self.llm_params)
+        return OlmOCRConverterConfig(
+            **self._create_client_kwargs(
+                f"http://localhost:{self.docker_port}{self.get_base_url_suffix()}"
+            )
+        )
 
 
 class OlmOCRConverterConfig(OpenAIConverterConfig):
@@ -37,7 +41,7 @@ class OlmOCRConverterConfig(OpenAIConverterConfig):
         "Return your output as markdown, with a front matter section on top specifying values for the primary_language, is_rotation_valid, rotation_correction, is_table, and is_diagram parameters."
     )
     postprompt: str | None = None
-    completion_kwargs: dict | None = {
+    completion_kwargs: dict = {
         "temperature": 0.1,
         "max_tokens": 8000,
     }