vlmparse 0.1.4__tar.gz → 0.1.6__tar.gz

{vlmparse-0.1.4/vlmparse.egg-info → vlmparse-0.1.6}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: vlmparse
-Version: 0.1.4
-Requires-Python: >=3.12.0
+Version: 0.1.6
+Requires-Python: >=3.11.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: devtools>=0.12.2
@@ -72,6 +72,19 @@ Supported Converters:
 
 ## Installation
 
+Simplest solution with only the cli: 
+
+```bash
+uv tool install vlmparse
+```
+
+If you want to run the granite-docling model or use the streamlit viewing app:
+
+```bash
+uv tool install vlmparse[docling_core,st_app]
+```
+
+If you prefer cloning the repository and using the local version:
 ```bash
 uv sync
 ```
@@ -86,10 +99,11 @@ Activate the virtual environment:
 ```bash
 source .venv/bin/activate
 ```
-Other solution: append uv run to all the commands below.
 
 ## CLI Usage
 
+Note that you can bypass the previous installation step and just add uvx before each of the commands below.
+
 ### Convert PDFs
 
 With a general VLM (requires setting your api key as an environment variable):
@@ -185,11 +199,13 @@ server.stop()
 ```
 
 
-Converter with automatic server deployment:
+Converter with automatic server management:
 
 ```python
 from vlmparse.converter_with_server import ConverterWithServer
 
-converter_with_server = ConverterWithServer(model="mineru2.5")
-documents = converter_with_server.parse(inputs=["file1.pdf", "file2.pdf"], out_folder="./output")
+with ConverterWithServer(model="mineru2.5") as converter_with_server:
+    documents = converter_with_server.parse(inputs=["file1.pdf", "file2.pdf"], out_folder="./output")
 ```
+
+Note that if you pass an uri of a vllm server to `ConverterWithServer`, the model name is inferred automatically and no server is started.

{vlmparse-0.1.4 → vlmparse-0.1.6}/README.md

@@ -18,6 +18,19 @@ Supported Converters:
 
 ## Installation
 
+Simplest solution with only the cli: 
+
+```bash
+uv tool install vlmparse
+```
+
+If you want to run the granite-docling model or use the streamlit viewing app:
+
+```bash
+uv tool install vlmparse[docling_core,st_app]
+```
+
+If you prefer cloning the repository and using the local version:
 ```bash
 uv sync
 ```
@@ -32,10 +45,11 @@ Activate the virtual environment:
 ```bash
 source .venv/bin/activate
 ```
-Other solution: append uv run to all the commands below.
 
 ## CLI Usage
 
+Note that you can bypass the previous installation step and just add uvx before each of the commands below.
+
 ### Convert PDFs
 
 With a general VLM (requires setting your api key as an environment variable):
@@ -131,11 +145,13 @@ server.stop()
 ```
 
 
-Converter with automatic server deployment:
+Converter with automatic server management:
 
 ```python
 from vlmparse.converter_with_server import ConverterWithServer
 
-converter_with_server = ConverterWithServer(model="mineru2.5")
-documents = converter_with_server.parse(inputs=["file1.pdf", "file2.pdf"], out_folder="./output")
-```
+with ConverterWithServer(model="mineru2.5") as converter_with_server:
+    documents = converter_with_server.parse(inputs=["file1.pdf", "file2.pdf"], out_folder="./output")
+```
+
+Note that if you pass an uri of a vllm server to `ConverterWithServer`, the model name is inferred automatically and no server is started.

{vlmparse-0.1.4 → vlmparse-0.1.6}/pyproject.toml

@@ -2,17 +2,13 @@
 requires = ["setuptools", "wheel"]
 build-backend = "setuptools.build_meta"
 
-[metadata]
-name = "vlmparse"
-version = "0.1.0"
-
 [project]
 name = "vlmparse"
-version = "0.1.4"
+version = "0.1.6"
 authors = []
 description = ""
 readme = "README.md"
-requires-python = ">=3.12.0"
+requires-python = ">=3.11.0"
 dependencies = [
     "devtools>=0.12.2",
     "docker>=7.1.0",

{vlmparse-0.1.4 → vlmparse-0.1.6}/tests/test_all_converters_mocked.py

@@ -5,6 +5,7 @@ This avoids the need to deploy actual Docker servers.
 
 from unittest.mock import AsyncMock, MagicMock, patch
 
+import orjson
 import pytest
 
 from vlmparse.data_model.document import Document, Page
@@ -26,6 +27,10 @@ def mock_openai_client():
         mock_response = MagicMock()
         mock_response.choices = [MagicMock()]
         mock_response.choices[0].message.content = MOCK_RESPONSES["default"]
+        mock_response.usage = MagicMock()
+        mock_response.usage.prompt_tokens = 50
+        mock_response.usage.completion_tokens = 150
+        mock_response.usage.reasoning_tokens = 30
 
         # Configure the async method
         mock_instance = MagicMock()
@@ -42,7 +47,10 @@ def dotsocr_mock_client():
         mock_response = MagicMock()
         mock_response.choices = [MagicMock()]
         mock_response.choices[0].message.content = MOCK_RESPONSES["dotsocr_ocr"]
-
+        mock_response.usage = MagicMock()
+        mock_response.usage.prompt_tokens = 40
+        mock_response.usage.completion_tokens = 160
+        mock_response.usage.reasoning_tokens = 20
         mock_instance = MagicMock()
         mock_instance.chat.completions.create = AsyncMock(return_value=mock_response)
         mock_client.return_value = mock_instance
@@ -87,7 +95,7 @@ class TestConverterConfigs:
     ):
         """Test basic document processing for OpenAI-compatible converters."""
         config = converter_config_registry.get(model_name)
-        converter = config.get_client(num_concurrent_pages=2)
+        converter = config.get_client(num_concurrent_pages=2, debug=True)
 
         # Process document
         document = converter(file_path)
@@ -112,7 +120,7 @@ class TestConverterConfigs:
         image_path = datadir / "page_with_formula.png"
 
         config = converter_config_registry.get(model_name)
-        converter = config.get_client()
+        converter = config.get_client(debug=True)
 
         # Process image
         document = converter(image_path)
@@ -134,7 +142,7 @@ class TestConverterConfigs:
     def test_dotsocr_ocr_mode(self, file_path, dotsocr_mock_client):
         """Test DotsOCR converter in OCR mode."""
         config = converter_config_registry.get("dotsocr")
-        converter = config.get_client(num_concurrent_pages=2)
+        converter = config.get_client(num_concurrent_pages=2, debug=True)
 
         # Process document
         document = converter(file_path)
@@ -192,6 +200,7 @@ class TestConverterBatchProcessing:
             num_concurrent_files=2,
             num_concurrent_pages=2,
             return_documents_in_batch_mode=True,
+            debug=True,
         )
 
         # Process multiple files (same file for testing)
@@ -205,6 +214,95 @@ class TestConverterBatchProcessing:
             assert len(doc.pages) == 2
 
 
+@pytest.fixture
+def mineru_mock_httpx_client():
+    """Mock the httpx AsyncClient used by MinerUConverter."""
+    with patch("httpx.AsyncClient") as mock_async_client:
+        mock_client = MagicMock()
+        mock_async_client.return_value = mock_client
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.__aexit__ = AsyncMock(return_value=None)
+
+        mock_response = MagicMock()
+        mock_response.raise_for_status = MagicMock()
+        mock_response.content = orjson.dumps(
+            [
+                {
+                    "bbox": [0.1, 0.2, 0.3, 0.4],
+                    "content": "<p>Hello MinerU</p>",
+                    "type": "Text",
+                },
+                {
+                    "bbox": [0.5, 0.6, 0.7, 0.8],
+                    "content": "<p>Second block</p>",
+                    "type": "Text",
+                },
+            ]
+        )
+
+        mock_client.post = AsyncMock(return_value=mock_response)
+        yield mock_client
+
+
+class TestMinerUConverterMockedApi:
+    def test_mineru_converter_repeated_call(self, file_path, mineru_mock_httpx_client):
+        """Repeated `__call__` should keep working and call API each page."""
+        from vlmparse.clients.mineru import MinerUConverterConfig
+
+        config = MinerUConverterConfig(base_url="http://mineru.test")
+        converter = config.get_client(num_concurrent_pages=2, debug=True)
+
+        with (
+            patch("vlmparse.clients.mineru.clean_response", lambda x: x),
+            patch("vlmparse.clients.mineru.html_to_md_keep_tables", lambda x: x),
+        ):
+            doc1 = converter(file_path)
+            doc2 = converter(file_path)
+
+        assert isinstance(doc1, Document)
+        assert isinstance(doc2, Document)
+        assert len(doc1.pages) == 2
+        assert len(doc2.pages) == 2
+
+        for page in doc1.pages + doc2.pages:
+            assert isinstance(page, Page)
+            assert page.text is not None and len(page.text) > 0
+            assert page.items is not None
+            assert len(page.items) == 2
+
+        # 2 pages per doc * 2 docs
+        assert mineru_mock_httpx_client.post.call_count == 4
+
+    def test_mineru_converter_batch_processing(
+        self, file_path, mineru_mock_httpx_client
+    ):
+        """Batch mode should return documents and call API for each page."""
+        from vlmparse.clients.mineru import MinerUConverterConfig
+
+        config = MinerUConverterConfig(base_url="http://mineru.test")
+        converter = config.get_client(
+            num_concurrent_files=2,
+            num_concurrent_pages=2,
+            return_documents_in_batch_mode=True,
+            debug=True,
+        )
+
+        with (
+            patch("vlmparse.clients.mineru.clean_response", lambda x: x),
+            patch("vlmparse.clients.mineru.html_to_md_keep_tables", lambda x: x),
+        ):
+            docs = converter.batch([file_path, file_path])
+
+        assert isinstance(docs, list)
+        assert len(docs) == 2
+        for doc in docs:
+            assert isinstance(doc, Document)
+            assert len(doc.pages) == 2
+
+        # 2 pages per doc * 2 docs
+        assert mineru_mock_httpx_client.post.call_count == 4
+
+
 class TestCustomURI:
     """Test converter initialization with custom URIs."""
 
@@ -216,7 +314,7 @@ class TestCustomURI:
         assert config.llm_params.base_url == custom_uri
 
         # Test it works
-        converter = config.get_client()
+        converter = config.get_client(debug=True)
         document = converter(file_path)
 
         assert isinstance(document, Document)
@@ -232,7 +330,7 @@ class TestConcurrency:
     ):
         """Test that concurrent page processing limits are respected."""
         config = converter_config_registry.get(model_name)
-        converter = config.get_client(num_concurrent_pages=1)
+        converter = config.get_client(num_concurrent_pages=1, debug=True)
 
         document = converter(file_path)
 

{vlmparse-0.1.4 → vlmparse-0.1.6}/tests/test_batch_parser.py

@@ -39,14 +39,13 @@ class TestBatchParser:
         mock_docker_registry.get.return_value = mock_config
 
         # Initialize
-        parser = ConverterWithServer(model="test_model", with_vllm_server=True)
-
-        # Verify interactions
-        mock_docker_registry.get.assert_called_with("test_model", default=True)
-        mock_config.get_server.assert_called_with(auto_stop=True)
-        mock_server.start.assert_called_once()
-        mock_config.get_client.assert_called_once()
-        assert parser.client == mock_client
+        with ConverterWithServer(model="test_model", with_vllm_server=True) as parser:
+            # Verify interactions
+            mock_docker_registry.get.assert_called_with("test_model", default=True)
+            mock_config.get_server.assert_called_with(auto_stop=True)
+            mock_server.start.assert_called_once()
+            mock_config.get_client.assert_called_once()
+            assert parser.client == mock_client
 
     def test_init_no_docker_fallback(
         self, mock_docker_registry, mock_converter_registry
@@ -61,13 +60,12 @@ class TestBatchParser:
         mock_converter_registry.get.return_value = mock_converter_config
 
         # Initialize
-        parser = ConverterWithServer(model="test_model")
-
-        # Verify interactions
-        mock_docker_registry.get.assert_called_with("test_model", default=False)
-        mock_converter_registry.get.assert_called_with("test_model")
-        mock_converter_config.get_client.assert_called_once()
-        assert parser.client == mock_client
+        with ConverterWithServer(model="test_model") as parser:
+            # Verify interactions
+            mock_docker_registry.get.assert_called_with("test_model", default=False)
+            mock_converter_registry.get.assert_called_with("test_model")
+            mock_converter_config.get_client.assert_called_once()
+            assert parser.client == mock_client
 
     def test_init_with_uri(self, mock_converter_registry):
         """Test initialization with explicit URI."""
@@ -76,13 +74,12 @@ class TestBatchParser:
         mock_config.get_client.return_value = mock_client
         mock_converter_registry.get.return_value = mock_config
 
-        parser = ConverterWithServer(model="test_model", uri="http://custom.uri")
-
-        mock_converter_registry.get.assert_called_with(
-            "test_model", uri="http://custom.uri"
-        )
-        mock_config.get_client.assert_called_once()
-        assert parser.client == mock_client
+        with ConverterWithServer(model="test_model", uri="http://custom.uri") as parser:
+            mock_converter_registry.get.assert_called_with(
+                "test_model", uri="http://custom.uri"
+            )
+            mock_config.get_client.assert_called_once()
+            assert parser.client == mock_client
 
     def test_parse_updates_client_config(
         self, mock_docker_registry, mock_get_file_paths, tmp_path
@@ -100,27 +97,30 @@ class TestBatchParser:
         mock_doc = MagicMock(spec=Document)
         mock_client.batch.return_value = [mock_doc, mock_doc]
 
-        parser = ConverterWithServer(model="test_model")
-
-        # Call parse
-        documents = parser.parse(
-            inputs=["dummy"], out_folder=str(tmp_path), mode="md", dpi=300, debug=True
-        )
-
-        # Verify client config updates
-        assert mock_client.config.dpi == 300
-        assert mock_client.debug is True
-        assert mock_client.save_mode == "md"
-        # Concurrency should be 1 because debug=True
-        assert mock_client.num_concurrent_files == 1
-        assert mock_client.num_concurrent_pages == 1
-
-        # Verify batch call
-        mock_client.batch.assert_called_once_with(["file1.pdf", "file2.pdf"])
-
-        # Verify result
-        assert len(documents) == 2
-        assert documents[0] == mock_doc
+        with ConverterWithServer(model="test_model") as parser:
+            # Call parse
+            documents = parser.parse(
+                inputs=["dummy"],
+                out_folder=str(tmp_path),
+                mode="md",
+                dpi=300,
+                debug=True,
+            )
+
+            # Verify client config updates
+            assert mock_client.config.dpi == 300
+            assert mock_client.debug is True
+            assert mock_client.save_mode == "md"
+            # Concurrency should be 1 because debug=True
+            assert mock_client.num_concurrent_files == 1
+            assert mock_client.num_concurrent_pages == 1
+
+            # Verify batch call
+            mock_client.batch.assert_called_once_with(["file1.pdf", "file2.pdf"])
+
+            # Verify result
+            assert len(documents) == 2
+            assert documents[0] == mock_doc
 
     def test_parse_retry_logic(
         self, mock_docker_registry, mock_get_file_paths, tmp_path
@@ -143,19 +143,18 @@ class TestBatchParser:
         # Input has file1 (processed) and file2 (new)
         mock_get_file_paths.return_value = ["path/to/file1.pdf", "path/to/file2.pdf"]
 
-        parser = ConverterWithServer(model="test_model")
-
-        # Call parse with retrylast
-        parser.parse(inputs=["dummy"], out_folder=str(tmp_path), retrylast=True)
+        with ConverterWithServer(model="test_model") as parser:
+            # Call parse with retrylast
+            parser.parse(inputs=["dummy"], out_folder=str(tmp_path), retrylast=True)
 
-        # Verify only file2 was sent to batch
-        # file1 should be filtered out because file1.zip exists
-        call_args = mock_client.batch.call_args
-        assert call_args is not None
-        batch_files = call_args[0][0]
-        assert len(batch_files) == 1
-        assert "file2.pdf" in batch_files[0]
-        assert "file1.pdf" not in batch_files[0]
+            # Verify only file2 was sent to batch
+            # file1 should be filtered out because file1.zip exists
+            call_args = mock_client.batch.call_args
+            assert call_args is not None
+            batch_files = call_args[0][0]
+            assert len(batch_files) == 1
+            assert "file2.pdf" in batch_files[0]
+            assert "file1.pdf" not in batch_files[0]
 
     def test_parse_retry_no_previous_runs(
         self, mock_docker_registry, mock_get_file_paths, tmp_path
@@ -166,9 +165,8 @@ class TestBatchParser:
         mock_config.get_client.return_value = mock_client
         mock_docker_registry.get.return_value = mock_config
 
-        parser = ConverterWithServer(model="test_model")
+        with ConverterWithServer(model="test_model") as parser:
+            # tmp_path is empty, so os.listdir(tmp_path) will be empty
 
-        # tmp_path is empty, so os.listdir(tmp_path) will be empty
-
-        with pytest.raises(ValueError, match="No previous runs found"):
-            parser.parse(inputs=["dummy"], out_folder=str(tmp_path), retrylast=True)
+            with pytest.raises(ValueError, match="No previous runs found"):
+                parser.parse(inputs=["dummy"], out_folder=str(tmp_path), retrylast=True)