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

vlmparse/converter_with_server.py

@@ -71,7 +71,14 @@ class ConverterWithServer:
         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
@@ -80,10 +87,11 @@ class ConverterWithServer:
         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
 
-        if self.uri is not None and self.model is None:
+        if self.uri is not None:
             self.model = get_model_from_uri(self.uri)
 
     def start_server_and_client(self):
@@ -101,14 +109,20 @@ class ConverterWithServer:
             )
 
             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()
+                self.client = converter_config_registry.get(self.model).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 +133,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 +193,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,24 @@
 import os
 from collections.abc import Callable
 
-from vlmparse.clients.chandra import ChandraConverterConfig, ChandraDockerServerConfig
-from vlmparse.clients.deepseekocr import (
-    DeepSeekOCRConverterConfig,
-    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.chandra import ChandraDockerServerConfig
+from vlmparse.clients.deepseekocr import DeepSeekOCRDockerServerConfig
+from vlmparse.clients.docling import DoclingDockerServerConfig
+from vlmparse.clients.dotsocr import DotsOCRDockerServerConfig
+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_server import DockerServerConfig, docker_config_registry
 
 
 def get_default(cls, field_name):
@@ -43,7 +30,8 @@ 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]] = [
     ChandraDockerServerConfig,
     LightOnOCRDockerServerConfig,
     DotsOCRDockerServerConfig,
@@ -55,7 +43,11 @@ for server_config_cls in [
     MinerUDockerServerConfig,
     DeepSeekOCRDockerServerConfig,
     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 +56,81 @@ 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
+        """Register a config factory for a model name (thread-safe)."""
+        with self._lock:
+            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)
+    def register_from_server(
+        self,
+        server_config_cls: type[DockerServerConfig],
+    ):
+        """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). Returns default 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(
-                llm_params=LLMParams(base_url=uri, model_name=model_name)
-            )
-        return OpenAIConverterConfig(llm_params=LLMParams(model_name=model_name))
+            return OpenAIConverterConfig(base_url=uri)
+        return OpenAIConverterConfig(model_name=model_name)
 
     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 +147,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 +161,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/docker_server.py

@@ -2,15 +2,23 @@ import os
 from typing import Callable
 
 from loguru import logger
-from pydantic import BaseModel, Field
+from pydantic import Field
 
+from .model_identity import ModelIdentityMixin
 from .utils import docker_server
 
 
-class DockerServerConfig(BaseModel):
-    """Base configuration for deploying a Docker server."""
+class DockerServerConfig(ModelIdentityMixin):
+    """Base configuration for deploying a Docker 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
+    """
 
-    model_name: str
     docker_image: str
     dockerfile_dir: str | None = None
     command_args: list[str] = Field(default_factory=list)
@@ -27,7 +35,6 @@ class DockerServerConfig(BaseModel):
     environment: dict[str, str] = Field(default_factory=dict)
     volumes: dict[str, dict] | None = None
     entrypoint: str | None = None
-    aliases: list[str] = Field(default_factory=list)
 
     class Config:
         extra = "allow"
@@ -84,22 +91,16 @@ class VLLMDockerServerConfig(DockerServerConfig):
     hf_home_folder: str | None = os.getenv("HF_HOME", None)
     add_model_key_to_server: bool = False
     container_port: int = 8000
-    aliases: list[str] = Field(default_factory=list)
-
-    @property
-    def llm_params(self):
-        from vlmparse.clients.openai_converter import LLMParams
-
-        return LLMParams(
-            base_url=f"http://localhost:{self.docker_port}{self.get_base_url_suffix()}",
-            model_name=self.default_model_name,
-        )
 
     @property
     def client_config(self):
         from vlmparse.clients.openai_converter import OpenAIConverterConfig
 
-        return OpenAIConverterConfig(llm_params=self.llm_params)
+        return OpenAIConverterConfig(
+            **self._create_client_kwargs(
+                f"http://localhost:{self.docker_port}{self.get_base_url_suffix()}"
+            )
+        )
 
     def get_command(self) -> list[str]:
         """Build VLLM-specific command."""
@@ -171,41 +172,64 @@ class ConverterServer:
     def stop(self):
         """Stop the Docker server."""
         if self._server_context is not None:
-            self._server_context.__exit__(None, None, None)
-            self._server_context = None
-            self._container = None
-            self.base_url = 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."""
-        if self.auto_stop and self._server_context is not None:
-            self.stop()
+        """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
 
 
 class DockerConfigRegistry:
-    """Registry for mapping model names to their Docker configurations."""
+    """Registry for mapping model names to their Docker configurations.
+
+    Thread-safe registry that maps model names to their Docker configuration factories.
+    """
 
     def __init__(self):
-        self._registry = dict()
+        import threading
+
+        self._registry: dict[str, Callable[[], DockerServerConfig | None]] = {}
+        self._lock = threading.RLock()
 
     def register(
         self, model_name: str, config_factory: Callable[[], DockerServerConfig | None]
     ):
-        """Register a config factory for a model name."""
-        self._registry[model_name] = config_factory
+        """Register a config factory for a model name (thread-safe)."""
+        with self._lock:
+            self._registry[model_name] = config_factory
 
     def get(self, model_name: str, default=False) -> DockerServerConfig | None:
-        """Get config for a model name. Returns default if not registered."""
-        if model_name not in self._registry:
-            if default:
-                return VLLMDockerServerConfig(model_name=model_name)
-            return None
-        return self._registry[model_name]()
+        """Get config for a model name (thread-safe). Returns default if not registered."""
+        with self._lock:
+            if model_name not in self._registry:
+                if default:
+                    return VLLMDockerServerConfig(
+                        model_name=model_name, default_model_name=DEFAULT_MODEL_NAME
+                    )
+                return None
+            factory = self._registry[model_name]
+        return factory()
 
     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

vlmparse/servers/model_identity.py

@@ -0,0 +1,48 @@
+"""Model identity mixin for consistent model name handling between server and client configs."""
+
+from pydantic import BaseModel, Field
+
+
+class ModelIdentityMixin(BaseModel):
+    """Mixin providing model identity fields with validation.
+
+    This mixin ensures that model_name and default_model_name are consistently
+    passed from server configs to client configs.
+    """
+
+    model_name: str
+    default_model_name: str | None = None
+    aliases: list[str] = Field(default_factory=list)
+
+    def get_effective_model_name(self) -> str:
+        """Returns the model name to use for API calls."""
+        return self.default_model_name if self.default_model_name else self.model_name
+
+    def _create_client_kwargs(self, base_url: str) -> dict:
+        """Generate kwargs for client config with model identity.
+
+        Use this method in server configs to ensure consistent passing
+        of model_name and default_model_name to client configs.
+
+        Args:
+            base_url: The base URL for the client to connect to.
+
+        Returns:
+            Dictionary with base_url, model_name, and default_model_name.
+        """
+        return {
+            "base_url": base_url,
+            "model_name": self.model_name,
+            "default_model_name": self.get_effective_model_name(),
+        }
+
+    def get_all_names(self) -> list[str]:
+        """Get all names this model can be referenced by.
+
+        Returns:
+            List containing model_name, aliases, and short name (after last /).
+        """
+        names = [self.model_name] + self.aliases
+        if "/" in self.model_name:
+            names.append(self.model_name.split("/")[-1])
+        return [n for n in names if isinstance(n, str)]

vlmparse/utils.py

@@ -19,8 +19,19 @@ def from_base64(base64_str: str):
     return Image.open(BytesIO(image_data))
 
 
-def get_file_paths(inputs: str | list[str]):
-    # Expand file paths from glob patterns
+def get_file_paths(inputs: str | list[str], raise_on_empty: bool = False) -> list[str]:
+    """Expand file paths from glob patterns.
+
+    Args:
+        inputs: A string or list of strings containing file paths, glob patterns, or directories.
+        raise_on_empty: If True, raise FileNotFoundError when no files are found.
+
+    Returns:
+        List of valid file paths.
+
+    Raises:
+        FileNotFoundError: If raise_on_empty is True and no files are found.
+    """
     file_paths = []
     if isinstance(inputs, str):
         inputs = [inputs]
@@ -36,6 +47,8 @@ def get_file_paths(inputs: str | list[str]):
     file_paths = [f for f in file_paths if os.path.exists(f) and os.path.isfile(f)]
 
     if not file_paths:
+        if raise_on_empty:
+            raise FileNotFoundError("No files found matching the input patterns")
         logger.error("No PDF files found matching the inputs patterns")
 
     return file_paths

{vlmparse-0.1.7.dist-info → vlmparse-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vlmparse
-Version: 0.1.7
+Version: 0.1.8
 Requires-Python: >=3.11.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -54,6 +54,12 @@ Dynamic: license-file
 
 # vlmparse
 
+<div align="center">
+
+[\[📜 arXiv coming soon\]] | [[Dataset (🤗Hugging Face)]](https://huggingface.co/datasets/pulsia/fr-bench-pdf2md) | [[pypi]](https://pypi.org/project/vlmparse/) | [[vlmparse]](https://github.com/ld-lab-pulsia/vlmparse) | [[Benchmark]](https://github.com/ld-lab-pulsia/benchpdf2md)
+
+</div>
+
 A unified wrapper for Vision Language Models (VLM) and OCR solutions to parse PDF documents into Markdown.
 
 Features:
@@ -209,3 +215,7 @@ with ConverterWithServer(model="mineru2.5") as converter_with_server:
 ```
 
 Note that if you pass an uri of a vllm server to `ConverterWithServer`, the model name is inferred automatically and no server is started.
+
+## Credits
+
+This work was financed by La Poste and led by members of Probayes and OpenValue, two subsidiaries (filiales) of La Poste.

vlmparse-0.1.8.dist-info/RECORD

@@ -0,0 +1,38 @@
+vlmparse/base_model.py,sha256=4U4UPe8SNArliKnUf8pp8zQugWYsnhg9okylt7mrW1U,381
+vlmparse/build_doc.py,sha256=fb7awoqVN-6NBlKVkMFb1v1iTWcxne5QAyNaKYTyvM4,2275
+vlmparse/cli.py,sha256=asew0JdpbgFZrZqnG-Bqh5A_DrXcP0XomLB3y3AgG6Y,12855
+vlmparse/constants.py,sha256=DYaK7KtTW8p9MPb3iPvoP5H1r7ICRuIFo89P01q4uCI,184
+vlmparse/converter.py,sha256=KKcXqrp3nJo3d7DXjHn3O2SklbsJ489rDY4NJ9O42Fs,8795
+vlmparse/converter_with_server.py,sha256=A84l3YNal-hs2mMlER1sB29rddsO8MNOP2j9ts0ujtE,7280
+vlmparse/registries.py,sha256=B4kxibP7XYbhL9bZ5gn21LQCPhHCYftAM4i0-xD9fRs,6469
+vlmparse/utils.py,sha256=6Ff9OfAIVR-4_37QD5sifoNt_GmB3YUqgFwmIjuemtc,1727
+vlmparse/clients/chandra.py,sha256=zAHjgI_MJ5FVGANHCG8KJQByaw6-zTS6CHXsCBA8TJI,13025
+vlmparse/clients/deepseekocr.py,sha256=pKdNJD9v86BRn7YrXE6PGk_jQxnbZ_6UjgSUxgd3Su4,6859
+vlmparse/clients/docling.py,sha256=BLtNAxVJR6qvPip4ZBP-se8IMNFSbJ-fWEGlTSwimK8,5310
+vlmparse/clients/dotsocr.py,sha256=oAUzDMTObeW0sTy5sFl08O6GQPSTic5ITbJYh_45Z54,10414
+vlmparse/clients/granite_docling.py,sha256=KYaEdgk3oD0TuYDKqTQ4o6IkXC-E3AIYJ2KYxnEsjWM,3595
+vlmparse/clients/hunyuanocr.py,sha256=etpIiA28OoGW-o5pOGeBxOlUDjUQ4zcKXWnJ8ba44DU,1979
+vlmparse/clients/lightonocr.py,sha256=ZWC12U6myDr_2EuOPYGyJYxpBachjOUtLrxS62A8mzg,2048
+vlmparse/clients/mineru.py,sha256=9r6_JwCGB6-C-YKpoadUs7lSuDEJyBFkfjWV5WN-VrE,3599
+vlmparse/clients/mistral_converter.py,sha256=_hEyK_2vM5LEwbt30bFodMrWJtavLsBDxCkVclNUF4M,2837
+vlmparse/clients/nanonetocr.py,sha256=gTbD4OtuHiWd6Ack6Bx-anZM9P_aErfSHXwtymETvqM,1665
+vlmparse/clients/olmocr.py,sha256=V4638WftLCTr5Q6ZRgWKKSPAhFYdpBw3izeuda6EKDQ,1966
+vlmparse/clients/openai_converter.py,sha256=bckm33Pkvqul--DjfEEEI3evn4_va0CoQcigdpCCMGc,7746
+vlmparse/clients/paddleocrvl.py,sha256=q3AgEWj0UyXGpSEVZISdfqv2PV_qY-uF498bL8U1tpg,1596
+vlmparse/clients/prompts.py,sha256=-J60lqxgRzlkQ9VsQLxmWsIMaDt-gNqWqWoqHIw9CLc,4228
+vlmparse/clients/pipe_utils/cleaner.py,sha256=oxBkBTOkluN1lmeNbzajRIe0_D__ZGwUOBaI_Ph0uxE,2396
+vlmparse/clients/pipe_utils/html_to_md_conversion.py,sha256=cFFqzD2jCNw_968_eu3Wt--Ox7iJj2Rn5UoP_DZWosU,4112
+vlmparse/clients/pipe_utils/utils.py,sha256=935ecIO446I0pstszE_1nrIPHn1Ffrxunq7fVd0dsd8,315
+vlmparse/data_model/box.py,sha256=lJsh4qhjgYXZF5vTSJ1qMXD5GVlBi2_SBedBMlfJikU,16868
+vlmparse/data_model/document.py,sha256=xheaMeStOj2c9GZKmdtxcEl_Dj44V5JyVp6JnTrSpH0,4615
+vlmparse/servers/docker_server.py,sha256=FOIHU0_CDfyZ9UA285BrnUFuEMJRxbu-OzlByBa-P9s,7951
+vlmparse/servers/model_identity.py,sha256=DkH7KQAAZA9Sn7eJEnaKfH54XSEI17aqD1ScqqkTBEk,1711
+vlmparse/servers/utils.py,sha256=tIXhgbF9EVOJy2nYEguVq69gn9ATxtya_1F4wZSt68o,9454
+vlmparse/st_viewer/fs_nav.py,sha256=7GNH68h2Loh5pQ64Pe72-D2cs2BLhqRXevEmKdFmPX0,1616
+vlmparse/st_viewer/st_viewer.py,sha256=m2rQTtk5rlwErNmivNAg-4rkHkvNkvLhoJZxFQi7Dwk,2105
+vlmparse-0.1.8.dist-info/licenses/LICENSE,sha256=3TKJHk8hPBR5dbLWZ3IpfCftl-_m-iyBwpYQGZYxj14,1080
+vlmparse-0.1.8.dist-info/METADATA,sha256=dwu5tiTLuhVMYL-ZQCMNYW_MNlJu84V2us0aeRfrSpU,6048
+vlmparse-0.1.8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+vlmparse-0.1.8.dist-info/entry_points.txt,sha256=gD5berP6HwE2wNIkls-Lw5goiceA8uMgPEd7ifnFJXs,47
+vlmparse-0.1.8.dist-info/top_level.txt,sha256=k4ni-GNH_iAX7liQEsk_KY_c3xgZgt8k9fsSs9IXLXs,9
+vlmparse-0.1.8.dist-info/RECORD,,

{vlmparse-0.1.7.dist-info → vlmparse-0.1.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any