mdify-cli 2.5.0__tar.gz → 2.8.0__tar.gz

{mdify_cli-2.5.0/mdify_cli.egg-info → mdify_cli-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdify-cli
-Version: 2.5.0
+Version: 2.8.0
 Summary: Convert PDFs and document images into structured Markdown for LLM workflows
 Author: tiroq
 License-Expression: MIT

{mdify_cli-2.5.0 → mdify_cli-2.8.0}/mdify/__init__.py

@@ -1,3 +1,3 @@
 """mdify - Convert documents to Markdown via Docling container."""
 
-__version__ = "2.5.0"
+__version__ = "2.8.0"

{mdify_cli-2.5.0 → mdify_cli-2.8.0}/mdify/container.py

@@ -41,6 +41,39 @@ class DoclingContainer:
         """Return base URL for API requests."""
         return f"http://localhost:{self.port}"
 
+    def _cleanup_stale_containers(self) -> None:
+        """Stop any existing mdify-serve containers.
+
+        This handles the case where a previous run left a container running
+        (e.g., due to crash, interrupt, or timeout).
+        """
+        # Find running containers matching mdify-serve-* pattern
+        result = subprocess.run(
+            [
+                self.runtime,
+                "ps",
+                "--filter",
+                "name=mdify-serve-",
+                "--format",
+                "{{.Names}}",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        if result.returncode != 0 or not result.stdout.strip():
+            return
+
+        # Stop each stale container
+        for container_name in result.stdout.strip().split("\n"):
+            if container_name:
+                subprocess.run(
+                    [self.runtime, "stop", container_name],
+                    capture_output=True,
+                    check=False,
+                )
+
     def start(self, timeout: int = 120) -> None:
         """Start container and wait for health check.
 
@@ -51,6 +84,8 @@ class DoclingContainer:
             subprocess.CalledProcessError: If container fails to start
             TimeoutError: If health check doesn't pass within timeout
         """
+        self._cleanup_stale_containers()
+
         # Start container in detached mode
         cmd = [
             self.runtime,

{mdify_cli-2.5.0 → mdify_cli-2.8.0}/mdify/docling_client.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
 
+import mimetypes
+
 import requests
 
 
@@ -40,6 +42,48 @@ class DoclingHTTPError(DoclingClientError):
         super().__init__(f"HTTP {status_code}: {message}")
 
 
+def _get_mime_type(file_path: Path) -> str:
+    """Get MIME type for file, with fallback for unknown types."""
+    mime_type, _ = mimetypes.guess_type(str(file_path))
+    return mime_type or "application/octet-stream"
+
+
+def _extract_content(result_data) -> str:
+    """Extract content from API response, supporting both old and new formats.
+
+    Supports:
+    - New format: {"document": {"md_content": "..."}}
+    - Fallback: {"document": {"content": "..."}}
+    - Old format: {"content": "..."}
+    - List format: [{"document": {...}} or {"content": "..."}]
+
+    Args:
+        result_data: Response data from docling-serve API
+
+    Returns:
+        Extracted content string, or empty string if not found
+    """
+    if isinstance(result_data, dict):
+        # New format with document field
+        if "document" in result_data:
+            doc = result_data["document"]
+            # Try md_content first, then content
+            return doc.get("md_content", "") or doc.get("content", "")
+        # Old format without document field
+        return result_data.get("content", "")
+    elif isinstance(result_data, list) and len(result_data) > 0:
+        # List format - process first item
+        first_result = result_data[0]
+        if isinstance(first_result, dict):
+            if "document" in first_result:
+                doc = first_result["document"]
+                # Try md_content first, then content
+                return doc.get("md_content", "") or doc.get("content", "")
+            # Old format without document field
+            return first_result.get("content", "")
+    return ""
+
+
 def check_health(base_url: str) -> bool:
     """Check if docling-serve is healthy.
 
@@ -77,7 +121,7 @@ def convert_file(
         with open(file_path, "rb") as f:
             response = requests.post(
                 f"{base_url}/v1/convert/file",
-                files={"files": (file_path.name, f, "application/pdf")},
+                files={"files": (file_path.name, f, _get_mime_type(file_path))},
                 data={"to_formats": to_format, "do_ocr": str(do_ocr).lower()},
             )
 
@@ -87,17 +131,10 @@ def convert_file(
             )
 
         result_data = response.json()
+        content = _extract_content(result_data)
 
-        # docling-serve returns results in a list format
-        if isinstance(result_data, list) and len(result_data) > 0:
-            first_result = result_data[0]
-            return ConvertResult(
-                content=first_result.get("content", ""), format=to_format, success=True
-            )
-        elif isinstance(result_data, dict):
-            return ConvertResult(
-                content=result_data.get("content", ""), format=to_format, success=True
-            )
+        if content or isinstance(result_data, (dict, list)):
+            return ConvertResult(content=content, format=to_format, success=True)
         else:
             raise DoclingHTTPError(200, f"Unexpected response format: {result_data}")
 
@@ -126,7 +163,7 @@ def convert_file_async(
         with open(file_path, "rb") as f:
             response = requests.post(
                 f"{base_url}/v1/convert/file/async",
-                files={"files": (file_path.name, f, "application/pdf")},
+                files={"files": (file_path.name, f, _get_mime_type(file_path))},
                 data={"to_formats": to_format, "do_ocr": str(do_ocr).lower()},
             )
 
@@ -202,19 +239,21 @@ def get_result(base_url: str, task_id: str) -> ConvertResult:
             )
 
         result_data = response.json()
+        content = _extract_content(result_data)
 
-        # Similar to sync conversion, handle list or dict format
-        if isinstance(result_data, list) and len(result_data) > 0:
+        # Determine format from response, defaulting to "md"
+        result_format = "md"
+        if isinstance(result_data, dict):
+            result_format = result_data.get("format", "md")
+        elif isinstance(result_data, list) and len(result_data) > 0:
             first_result = result_data[0]
+            if isinstance(first_result, dict):
+                result_format = first_result.get("format", "md")
+
+        if content or isinstance(result_data, (dict, list)):
             return ConvertResult(
-                content=first_result.get("content", ""),
-                format=first_result.get("format", "md"),
-                success=True,
-            )
-        elif isinstance(result_data, dict):
-            return ConvertResult(
-                content=result_data.get("content", ""),
-                format=result_data.get("format", "md"),
+                content=content,
+                format=result_format,
                 success=True,
             )
         else:

{mdify_cli-2.5.0 → mdify_cli-2.8.0/mdify_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdify-cli
-Version: 2.5.0
+Version: 2.8.0
 Summary: Convert PDFs and document images into structured Markdown for LLM workflows
 Author: tiroq
 License-Expression: MIT

{mdify_cli-2.5.0 → mdify_cli-2.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mdify-cli"
-version = "2.5.0"
+version = "2.8.0"
 description = "Convert PDFs and document images into structured Markdown for LLM workflows"
 readme = "README.md"
 requires-python = ">=3.8"

{mdify_cli-2.5.0 → mdify_cli-2.8.0}/tests/test_container.py

@@ -311,7 +311,110 @@ class TestDoclingContainerIntegration:
             container1 = DoclingContainer("docker", "image1", port=5001)
             container2 = DoclingContainer("docker", "image2", port=5002)
 
-            # Each should be independent
             assert container1.port == 5001
             assert container2.port == 5002
             assert container1.container_name != container2.container_name
+
+
+class TestDoclingContainerCleanup:
+    """Test cleanup of stale containers."""
+
+    def test_cleanup_no_stale_containers(self):
+        """Test cleanup runs when no stale containers exist."""
+        with patch("mdify.container.subprocess.run") as mock_run, patch(
+            "mdify.container.check_health"
+        ) as mock_health:
+            ps_result = Mock()
+            ps_result.returncode = 0
+            ps_result.stdout = ""
+
+            run_result = Mock()
+            run_result.stdout = "container_id\n"
+
+            mock_run.side_effect = [ps_result, run_result]
+            mock_health.return_value = True
+
+            container = DoclingContainer("docker", "test-image")
+            container.start(timeout=5)
+
+            ps_call = mock_run.call_args_list[0][0][0]
+            assert "ps" in ps_call
+            assert "--filter" in ps_call
+            assert "name=mdify-serve-" in ps_call
+
+    def test_cleanup_stops_stale_containers(self):
+        """Test cleanup finds and stops stale containers."""
+        with patch("mdify.container.subprocess.run") as mock_run, patch(
+            "mdify.container.check_health"
+        ) as mock_health:
+            ps_result = Mock()
+            ps_result.returncode = 0
+            ps_result.stdout = "mdify-serve-abc123\nmdify-serve-def456\n"
+
+            stop_result1 = Mock()
+            stop_result2 = Mock()
+
+            run_result = Mock()
+            run_result.stdout = "container_id\n"
+
+            mock_run.side_effect = [ps_result, stop_result1, stop_result2, run_result]
+            mock_health.return_value = True
+
+            container = DoclingContainer("docker", "test-image")
+            container.start(timeout=5)
+
+            ps_call = mock_run.call_args_list[0][0][0]
+            assert "ps" in ps_call
+
+            stop_calls = [
+                call for call in mock_run.call_args_list if "stop" in str(call)
+            ]
+            assert len(stop_calls) == 2
+            assert "mdify-serve-abc123" in str(stop_calls[0])
+            assert "mdify-serve-def456" in str(stop_calls[1])
+
+    def test_cleanup_handles_subprocess_error(self):
+        """Test cleanup handles subprocess errors gracefully."""
+        with patch("mdify.container.subprocess.run") as mock_run, patch(
+            "mdify.container.check_health"
+        ) as mock_health:
+            ps_result = Mock()
+            ps_result.returncode = 1
+            ps_result.stdout = ""
+
+            run_result = Mock()
+            run_result.stdout = "container_id\n"
+
+            mock_run.side_effect = [ps_result, run_result]
+            mock_health.return_value = True
+
+            container = DoclingContainer("docker", "test-image")
+            container.start(timeout=5)
+
+            assert container.container_id == "container_id"
+
+    def test_start_calls_cleanup(self):
+        """Test that start() calls _cleanup_stale_containers()."""
+        with patch("mdify.container.subprocess.run") as mock_run, patch(
+            "mdify.container.check_health"
+        ) as mock_health:
+            ps_result = Mock()
+            ps_result.returncode = 0
+            ps_result.stdout = ""
+
+            run_result = Mock()
+            run_result.stdout = "new_container_id\n"
+
+            mock_run.side_effect = [ps_result, run_result]
+            mock_health.return_value = True
+
+            container = DoclingContainer("docker", "test-image")
+            container.start(timeout=5)
+
+            all_calls = mock_run.call_args_list
+            ps_called = any("ps" in str(call) for call in all_calls[:1])
+            run_called = any("run" in str(call) for call in all_calls)
+
+            assert ps_called
+            assert run_called
+            assert "ps" in all_calls[0][0][0]

{mdify_cli-2.5.0 → mdify_cli-2.8.0}/tests/test_docling_client.py

@@ -133,6 +133,26 @@ class TestConvertFile:
 
             assert result.format == "html"
 
+    def test_convert_file_new_document_format(self, tmp_path):
+        """Test file conversion with new document.md_content format."""
+        test_file = tmp_path / "test.pdf"
+        test_file.write_bytes(b"fake pdf content")
+
+        with patch("mdify.docling_client.requests.post") as mock_post:
+            mock_response = Mock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = {
+                "document": {"md_content": "# New Format Content\n\nMarkdown here."}
+            }
+            mock_post.return_value = mock_response
+
+            result = convert_file("http://localhost:5001", test_file)
+
+            assert result.success is True
+            assert "# New Format Content" in result.content
+            assert result.error is None
+            assert result.format == "md"
+
 
 class TestConvertFileAsync:
     """Test async file conversion."""
@@ -302,6 +322,25 @@ class TestGetResult:
             assert result.success is False
             assert result.error is not None
 
+    def test_get_result_new_document_format(self):
+        """Test getting result with new document.md_content format."""
+        with patch("mdify.docling_client.requests.get") as mock_get:
+            mock_response = Mock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = {
+                "document": {
+                    "md_content": "# Result with MD Content\n\nFormatted markdown."
+                }
+            }
+            mock_get.return_value = mock_response
+
+            result = get_result("http://localhost:5001", "abc123")
+
+            assert result.success is True
+            assert "# Result with MD Content" in result.content
+            assert result.error is None
+            assert result.format == "md"
+
 
 class TestDataClasses:
     """Test dataclass definitions."""
@@ -356,3 +395,97 @@ class TestDoclingHTTPError:
         error = DoclingHTTPError(400, "Bad Request")
 
         assert isinstance(error, Exception)
+
+
+class TestMimeTypeDetection:
+    """Test MIME type detection in file conversion."""
+
+    def test_convert_file_sends_correct_mime_for_xlsx(self, tmp_path):
+        """Test that .xlsx files are sent with correct MIME type."""
+        test_file = tmp_path / "test.xlsx"
+        test_file.write_bytes(b"fake xlsx content")
+
+        with patch("mdify.docling_client.requests.post") as mock_post:
+            mock_response = Mock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = [
+                {"content": "# Test Spreadsheet\n\nContent here."}
+            ]
+            mock_post.return_value = mock_response
+
+            convert_file("http://localhost:5001", test_file)
+
+            mock_post.assert_called_once()
+            call_args = mock_post.call_args
+            files_param = call_args[1]["files"]
+            filename, file_obj, mime_type = files_param["files"]
+            assert (
+                mime_type
+                == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            )
+
+    def test_convert_file_sends_correct_mime_for_pdf(self, tmp_path):
+        """Test that .pdf files are sent with correct MIME type (regression test)."""
+        test_file = tmp_path / "test.pdf"
+        test_file.write_bytes(b"fake pdf content")
+
+        with patch("mdify.docling_client.requests.post") as mock_post:
+            mock_response = Mock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = [
+                {"content": "# Test Document\n\nContent here."}
+            ]
+            mock_post.return_value = mock_response
+
+            convert_file("http://localhost:5001", test_file)
+
+            mock_post.assert_called_once()
+            call_args = mock_post.call_args
+            files_param = call_args[1]["files"]
+            filename, file_obj, mime_type = files_param["files"]
+            assert mime_type == "application/pdf"
+
+    def test_convert_file_sends_correct_mime_for_docx(self, tmp_path):
+        """Test that .docx files are sent with correct MIME type."""
+        test_file = tmp_path / "test.docx"
+        test_file.write_bytes(b"fake docx content")
+
+        with patch("mdify.docling_client.requests.post") as mock_post:
+            mock_response = Mock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = [
+                {"content": "# Test Document\n\nContent here."}
+            ]
+            mock_post.return_value = mock_response
+
+            convert_file("http://localhost:5001", test_file)
+
+            mock_post.assert_called_once()
+            call_args = mock_post.call_args
+            files_param = call_args[1]["files"]
+            filename, file_obj, mime_type = files_param["files"]
+            assert (
+                mime_type
+                == "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+            )
+
+    def test_convert_file_fallback_for_unknown_extension(self, tmp_path):
+        """Test that unknown file extensions fall back to application/octet-stream."""
+        test_file = tmp_path / "test.unknownext123"
+        test_file.write_bytes(b"fake unknown content")
+
+        with patch("mdify.docling_client.requests.post") as mock_post:
+            mock_response = Mock()
+            mock_response.status_code = 200
+            mock_response.json.return_value = [
+                {"content": "# Test Content\n\nContent here."}
+            ]
+            mock_post.return_value = mock_response
+
+            convert_file("http://localhost:5001", test_file)
+
+            mock_post.assert_called_once()
+            call_args = mock_post.call_args
+            files_param = call_args[1]["files"]
+            filename, file_obj, mime_type = files_param["files"]
+            assert mime_type == "application/octet-stream"