vlmparse 0.1.8__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,7 +82,7 @@ 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,
@@ -83,7 +98,7 @@ class ConverterWithServer:
         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
@@ -91,18 +106,31 @@ class ConverterWithServer:
         self.server = None
         self.client = None
 
-        if self.uri is not None:
+        if self.uri is not None and self.model is None:
             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,
@@ -113,10 +141,19 @@ class ConverterWithServer:
                     return_documents_in_batch_mode=self.return_documents
                 )
             else:
+                # 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)
 

vlmparse/registries.py

@@ -2,9 +2,13 @@ import os
 from collections.abc import Callable
 
 from vlmparse.clients.chandra import ChandraDockerServerConfig
-from vlmparse.clients.deepseekocr import DeepSeekOCRDockerServerConfig
+from vlmparse.clients.deepseekocr import (
+    DeepSeekOCR2DockerServerConfig,
+    DeepSeekOCRDockerServerConfig,
+)
 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 (
@@ -18,7 +22,9 @@ 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_server import DockerServerConfig, docker_config_registry
+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):
@@ -31,17 +37,19 @@ def get_default(cls, field_name):
 
 
 # All server configs - single source of truth
-SERVER_CONFIGS: list[type[DockerServerConfig]] = [
+SERVER_CONFIGS: list[type[DockerServerConfig | DockerComposeServerConfig]] = [
     ChandraDockerServerConfig,
     LightOnOCRDockerServerConfig,
     DotsOCRDockerServerConfig,
     PaddleOCRVLDockerServerConfig,
+    GLMOCRDockerServerConfig,
     NanonetOCR2DockerServerConfig,
     HunyuanOCRDockerServerConfig,
     DoclingDockerServerConfig,
     OlmOCRDockerServerConfig,
     MinerUDockerServerConfig,
     DeepSeekOCRDockerServerConfig,
+    DeepSeekOCR2DockerServerConfig,
     GraniteDoclingDockerServerConfig,
     LightonOCR21BServerConfig,
 ]
@@ -78,7 +86,7 @@ class ConverterConfigRegistry:
 
     def register_from_server(
         self,
-        server_config_cls: type[DockerServerConfig],
+        server_config_cls: type[DockerServerConfig | DockerComposeServerConfig],
     ):
         """Register converter config derived from a server config class.
 
@@ -104,17 +112,19 @@ class ConverterConfigRegistry:
             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). Returns default if not registered."""
+    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)
-        # Fallback to OpenAIConverterConfig for unregistered models
-        if uri is not None:
-            return OpenAIConverterConfig(base_url=uri)
-        return OpenAIConverterConfig(model_name=model_name)
+
+        raise ValueError(f"Model '{model_name}' not found in registry.")
 
     def list_models(self) -> list[str]:
         """List all registered model names (thread-safe)."""

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