mdify-cli 2.0.0__tar.gz → 2.6.0__tar.gz

{mdify_cli-2.0.0/mdify_cli.egg-info → mdify_cli-2.6.0}/PKG-INFO

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

{mdify_cli-2.0.0 → mdify_cli-2.6.0}/mdify/__init__.py

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

{mdify_cli-2.0.0 → mdify_cli-2.6.0}/mdify/cli.py

@@ -232,6 +232,44 @@ def pull_image(runtime: str, image: str, quiet: bool = False) -> bool:
         return False
 
 
+def get_image_size_estimate(runtime: str, image: str) -> Optional[int]:
+    """
+    Estimate image size by querying registry manifest.
+
+    Runs `<runtime> manifest inspect --verbose <image>` and sums all layer sizes
+    across all architectures, then applies 50% buffer for decompression.
+
+    Args:
+        runtime: Path to container runtime
+        image: Image name/tag
+
+    Returns:
+        Estimated size in bytes with 50% buffer, or None if command fails.
+    """
+    try:
+        result = subprocess.run(
+            [runtime, "manifest", "inspect", "--verbose", image],
+            capture_output=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            return None
+
+        manifest_data = json.loads(result.stdout.decode())
+
+        # Sum all layer sizes across all architectures
+        total_size = 0
+        for manifest in manifest_data.get("Manifests", []):
+            oci_manifest = manifest.get("OCIManifest", {})
+            for layer in oci_manifest.get("layers", []):
+                total_size += layer.get("size", 0)
+
+        # Apply 50% buffer for decompression (compressed -> uncompressed)
+        return int(total_size * 1.5)
+    except (json.JSONDecodeError, KeyError, ValueError, OSError):
+        return None
+
+
 def format_size(size_bytes: int) -> str:
     """Format file size in human-readable format."""
     for unit in ["B", "KB", "MB", "GB"]:
@@ -254,6 +292,71 @@ def format_duration(seconds: float) -> str:
     return f"{hours}h {mins}m {secs:.0f}s"
 
 
+def get_free_space(path: str) -> int:
+    """Get free disk space for the given path in bytes."""
+    try:
+        return shutil.disk_usage(path).free
+    except (FileNotFoundError, OSError):
+        return 0
+
+
+def get_storage_root(runtime: str) -> Optional[str]:
+    """
+    Get the storage root directory for Docker or Podman.
+
+    Args:
+        runtime: Path to container runtime executable
+
+    Returns:
+        Storage root path as string, or None if command fails.
+    """
+    try:
+        # Extract runtime name from path (e.g., /usr/bin/docker -> docker)
+        runtime_name = os.path.basename(runtime)
+
+        if runtime_name == "docker":
+            result = subprocess.run(
+                [runtime, "system", "info", "--format", "{{.DockerRootDir}}"],
+                capture_output=True,
+                check=False,
+            )
+            if result.stdout:
+                return result.stdout.decode().strip()
+        elif runtime_name == "podman":
+            result = subprocess.run(
+                [runtime, "info", "--format", "json"],
+                capture_output=True,
+                check=False,
+            )
+            if result.stdout:
+                info = json.loads(result.stdout.decode())
+                return info.get("store", {}).get("graphRoot")
+        return None
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def confirm_proceed(message: str, default_no: bool = True) -> bool:
+    """
+    Prompt user for confirmation with a y/N prompt.
+
+    Args:
+        message: The confirmation message to display
+        default_no: If True, shows [y/N] (default no). If False, shows [Y/n] (default yes)
+
+    Returns:
+        True if user entered 'y' or 'Y', False otherwise.
+        Returns False immediately if stdin is not a TTY (non-interactive).
+    """
+    if not sys.stdin.isatty():
+        return False
+
+    prompt = "[y/N]" if default_no else "[Y/n]"
+    print(f"{message} {prompt}", file=sys.stderr)
+    response = input()
+    return response.lower() == "y"
+
+
 class Spinner:
     """A simple spinner to show progress during long operations."""
 
@@ -455,6 +558,13 @@ Examples:
         help="Suppress progress messages",
     )
 
+    parser.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help="Skip confirmation prompts (for scripts/CI)",
+    )
+
     parser.add_argument(
         "-m",
         "--mask",
@@ -499,6 +609,13 @@ Examples:
         help="Image pull policy: always, missing, never (default: missing)",
     )
 
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=None,
+        help="Conversion timeout in seconds (default: 1200, can be set via MDIFY_TIMEOUT env var)",
+    )
+
     # Utility options
     parser.add_argument(
         "--check-update",
@@ -532,6 +649,9 @@ def main() -> int:
     # Check for updates (daily, silent on errors)
     check_for_update(force=False)
 
+    # Resolve timeout value: CLI > env > default 1200
+    timeout = args.timeout or int(os.environ.get("MDIFY_TIMEOUT", 1200))
+
     # Validate input is provided
     if args.input is None:
         print("Error: Input file or directory is required", file=sys.stderr)
@@ -562,6 +682,70 @@ def main() -> int:
 
     image_exists = check_image_exists(runtime, image)
 
+    # NOTE: Docker Desktop on macOS/Windows uses a VM, so disk space checks may not
+    # accurately reflect available space in the container's filesystem. Remote Docker
+    # daemons (DOCKER_HOST) are also not supported. In these cases, the check will
+    # gracefully degrade (warn and proceed).
+
+    # Check disk space before pulling image (skip if pull=never or image exists with pull=missing)
+    will_pull = args.pull == "always" or (args.pull == "missing" and not image_exists)
+    if will_pull:
+        storage_root = get_storage_root(runtime)
+        if storage_root:
+            image_size = get_image_size_estimate(runtime, image)
+            if image_size:
+                free_space = get_free_space(storage_root)
+                if free_space < image_size:
+                    print(
+                        f"Warning: Not enough free disk space on {storage_root}",
+                        file=sys.stderr,
+                    )
+                    print(
+                        f"  Available: {format_size(free_space)}",
+                        file=sys.stderr,
+                    )
+                    print(
+                        f"  Required:  {format_size(image_size)} (estimated)",
+                        file=sys.stderr,
+                    )
+                    if args.yes:
+                        print("  Proceeding anyway (--yes flag set)", file=sys.stderr)
+                    elif not sys.stdin.isatty():
+                        print(
+                            "  Run with --yes to proceed anyway, or free up disk space",
+                            file=sys.stderr,
+                        )
+                        return 1
+                    elif not confirm_proceed("Continue anyway?"):
+                        return 130
+                elif free_space - image_size < 1024 * 1024 * 1024:
+                    print(
+                        f"Warning: Less than 1 GB would remain after pulling image on {storage_root}",
+                        file=sys.stderr,
+                    )
+                    print(
+                        f"  Available: {format_size(free_space)}",
+                        file=sys.stderr,
+                    )
+                    print(
+                        f"  Required:  {format_size(image_size)} (estimated)",
+                        file=sys.stderr,
+                    )
+                    print(
+                        f"  Remaining: {format_size(free_space - image_size)}",
+                        file=sys.stderr,
+                    )
+                    if args.yes:
+                        print("  Proceeding anyway (--yes flag set)", file=sys.stderr)
+                    elif not sys.stdin.isatty():
+                        print(
+                            "  Run with --yes to proceed anyway, or free up disk space",
+                            file=sys.stderr,
+                        )
+                        return 1
+                    elif not confirm_proceed("Continue anyway?"):
+                        return 130
+
     if args.pull == "always" or (args.pull == "missing" and not image_exists):
         if not pull_image(runtime, image, args.quiet):
             print(f"Error: Failed to pull image: {image}", file=sys.stderr)
@@ -571,9 +755,15 @@ def main() -> int:
         print(f"Run with --pull=missing or pull manually: {preferred} pull {image}")
         return 1
 
-    # Resolve paths
-    input_path = Path(args.input).resolve()
-    output_dir = Path(args.out_dir).resolve()
+    # Resolve paths (use absolute() as fallback if resolve() fails due to permissions)
+    try:
+        input_path = Path(args.input).resolve()
+    except PermissionError:
+        input_path = Path(args.input).absolute()
+    try:
+        output_dir = Path(args.out_dir).resolve()
+    except PermissionError:
+        output_dir = Path(args.out_dir).absolute()
 
     # Validate input
     if not input_path.exists():
@@ -622,7 +812,7 @@ def main() -> int:
             print(f"Starting docling-serve container...")
             print()
 
-        with DoclingContainer(runtime, image, args.port) as container:
+        with DoclingContainer(runtime, image, args.port, timeout=timeout) as container:
             # Convert files
             conversion_start = time.time()
             spinner = Spinner()

{mdify_cli-2.0.0 → mdify_cli-2.6.0}/mdify/container.py

@@ -20,17 +20,19 @@ class DoclingContainer:
         # Container automatically stopped and removed
     """
 
-    def __init__(self, runtime: str, image: str, port: int = 5001):
+    def __init__(self, runtime: str, image: str, port: int = 5001, timeout: int = 1200):
         """Initialize container manager.
 
         Args:
             runtime: Container runtime ("docker" or "podman")
             image: Container image to use
             port: Host port to bind (default: 5001)
+            timeout: Conversion timeout in seconds (default: 1200)
         """
         self.runtime = runtime
         self.image = image
         self.port = port
+        self.timeout = timeout
         self.container_name = f"mdify-serve-{uuid.uuid4().hex[:8]}"
         self.container_id: Optional[str] = None
 
@@ -39,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.
 
@@ -49,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,
@@ -59,6 +96,8 @@ class DoclingContainer:
             self.container_name,
             "-p",
             f"{self.port}:5001",
+            "-e",
+            f"DOCLING_SERVE_MAX_SYNC_WAIT={self.timeout}",
             self.image,
         ]
 

{mdify_cli-2.0.0 → mdify_cli-2.6.0/mdify_cli.egg-info}/PKG-INFO

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

{mdify_cli-2.0.0 → mdify_cli-2.6.0}/pyproject.toml

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