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

vlmparse/converter_with_server.py

@@ -14,25 +14,39 @@ def start_server(
     model: str,
     gpus: str,
     port: None | int = None,
-    with_vllm_server: bool = True,
+    server: Literal["registry", "hf"] = "registry",
     vllm_args: list[str] = {},
     forget_predefined_vllm_args: bool = False,
     auto_stop: bool = False,
 ):
     from vlmparse.registries import docker_config_registry
+    from vlmparse.servers.docker_server import (
+        DEFAULT_MODEL_NAME,
+        VLLMDockerServerConfig,
+    )
 
     base_url = ""
     container = None
-    docker_config = docker_config_registry.get(model, default=with_vllm_server)
+    docker_config = docker_config_registry.get(model)
 
     if port is None:
         port = DEFAULT_SERVER_PORT
 
     if docker_config is None:
-        logger.warning(
-            f"No Docker configuration found for model: {model}, using default configuration"
-        )
-        return "", container, None, docker_config
+        if server == "registry":
+            print(f"DEBUG: Registry lookup failed for {model} (strict mode)")
+            raise ValueError(
+                f"Model '{model}' not found in registry and server='registry'. Use server='hf' to serve arbitrary HuggingFace models."
+            )
+        elif server == "hf":
+            docker_config = VLLMDockerServerConfig(
+                model_name=model, default_model_name=DEFAULT_MODEL_NAME
+            )
+        else:
+            logger.warning(
+                f"No Docker configuration found for model: {model} and server type is undetermined."
+            )
+            return "", container, None, docker_config
 
     gpu_device_ids = None
     if gpus is not None:
@@ -42,13 +56,14 @@ def start_server(
         if port is not None:
             docker_config.docker_port = port
         docker_config.gpu_device_ids = gpu_device_ids
-        docker_config.update_command_args(
-            vllm_args,
-            forget_predefined_vllm_args=forget_predefined_vllm_args,
-        )
+        if hasattr(docker_config, "update_command_args"):
+            docker_config.update_command_args(
+                vllm_args,
+                forget_predefined_vllm_args=forget_predefined_vllm_args,
+            )
 
         logger.info(
-            f"Deploying VLLM server for {docker_config.model_name} on port {port}..."
+            f"Deploying server for {docker_config.model_name} on port {port}..."
         )
         server = docker_config.get_server(auto_stop=auto_stop)
         if server is None:
@@ -67,19 +82,27 @@ class ConverterWithServer:
         uri: str | None = None,
         gpus: str | None = None,
         port: int | None = None,
-        with_vllm_server: bool = False,
+        server: Literal["registry", "hf", "google", "openai"] = "registry",
         concurrency: int = 10,
         vllm_args: dict | None = None,
         forget_predefined_vllm_args: bool = False,
+        return_documents: bool = False,
     ):
+        if model is None and uri is None:
+            raise ValueError("Either 'model' or 'uri' must be provided")
+
+        if concurrency < 1:
+            raise ValueError("concurrency must be at least 1")
+
         self.model = model
         self.uri = uri
         self.port = port
         self.gpus = gpus
-        self.with_vllm_server = with_vllm_server
+        self.server_type = server
         self.concurrency = concurrency
         self.vllm_args = vllm_args
         self.forget_predefined_vllm_args = forget_predefined_vllm_args
+        self.return_documents = return_documents
         self.server = None
         self.client = None
 
@@ -87,28 +110,56 @@ class ConverterWithServer:
             self.model = get_model_from_uri(self.uri)
 
     def start_server_and_client(self):
-        from vlmparse.registries import converter_config_registry
+        from vlmparse.clients.openai_converter import OpenAIConverterConfig
+        from vlmparse.registries import (
+            converter_config_registry,
+            docker_config_registry,
+        )
 
+        start_local_server = False
         if self.uri is None:
+            if self.server_type == "hf":
+                start_local_server = True
+            elif self.server_type == "registry":
+                if self.model in docker_config_registry.list_models():
+                    start_local_server = True
+
+        if start_local_server:
+            server_arg = "hf" if self.server_type == "hf" else "registry"
             _, _, self.server, docker_config = start_server(
                 model=self.model,
                 gpus=self.gpus,
                 port=self.port,
-                with_vllm_server=self.with_vllm_server,
+                server=server_arg,
                 vllm_args=self.vllm_args,
                 forget_predefined_vllm_args=self.forget_predefined_vllm_args,
                 auto_stop=True,
             )
 
             if docker_config is not None:
-                self.client = docker_config.get_client()
+                self.client = docker_config.get_client(
+                    return_documents_in_batch_mode=self.return_documents
+                )
             else:
-                self.client = converter_config_registry.get(self.model).get_client()
+                # Should not happen if start_server works as expected
+                self.client = converter_config_registry.get(self.model).get_client(
+                    return_documents_in_batch_mode=self.return_documents
+                )
+
+        elif self.server_type == "hf":
+            client_config = OpenAIConverterConfig(
+                model_name=self.model, base_url=self.uri
+            )
+            self.client = client_config.get_client(
+                return_documents_in_batch_mode=self.return_documents
+            )
 
         else:
             client_config = converter_config_registry.get(self.model, uri=self.uri)
 
-            self.client = client_config.get_client()
+            self.client = client_config.get_client(
+                return_documents_in_batch_mode=self.return_documents
+            )
 
     def stop_server(self):
         if self.server is not None and self.server.auto_stop:
@@ -119,16 +170,30 @@ class ConverterWithServer:
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
-        self.stop_server()
+        try:
+            self.stop_server()
+        except Exception as e:
+            logger.warning(f"Error stopping server during cleanup: {e}")
+        return False  # Don't suppress exceptions
 
     def parse(
         self,
         inputs: str | list[str],
         out_folder: str = ".",
         mode: Literal["document", "md", "md_page"] = "document",
+        conversion_mode: Literal[
+            "ocr",
+            "ocr_layout",
+            "table",
+            "image_description",
+            "formula",
+            "chart",
+        ]
+        | None = None,
         dpi: int | None = None,
         debug: bool = False,
         retrylast: bool = False,
+        completion_kwargs: dict | None = None,
     ):
         assert (
             self.client is not None
@@ -165,6 +230,14 @@ class ConverterWithServer:
         if dpi is not None:
             self.client.config.dpi = int(dpi)
 
+        if conversion_mode is not None:
+            self.client.config.conversion_mode = conversion_mode
+
+        if completion_kwargs is not None and hasattr(
+            self.client.config, "completion_kwargs"
+        ):
+            self.client.config.completion_kwargs |= completion_kwargs
+
         if debug:
             self.client.debug = debug
 

vlmparse/registries.py

@@ -1,37 +1,30 @@
 import os
 from collections.abc import Callable
 
-from vlmparse.clients.chandra import ChandraConverterConfig, ChandraDockerServerConfig
+from vlmparse.clients.chandra import ChandraDockerServerConfig
 from vlmparse.clients.deepseekocr import (
-    DeepSeekOCRConverterConfig,
+    DeepSeekOCR2DockerServerConfig,
     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.docling import DoclingDockerServerConfig
+from vlmparse.clients.dotsocr import DotsOCRDockerServerConfig
+from vlmparse.clients.glmocr import GLMOCRDockerServerConfig
+from vlmparse.clients.granite_docling import GraniteDoclingDockerServerConfig
+from vlmparse.clients.hunyuanocr import HunyuanOCRDockerServerConfig
 from vlmparse.clients.lightonocr import (
-    LightOnOCRConverterConfig,
+    LightonOCR21BServerConfig,
     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
+from vlmparse.clients.mineru import MinerUDockerServerConfig
+from vlmparse.clients.mistral_converter import MistralOCRConverterConfig
+from vlmparse.clients.nanonetocr import NanonetOCR2DockerServerConfig
+from vlmparse.clients.olmocr import OlmOCRDockerServerConfig
+from vlmparse.clients.openai_converter import OpenAIConverterConfig
+from vlmparse.clients.paddleocrvl import PaddleOCRVLDockerServerConfig
+from vlmparse.converter import ConverterConfig
+from vlmparse.servers.docker_compose_server import DockerComposeServerConfig
+from vlmparse.servers.docker_server import DockerServerConfig
+from vlmparse.servers.server_registry import docker_config_registry
 
 
 def get_default(cls, field_name):
@@ -43,19 +36,26 @@ def get_default(cls, field_name):
     return field_info.default
 
 
-for server_config_cls in [
+# All server configs - single source of truth
+SERVER_CONFIGS: list[type[DockerServerConfig | DockerComposeServerConfig]] = [
     ChandraDockerServerConfig,
     LightOnOCRDockerServerConfig,
     DotsOCRDockerServerConfig,
     PaddleOCRVLDockerServerConfig,
+    GLMOCRDockerServerConfig,
     NanonetOCR2DockerServerConfig,
     HunyuanOCRDockerServerConfig,
     DoclingDockerServerConfig,
     OlmOCRDockerServerConfig,
     MinerUDockerServerConfig,
     DeepSeekOCRDockerServerConfig,
+    DeepSeekOCR2DockerServerConfig,
     GraniteDoclingDockerServerConfig,
-]:
+    LightonOCR21BServerConfig,
+]
+
+# Register docker server configs
+for server_config_cls in SERVER_CONFIGS:
     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)]
@@ -64,37 +64,83 @@ for server_config_cls in [
 
 
 class ConverterConfigRegistry:
-    """Registry for mapping model names to their Docker configurations."""
+    """Registry for mapping model names to their converter configurations.
+
+    Thread-safe registry that maps model names to their converter configuration factories.
+    """
 
     def __init__(self):
-        self._registry = dict()
+        import threading
+
+        self._registry: dict[str, Callable[[str | None], ConverterConfig]] = {}
+        self._lock = threading.RLock()
 
     def register(
         self,
         model_name: str,
-        config_factory: Callable[[str], OpenAIConverterConfig | None],
+        config_factory: Callable[[str | None], ConverterConfig],
     ):
-        """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:
-        """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))
+        """Register a config factory for a model name (thread-safe)."""
+        with self._lock:
+            self._registry[model_name] = config_factory
+
+    def register_from_server(
+        self,
+        server_config_cls: type[DockerServerConfig | DockerComposeServerConfig],
+    ):
+        """Register converter config derived from a server config class.
+
+        This ensures model_name and default_model_name are consistently
+        passed from server to client config via _create_client_kwargs.
+        """
+        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)]
+        # Also register short name (after last /)
+        if model_name and "/" in model_name:
+            names.append(model_name.split("/")[-1])
+
+        def factory(uri: str | None, cls=server_config_cls) -> ConverterConfig:
+            server = cls()
+            client_config = server.client_config
+            # Override base_url if provided
+            if uri is not None:
+                client_config = client_config.model_copy(update={"base_url": uri})
+            return client_config
+
+        with self._lock:
+            for name in names:
+                self._registry[name] = factory
+
+    def get(
+        self,
+        model_name: str,
+        uri: str | None = None,
+    ) -> ConverterConfig:
+        """Get config for a model name (thread-safe). Raises ValueError if not registered."""
+        with self._lock:
+            factory = self._registry.get(model_name)
+
+        if factory is not None:
+            return factory(uri)
+
+        raise ValueError(f"Model '{model_name}' not found in registry.")
 
     def list_models(self) -> list[str]:
-        """List all registered model names."""
-        return list(self._registry.keys())
+        """List all registered model names (thread-safe)."""
+        with self._lock:
+            return list(self._registry.keys())
 
 
 # Global registry instance
 converter_config_registry = ConverterConfigRegistry()
+
+# Register all server-backed converters through the server config
+# This ensures model_name and default_model_name are consistently passed
+for server_config_cls in SERVER_CONFIGS:
+    converter_config_registry.register_from_server(server_config_cls)
+
+# External API configs (no server config - these are cloud APIs)
 GOOGLE_API_BASE_URL = (
     os.getenv("GOOGLE_API_BASE_URL")
     or "https://generativelanguage.googleapis.com/v1beta/openai/"
@@ -111,11 +157,10 @@ for gemini_model in [
     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"),
-            )
+            model_name=model,
+            base_url=GOOGLE_API_BASE_URL if uri is None else uri,
+            api_key=os.getenv("GOOGLE_API_KEY"),
+            default_model_name=model,
         ),
     )
 for openai_model in [
@@ -126,45 +171,18 @@ for openai_model in [
     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"),
-            )
+            model_name=model,
+            base_url=None,
+            api_key=os.getenv("OPENAI_API_KEY"),
+            default_model_name=model,
         ),
     )
 
-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),
-        )
+for mistral_model in ["mistral-ocr-latest", "mistral-ocr"]:
+    converter_config_registry.register(
+        mistral_model,
+        lambda uri=None, model=mistral_model: MistralOCRConverterConfig(
+            base_url="https://api.mistral.ai/v1" if uri is None else uri,
+            api_key=os.getenv("MISTRAL_API_KEY"),
+        ),
+    )

vlmparse/servers/base_server.py

@@ -0,0 +1,127 @@
+"""Base classes for server configurations and server lifecycle management."""
+
+from abc import ABC, abstractmethod
+
+from loguru import logger
+from pydantic import Field
+
+from .model_identity import ModelIdentityMixin
+
+
+class BaseServerConfig(ModelIdentityMixin, ABC):
+    """Base configuration for deploying a server.
+
+    Inherits from ModelIdentityMixin which provides:
+    - model_name: str
+    - default_model_name: str | None
+    - aliases: list[str]
+    - _create_client_kwargs(base_url): Helper for creating client configs
+    - get_all_names(): All names this model can be referenced by
+
+    All server configs should inherit from this base class.
+    """
+
+    docker_port: int = 8056
+    container_port: int = 8000
+    gpu_device_ids: list[str] | None = None
+    environment: dict[str, str] = Field(default_factory=dict)
+    server_ready_indicators: list[str] = Field(
+        default_factory=lambda: [
+            "Application startup complete",
+            "Uvicorn running",
+            "Starting vLLM API server",
+        ]
+    )
+
+    class Config:
+        extra = "allow"
+
+    @property
+    @abstractmethod
+    def client_config(self):
+        """Override in subclasses to return appropriate client config."""
+        raise NotImplementedError
+
+    def get_client(self, **kwargs):
+        """Get a client instance configured for this server."""
+        return self.client_config.get_client(**kwargs)
+
+    @abstractmethod
+    def get_server(self, auto_stop: bool = True):
+        """Get a server instance for this configuration."""
+        raise NotImplementedError
+
+    def get_environment(self) -> dict | None:
+        """Setup environment variables. Override in subclasses for specific logic."""
+        return self.environment if self.environment else None
+
+    def get_base_url_suffix(self) -> str:
+        """Return URL suffix (e.g., '/v1' for OpenAI-compatible APIs). Override in subclasses."""
+        return ""
+
+    def update_command_args(
+        self,
+        vllm_args: dict | None = None,
+        forget_predefined_vllm_args: bool = False,
+    ) -> list[str]:
+        """Update command arguments. Override in subclasses that support this."""
+        _ = vllm_args, forget_predefined_vllm_args
+        return []
+
+
+class BaseServer(ABC):
+    """Base class for managing server lifecycle with start/stop methods.
+
+    All server implementations should inherit from this class.
+    """
+
+    def __init__(self, config: BaseServerConfig, auto_stop: bool = True):
+        self.config = config
+        self.auto_stop = auto_stop
+        self._server_context = None
+        self._container = None
+        self.base_url = None
+
+    @abstractmethod
+    def _create_server_context(self):
+        """Create the appropriate server context. Override in subclasses."""
+        raise NotImplementedError
+
+    def start(self):
+        """Start the server."""
+        if self._server_context is not None:
+            logger.warning("Server already started")
+            return self.base_url, self._container
+
+        self._server_context = self._create_server_context()
+        self.base_url, self._container = self._server_context.__enter__()
+        logger.info(f"Server started at {self.base_url}")
+        if self._container is not None:
+            logger.info(f"Container ID: {self._container.id}")
+            logger.info(f"Container name: {self._container.name}")
+        return self.base_url, self._container
+
+    def stop(self):
+        """Stop the server."""
+        if self._server_context is not None:
+            try:
+                self._server_context.__exit__(None, None, None)
+            except Exception as e:
+                logger.warning(f"Error during server cleanup: {e}")
+            finally:
+                self._server_context = None
+                self._container = None
+                self.base_url = None
+            logger.info("Server stopped")
+
+    def __del__(self):
+        """Automatically stop server when object is destroyed if auto_stop is True.
+
+        Note: This is a fallback mechanism. Prefer using the context manager
+        or explicitly calling stop() for reliable cleanup.
+        """
+        try:
+            if self.auto_stop and self._server_context is not None:
+                self.stop()
+        except Exception:
+            pass  # Suppress errors during garbage collection