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

vlmparse/clients/openai_converter.py

@@ -1,15 +1,13 @@
-import os
+import asyncio
 from typing import Literal, Optional
 
 from loguru import logger
 from pydantic import Field
 
-from vlmparse.base_model import VLMParseBaseModel
 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.servers.docker_server import DEFAULT_MODEL_NAME
 from vlmparse.utils import to_base64
 
 from .prompts import PDF2MD_PROMPT
@@ -17,50 +15,14 @@ from .prompts import PDF2MD_PROMPT
 GOOGLE_API_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
 
 
-class LLMParams(VLMParseBaseModel):
+class OpenAIConverterConfig(ConverterConfig):
     api_key: str = ""
-    base_url: str | None = None
-    model_name: str = DEFAULT_MODEL_NAME
     timeout: int | None = 500
     max_retries: int = 1
-
-
-def get_llm_params(model_name: str, uri: str | None = None):
-    if uri is not None:
-        return LLMParams(base_url=uri, model_name="vllm-model", api_key="")
-    if model_name in [
-        "gpt-4o",
-        "gpt-4o-mini",
-        "gpt-4.1",
-        "gpt-4.1-mini",
-        "gpt-4.1-nano",
-        "gpt-5",
-        "gpt-5-mini",
-        "gpt-5-nano",
-    ]:
-        base_url = None
-        api_key = os.getenv("OPENAI_API_KEY")
-        if api_key is None:
-            raise ValueError("OPENAI_API_KEY environment variable not set")
-    else:
-        if model_name in [
-            "gemini-2.5-flash-lite",
-            "gemini-2.5-flash",
-            "gemini-2.5-pro",
-        ]:
-            base_url = GOOGLE_API_BASE_URL
-            api_key = os.getenv("GOOGLE_API_KEY")
-            if api_key is None:
-                raise ValueError("GOOGLE_API_KEY environment variable not set")
-        else:
-            return None
-    return LLMParams(base_url=base_url, model_name=model_name, api_key=api_key)
-
-
-class OpenAIConverterConfig(ConverterConfig):
-    llm_params: LLMParams
     preprompt: str | None = None
-    postprompt: str | None = PDF2MD_PROMPT
+    postprompt: str | dict[str, str] | None = PDF2MD_PROMPT
+    prompts: dict[str, str] = Field(default_factory=dict)
+    prompt_mode_map: dict[str, str] = Field(default_factory=dict)
     completion_kwargs: dict = Field(default_factory=dict)
     stream: bool = False
 
@@ -71,6 +33,33 @@ class OpenAIConverterConfig(ConverterConfig):
 class OpenAIConverterClient(BaseConverter):
     """Client for OpenAI-compatible API servers."""
 
+    def get_prompt_key(self) -> str | None:
+        """Resolve a prompt key from conversion_mode using class mappings."""
+        mode = getattr(self.config, "conversion_mode", None) or "ocr"
+        prompts = self._get_prompts()
+        if mode in prompts:
+            return mode
+        mapped = self._get_prompt_mode_map().get(mode)
+        if mapped in prompts:
+            return mapped
+        return None
+
+    def get_prompt_for_mode(self) -> str | None:
+        key = self.get_prompt_key()
+        if key is None:
+            return None
+        return self._get_prompts().get(key)
+
+    def _get_prompts(self) -> dict[str, str]:
+        if self.config.prompts:
+            return self.config.prompts
+        if isinstance(self.config.postprompt, dict):
+            return self.config.postprompt
+        return {}
+
+    def _get_prompt_mode_map(self) -> dict[str, str]:
+        return self.config.prompt_mode_map or {}
+
     def __init__(
         self,
         config: OpenAIConverterConfig,
@@ -90,14 +79,54 @@ class OpenAIConverterClient(BaseConverter):
             debug=debug,
             return_documents_in_batch_mode=return_documents_in_batch_mode,
         )
-        from openai import AsyncOpenAI
-
-        self.model = AsyncOpenAI(
-            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,
-        )
+        self._model = None
+        self._model_loop = None
+
+    async def _get_async_model(self):
+        loop = asyncio.get_running_loop()
+        if self._model is None or self._model_loop is not loop:
+            await self._close_model()
+            from openai import AsyncOpenAI
+
+            self._model = AsyncOpenAI(
+                base_url=self.config.base_url,
+                api_key=self.config.api_key,
+                timeout=self.config.timeout,
+                max_retries=self.config.max_retries,
+            )
+            self._model_loop = loop
+        return self._model
+
+    async def _close_model(self):
+        """Close the async OpenAI client if it exists."""
+        if self._model is not None:
+            try:
+                await self._model.close()
+            except RuntimeError:
+                # Event loop may already be closed
+                pass
+            finally:
+                self._model = None
+                self._model_loop = None
+
+    async def aclose(self):
+        """Close the converter and release resources."""
+        await self._close_model()
+
+    def close(self):
+        """Synchronously close the converter if possible."""
+        if self._model is not None:
+            try:
+                loop = asyncio.get_running_loop()
+                loop.create_task(self._close_model())
+            except RuntimeError:
+                # No running loop, try to close synchronously
+                try:
+                    asyncio.run(self._close_model())
+                except RuntimeError:
+                    # Event loop already closed, force cleanup
+                    self._model = None
+                    self._model_loop = None
 
     async def _get_chat_completion(
         self, messages: list[dict], completion_kwargs: dict | None = None
@@ -106,9 +135,11 @@ class OpenAIConverterClient(BaseConverter):
         if completion_kwargs is None:
             completion_kwargs = self.config.completion_kwargs
 
+        model = await self._get_async_model()
+
         if self.config.stream:
-            response_stream = await self.model.chat.completions.create(
-                model=self.config.llm_params.model_name,
+            response_stream = await model.chat.completions.create(
+                model=self.config.default_model_name,
                 messages=messages,
                 stream=True,
                 **completion_kwargs,
@@ -120,8 +151,8 @@ class OpenAIConverterClient(BaseConverter):
 
             return "".join(response_parts), None
         else:
-            response_obj = await self.model.chat.completions.create(
-                model=self.config.llm_params.model_name,
+            response_obj = await model.chat.completions.create(
+                model=self.config.default_model_name,
                 messages=messages,
                 **completion_kwargs,
             )
@@ -147,11 +178,15 @@ class OpenAIConverterClient(BaseConverter):
         else:
             preprompt = []
 
-        postprompt = (
-            [{"type": "text", "text": self.config.postprompt}]
-            if self.config.postprompt
-            else []
-        )
+        selected_prompt = self.get_prompt_for_mode()
+        if selected_prompt is not None:
+            postprompt = [{"type": "text", "text": selected_prompt}]
+        else:
+            postprompt = (
+                [{"type": "text", "text": self.config.postprompt}]
+                if isinstance(self.config.postprompt, str) and self.config.postprompt
+                else []
+            )
 
         messages = [
             *preprompt,

vlmparse/clients/paddleocrvl.py

@@ -1,49 +1,204 @@
+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.openai_converter import OpenAIConverterConfig
-from vlmparse.servers.docker_server import VLLMDockerServerConfig
+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" / "paddleocrvl"
+)
 
 
-class PaddleOCRVLDockerServerConfig(VLLMDockerServerConfig):
-    """Configuration for PaddleOCRVL model."""
+class PaddleOCRVLDockerServerConfig(DockerComposeServerConfig):
+    """Docker Compose configuration for PaddleOCR-VL server."""
 
-    model_name: str = "PaddlePaddle/PaddleOCR-VL"
-    command_args: list[str] = Field(
-        default_factory=lambda: [
-            "--limit-mm-per-prompt",
-            '{"image": 1}',
-            "--async-scheduling",
-            "--trust-remote-code",
-            "--mm-processor-cache-gb",
-            "0",
-        ]
+    model_name: str = "PaddleOCR-VL-1.5"
+    aliases: list[str] = Field(
+        default_factory=lambda: ["paddleocrvl1.5", "paddleocr-vl-1.5"]
+    )
+    compose_file: str = str(DOCKER_PIPELINE_DIR / "compose.yaml")
+    server_service: str = "paddleocr-vl-api"
+    compose_services: list[str] = Field(
+        default_factory=lambda: ["paddleocr-vl-api", "paddleocr-vlm-server"]
+    )
+    gpu_service_names: list[str] = Field(
+        default_factory=lambda: ["paddleocr-vl-api", "paddleocr-vlm-server"]
+    )
+    docker_port: int = 8080
+    container_port: int = 8080
+    environment: dict[str, str] = Field(
+        default_factory=lambda: {
+            "VLM_BACKEND": "vllm",
+        }
     )
-    aliases: list[str] = Field(default_factory=lambda: ["paddleocrvl"])
+    environment_services: list[str] = Field(
+        default_factory=lambda: ["paddleocr-vl-api"]
+    )
+    server_ready_indicators: list[str] = Field(
+        default_factory=lambda: ["Application startup complete", "Uvicorn running"]
+    )
+
+    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 PaddleOCRVLConverterConfig(llm_params=self.llm_params)
-
-
-# Task-specific base prompts
-TASKS = {
-    "ocr": "OCR:",
-    "table": "Table Recognition:",
-    "formula": "Formula Recognition:",
-    "chart": "Chart Recognition:",
-}
-
-
-class PaddleOCRVLConverterConfig(OpenAIConverterConfig):
-    """PaddleOCRVL converter"""
-
-    model_name: str = "PaddlePaddle/PaddleOCR-VL"
-    preprompt: str | None = None
-    postprompt: str | None = TASKS["ocr"]
-    completion_kwargs: dict | None = {
-        "temperature": 0.0,
-        "max_completion_tokens": 16384,
-    }
-    dpi: int = 200
-    aliases: list[str] = Field(default_factory=lambda: ["paddleocrvl"])
-    stream: bool = True
+        return PaddleOCRVLConverterConfig(
+            **self._create_client_kwargs(f"http://localhost:{self.docker_port}")
+        )
+
+
+class PaddleOCRVLConverterConfig(ConverterConfig):
+    """Configuration for PaddleOCR-VL API client."""
+
+    model_name: str = "PaddleOCR-VL-1.5"
+    aliases: list[str] = Field(
+        default_factory=lambda: ["paddleocrvl1.5", "paddleocr-vl-1.5"]
+    )
+    timeout: int = 600
+
+    endpoint_layout_parsing: str = "/layout-parsing"
+    endpoint_restructure_pages: str = "/restructure-pages"
+
+    # Dict of PaddleOCR-VL API args.
+    # Keys should match the PaddleOCR-VL API JSON fields (camelCase), e.g.
+    # {"useLayoutDetection": true, "promptLabel": "..."}.
+    paddleocr_args: dict[str, Any] = Field(
+        default_factory=lambda: {
+            # Preserve previous default behavior (these were always sent before).
+            "prettifyMarkdown": True,
+            "showFormulaNumber": False,
+            "restructurePages": False,
+        }
+    )
+
+    # Optional args for the /restructure-pages endpoint (if/when used).
+    restructure_args: dict[str, Any] = Field(default_factory=dict)
+
+    # 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) -> "PaddleOCRVLConverter":
+        return PaddleOCRVLConverter(config=self, **kwargs)
+
+
+class PaddleOCRVLConverter(BaseConverter):
+    """PaddleOCR-VL HTTP API converter."""
+
+    config: PaddleOCRVLConverterConfig
+
+    def _build_layout_payload(self, file_content_b64: str, file_type: int | None):
+        payload: dict[str, Any] = {"file": file_content_b64}
+
+        if self.config.paddleocr_args:
+            payload.update(self.config.paddleocr_args)
+
+        if file_type is not None:
+            payload["fileType"] = file_type
+
+        if self.config.request_overrides:
+            payload.update(self.config.request_overrides)
+
+        return payload
+
+    def _build_restructure_payload(self, layout_results: list[dict]) -> dict:
+        pages = []
+        for page_result in layout_results:
+            pruned = page_result.get("prunedResult")
+            markdown = page_result.get("markdown") or {}
+            if pruned is None:
+                continue
+            pages.append(
+                {
+                    "prunedResult": pruned,
+                    "markdownImages": markdown.get("images"),
+                }
+            )
+
+        payload: dict[str, Any] = {"pages": pages}
+
+        if self.config.restructure_args:
+            payload.update(self.config.restructure_args)
+
+        return payload
+
+    async def _post_json(self, endpoint: str, payload: dict) -> dict:
+        async with httpx.AsyncClient(
+            base_url=self.config.base_url, timeout=self.config.timeout
+        ) as client:
+            response = await client.post(endpoint, json=payload)
+
+        response.raise_for_status()
+        data = response.json()
+        if data.get("errorCode", 0) != 0:
+            raise RuntimeError(data.get("errorMsg", "Unknown error"))
+        return data
+
+    def _apply_markdown(self, page: Page, markdown_text: str | None):
+        text = markdown_text or ""
+        text = clean_response(text)
+        text = html_to_md_keep_tables(text)
+        logger.debug(f"Converted markdown text: {text}...")
+        page.text = text
+
+    def _apply_items(self, page: Page, pruned_result: dict | None):
+        if not pruned_result:
+            return
+        parsing_res_list = pruned_result.get("parsing_res_list") or []
+        items: list[Item] = []
+        for block in parsing_res_list:
+            bbox = block.get("block_bbox")
+            if not bbox or len(bbox) != 4:
+                logger.warning(f"Invalid bbox in block: {block}")
+                continue
+            l, t, r, b = bbox
+            text = block.get("block_content") or ""
+            items.append(
+                Item(
+                    text=text,
+                    box=BoundingBox(l=l, t=t, r=r, b=b),
+                    category=block.get("block_label") or "",
+                )
+            )
+
+        page.items = items
+
+    async def async_call_inside_page(self, page: Page) -> Page:
+        image = page.image
+        file_content_b64 = await asyncio.to_thread(to_base64, image, "PNG")
+        payload = self._build_layout_payload(file_content_b64, 1)
+
+        data = await self._post_json(self.config.endpoint_layout_parsing, payload)
+        result = data.get("result", {})
+        layout_results = result.get("layoutParsingResults", [])
+        if layout_results:
+            first = layout_results[0]
+
+            markdown = first.get("markdown") or {}
+            self._apply_markdown(page, markdown.get("text"))
+            self._apply_items(page, first.get("prunedResult"))
+            page.raw_response = orjson.dumps(first).decode("utf-8")
+
+        return page

vlmparse/converter.py

@@ -1,7 +1,6 @@
 import asyncio
 import threading
 import time
-import traceback
 from pathlib import Path
 from typing import Literal
 
@@ -9,6 +8,8 @@ from loguru import logger
 from PIL import Image
 from pydantic import Field
 
+from vlmparse.servers.docker_server import DEFAULT_MODEL_NAME
+
 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
@@ -19,9 +20,20 @@ PDFIUM_LOCK = threading.Lock()
 
 
 class ConverterConfig(VLMParseBaseModel):
+    model_name: str
     aliases: list[str] = Field(default_factory=list)
-    dpi: int = 175
-    max_image_size: int | None = 4000
+    dpi: int = Field(default=175, ge=30, le=600)
+    max_image_size: int | None = Field(default=4000, ge=50)
+    base_url: str | None = None
+    default_model_name: str = DEFAULT_MODEL_NAME
+    conversion_mode: Literal[
+        "ocr",
+        "ocr_layout",
+        "table",
+        "image_description",
+        "formula",
+        "chart",
+    ] = "ocr"
 
     def get_client(self, **kwargs) -> "BaseConverter":
         return BaseConverter(config=self, **kwargs)
@@ -94,14 +106,22 @@ class BaseConverter:
                         page = await self.async_call_inside_page(page)
                         toc = time.perf_counter()
                         page.latency = toc - tic
-                        logger.debug(f"Time taken: {page.latency} seconds")
+                        logger.debug(
+                            "Page {page_idx} processed in {latency:.2f}s",
+                            page_idx=page_idx,
+                            latency=page.latency,
+                        )
                     except KeyboardInterrupt:
                         raise
                     except Exception:
                         if self.debug:
                             raise
                         else:
-                            logger.exception(traceback.format_exc())
+                            logger.opt(exception=True).error(
+                                "Error processing page {page_idx} of {file_path}",
+                                page_idx=page_idx,
+                                file_path=str(file_path),
+                            )
                             page.error = ProcessingError.from_class(self)
                     if not self.save_page_images:
                         page.buffer_image = dict(
@@ -122,12 +142,19 @@ class BaseConverter:
             if self.debug:
                 raise
             else:
-                logger.exception(traceback.format_exc())
+                logger.opt(exception=True).error(
+                    "Error processing document {file_path}",
+                    file_path=str(file_path),
+                )
                 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")
+        logger.debug(
+            "Document {file_path} processed in {latency:.2f}s",
+            file_path=str(file_path),
+            latency=document.latency,
+        )
         if self.save_folder is not None:
             self._save_document(document)
 
@@ -169,8 +196,16 @@ class BaseConverter:
         else:
             logger.warning(f"Unknown save_mode: {self.save_mode}, skipping save")
 
+    async def _async_call_with_cleanup(self, file_path: str | Path):
+        """Call async_call and ensure cleanup."""
+        try:
+            return await self.async_call(file_path)
+        finally:
+            if hasattr(self, "aclose"):
+                await self.aclose()
+
     def __call__(self, file_path: str | Path):
-        return asyncio.run(self.async_call(file_path))
+        return asyncio.run(self._async_call_with_cleanup(file_path))
 
     async def async_batch(self, file_paths: list[str | Path]) -> list[Document] | None:
         """Process multiple files concurrently with semaphore limit."""
@@ -184,9 +219,14 @@ class BaseConverter:
                     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
+        try:
+            documents = await asyncio.gather(*tasks)
+            if self.return_documents_in_batch_mode:
+                return documents
+        finally:
+            # Close async resources before the event loop ends
+            if hasattr(self, "aclose"):
+                await self.aclose()
 
     def batch(self, file_paths: list[str | Path]) -> list[Document] | None:
         """Synchronous wrapper for async_batch."""