mdify-cli 2.5.0__py3-none-any.whl → 2.10.0__py3-none-any.whl

mdify/__init__.py

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

mdify/cli.py

@@ -10,6 +10,7 @@ is lightweight and has no ML dependencies.
 import argparse
 import json
 import os
+import platform
 import shutil
 import subprocess
 import sys
@@ -33,7 +34,9 @@ CHECK_INTERVAL_SECONDS = 86400  # 24 hours
 # Container configuration
 DEFAULT_IMAGE = "ghcr.io/docling-project/docling-serve-cpu:main"
 GPU_IMAGE = "ghcr.io/docling-project/docling-serve-cu126:main"
-SUPPORTED_RUNTIMES = ("docker", "podman")
+SUPPORTED_RUNTIMES = ("docker", "podman", "orbstack", "colima", "container")
+MACOS_RUNTIMES_PRIORITY = ("container", "orbstack", "colima", "podman", "docker")
+OTHER_RUNTIMES_PRIORITY = ("docker", "podman")
 
 
 # =============================================================================
@@ -151,34 +154,117 @@ def check_for_update(force: bool = False) -> None:
 # =============================================================================
 
 
-def detect_runtime(preferred: str, explicit: bool = True) -> Optional[str]:
+def is_daemon_running(runtime: str) -> bool:
+    """
+    Check if a container runtime daemon is running.
+
+    Args:
+        runtime: Path to container runtime executable
+
+    Returns:
+        True if daemon is running and responsive, False otherwise.
+    """
+    try:
+        runtime_name = os.path.basename(runtime)
+        
+        # Apple Container uses 'container system status' to check daemon
+        if runtime_name == "container":
+            result = subprocess.run(
+                [runtime, "system", "status"],
+                capture_output=True,
+                timeout=5,
+                check=False,
+            )
+            return result.returncode == 0
+        
+        # Other runtimes use --version check
+        result = subprocess.run(
+            [runtime, "--version"],
+            capture_output=True,
+            timeout=5,
+            check=False,
+        )
+        return result.returncode == 0
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
+def detect_runtime(preferred: Optional[str] = None, explicit: bool = True) -> Optional[str]:
     """
     Detect available container runtime.
 
+    First checks MDIFY_CONTAINER_RUNTIME environment variable for explicit override.
+    On macOS, tries native tools first (OrbStack → Colima → Podman → Docker).
+    On other platforms, tries Docker → Podman.
+
     Args:
-        preferred: Preferred runtime ('docker' or 'podman')
-        explicit: If True, warn when falling back to alternative.
-                  If False, silently use alternative without warning.
-                  Note: This only controls warning emission; selection order
-                  is always preferred → alternative regardless of this flag.
+        preferred: Preferred runtime name override (deprecated, use MDIFY_CONTAINER_RUNTIME)
+        explicit: If True, print info about detection/fallback choices.
 
     Returns:
         Path to runtime executable, or None if not found.
     """
-    # Try preferred runtime first
-    runtime_path = shutil.which(preferred)
-    if runtime_path:
-        return runtime_path
-
-    # Try alternative
-    alternative = "podman" if preferred == "docker" else "docker"
-    runtime_path = shutil.which(alternative)
-    if runtime_path:
+    # Check for explicit environment variable override
+    env_runtime = os.environ.get("MDIFY_CONTAINER_RUNTIME", "").strip().lower()
+    if env_runtime:
+        if env_runtime not in SUPPORTED_RUNTIMES:
+            print(
+                f"Warning: MDIFY_CONTAINER_RUNTIME='{env_runtime}' is not supported. "
+                f"Supported: {', '.join(SUPPORTED_RUNTIMES)}",
+                file=sys.stderr,
+            )
+        else:
+            runtime_path = shutil.which(env_runtime)
+            if runtime_path:
+                if explicit:
+                    print(f"Using runtime from MDIFY_CONTAINER_RUNTIME: {env_runtime}")
+                return runtime_path
+            else:
+                print(
+                    f"Warning: MDIFY_CONTAINER_RUNTIME='{env_runtime}' specified but not found in PATH",
+                    file=sys.stderr,
+                )
+
+    # Determine runtime priority based on OS
+    is_macos = platform.system() == "Darwin"
+    if is_macos:
+        runtime_priority = MACOS_RUNTIMES_PRIORITY
         if explicit:
+            print(f"Detected macOS: checking for native container tools...")
+    else:
+        runtime_priority = OTHER_RUNTIMES_PRIORITY
+
+    # Try each runtime in priority order
+    found_but_not_running = []
+    for runtime_name in runtime_priority:
+        runtime_path = shutil.which(runtime_name)
+        if runtime_path:
+            # Check if daemon is running
+            if is_daemon_running(runtime_path):
+                if explicit:
+                    print(f"Using container runtime: {runtime_name}")
+                return runtime_path
+            else:
+                found_but_not_running.append((runtime_name, runtime_path))
+
+    # If we found tools but none are running, warn and ask user to start one
+    if found_but_not_running:
+        print(
+            f"\nWarning: Found container runtime(s) but daemon is not running:",
+            file=sys.stderr,
+        )
+        for runtime_name, runtime_path in found_but_not_running:
+            print(f"  - {runtime_name} ({runtime_path})", file=sys.stderr)
+        print(
+            "\nPlease start one of these tools before running mdify.",
+            file=sys.stderr,
+        )
+        if is_macos:
             print(
-                f"Warning: {preferred} not found, using {alternative}", file=sys.stderr
+                "  macOS tip: Start OrbStack, Colima, or Podman Desktop application",
+                file=sys.stderr,
             )
-        return runtime_path
+        return None
 
     return None
 
@@ -195,6 +281,27 @@ def check_image_exists(runtime: str, image: str) -> bool:
         True if image exists locally.
     """
     try:
+        runtime_name = os.path.basename(runtime)
+        
+        # Apple Container uses 'image list' command (two words)
+        if runtime_name == "container":
+            result = subprocess.run(
+                [runtime, "image", "list", "--format", "json"],
+                capture_output=True,
+                check=False,
+            )
+            if result.returncode == 0 and result.stdout:
+                try:
+                    images = json.loads(result.stdout.decode())
+                    # Check if image exists in the list
+                    for img in images:
+                        if img.get("name") == image or image in img.get("repoTags", []):
+                            return True
+                except json.JSONDecodeError:
+                    pass
+            return False
+        
+        # Docker/Podman/OrbStack/Colima use standard 'image inspect'
         result = subprocess.run(
             [runtime, "image", "inspect", image],
             capture_output=True,
@@ -221,6 +328,18 @@ def pull_image(runtime: str, image: str, quiet: bool = False) -> bool:
         print(f"Pulling image: {image}")
 
     try:
+        runtime_name = os.path.basename(runtime)
+        
+        # Apple Container uses 'image pull' command (two words)
+        if runtime_name == "container":
+            result = subprocess.run(
+                [runtime, "image", "pull", image],
+                capture_output=quiet,
+                check=False,
+            )
+            return result.returncode == 0
+        
+        # Docker/Podman/OrbStack/Colima use standard 'pull'
         result = subprocess.run(
             [runtime, "pull", image],
             capture_output=quiet,
@@ -302,7 +421,7 @@ def get_free_space(path: str) -> int:
 
 def get_storage_root(runtime: str) -> Optional[str]:
     """
-    Get the storage root directory for Docker or Podman.
+    Get the storage root directory for Docker, Podman, OrbStack, or Colima.
 
     Args:
         runtime: Path to container runtime executable
@@ -331,6 +450,18 @@ def get_storage_root(runtime: str) -> Optional[str]:
             if result.stdout:
                 info = json.loads(result.stdout.decode())
                 return info.get("store", {}).get("graphRoot")
+        elif runtime_name == "orbstack":
+            # OrbStack stores containers in ~/.orbstack
+            home = os.path.expanduser("~")
+            return os.path.join(home, ".orbstack")
+        elif runtime_name == "colima":
+            # Colima stores containers in ~/.colima
+            home = os.path.expanduser("~")
+            return os.path.join(home, ".colima")
+        elif runtime_name == "container":
+            # Apple Container stores data in Application Support
+            home = os.path.expanduser("~")
+            return os.path.join(home, "Library", "Application Support", "com.apple.container")
         return None
     except (OSError, json.JSONDecodeError):
         return None
@@ -390,8 +521,8 @@ class Spinner:
         self.running = False
         if self.thread:
             self.thread.join(timeout=0.5)
-        # Clear the spinner line
-        print(f"\r{' ' * 80}\r", end="", flush=True)
+        # Clear the spinner line with enough spaces to cover the longest possible line
+        print(f"\r{' ' * 120}\r", end="", flush=True)
 
 
 # =============================================================================
@@ -639,6 +770,7 @@ Examples:
 
 def main() -> int:
     """Main entry point for the CLI."""
+    print(f"mdify v{__version__}", file=sys.stderr)
     args = parse_args()
 
     # Handle --check-update flag
@@ -660,15 +792,14 @@ def main() -> int:
         return 1
 
     # Detect container runtime
-    preferred = args.runtime if args.runtime else "docker"
+    # If --runtime is specified, treat as explicit user choice
     explicit = args.runtime is not None
-    runtime = detect_runtime(preferred, explicit=explicit)
+    runtime = detect_runtime(preferred=args.runtime, explicit=explicit)
     if runtime is None:
         print(
             f"Error: Container runtime not found ({', '.join(SUPPORTED_RUNTIMES)})",
             file=sys.stderr,
         )
-        print("Please install Docker or Podman to use mdify.", file=sys.stderr)
         return 2
 
     # Handle image pull policy
@@ -752,7 +883,8 @@ def main() -> int:
             return 1
     elif args.pull == "never" and not image_exists:
         print(f"Error: Image not found locally: {image}", file=sys.stderr)
-        print(f"Run with --pull=missing or pull manually: {preferred} pull {image}")
+        runtime_name = os.path.basename(runtime)
+        print(f"Run with --pull=missing or pull manually: {runtime_name} pull {image}")
         return 1
 
     # Resolve paths (use absolute() as fallback if resolve() fails due to permissions)
@@ -786,6 +918,8 @@ def main() -> int:
 
     if not args.quiet:
         print(f"Found {total_files} file(s) to convert ({format_size(total_size)})")
+        print(f"Source: {input_path.resolve()}")
+        print(f"Output: {output_dir.resolve()}")
         print(f"Using runtime: {runtime}")
         print(f"Using image: {image}")
         print()
@@ -848,6 +982,7 @@ def main() -> int:
                     )
                     elapsed = time.time() - start_time
 
+                    # Stop spinner before any output
                     if not args.quiet:
                         spinner.stop()
 
@@ -870,12 +1005,27 @@ def main() -> int:
                 except Exception as e:
                     elapsed = time.time() - start_time
                     failed_count += 1
+                    # Stop spinner before printing error
                     if not args.quiet:
                         spinner.stop()
+                    
+                    # Check if container is still healthy
+                    error_msg = str(e)
+                    if "Connection refused" in error_msg or "Connection aborted" in error_msg or "RemoteDisconnected" in error_msg:
+                        if not container.is_ready():
+                            if not args.quiet:
+                                print(
+                                    f"{progress} {input_file.name} ✗ ({format_duration(elapsed)})"
+                                )
+                                print(f"    Error: Container crashed (file may be too complex or large)", file=sys.stderr)
+                                print(f"    Stopping remaining conversions", file=sys.stderr)
+                            break
+                    
+                    if not args.quiet:
                         print(
                             f"{progress} {input_file.name} ✗ ({format_duration(elapsed)})"
                         )
-                        print(f"    Error: {str(e)}", file=sys.stderr)
+                        print(f"    Error: {error_msg}", file=sys.stderr)
 
             total_elapsed = time.time() - conversion_start
 

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/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.dist-info → mdify_cli-2.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdify-cli
-Version: 2.5.0
+Version: 2.10.0
 Summary: Convert PDFs and document images into structured Markdown for LLM workflows
 Author: tiroq
 License-Expression: MIT
@@ -42,7 +42,10 @@ A lightweight CLI for converting documents to Markdown. The CLI is fast to insta
 ## Requirements
 
 - **Python 3.8+**
-- **Docker** or **Podman** (for document conversion)
+- **Docker**, **Podman**, or native macOS container tools (for document conversion)
+  - On macOS: Supports Apple Container (macOS 26+), OrbStack, Colima, Podman, or Docker Desktop
+  - On Linux: Docker or Podman
+  - Auto-detects available tools
 
 ## Installation
 
@@ -56,6 +59,13 @@ pipx install mdify-cli
 
 Restart your terminal after installation.
 
+For containerized document conversion, install one of these (or use Docker Desktop):
+- **Apple Container** (macOS 26+): Download from https://github.com/apple/container/releases
+- **OrbStack** (recommended): `brew install orbstack`
+- **Colima**: `brew install colima && colima start`
+- **Podman**: `brew install podman && podman machine init && podman machine start`
+- **Docker Desktop**: Available at https://www.docker.com/products/docker-desktop
+
 ### Linux
 
 ```bash
@@ -142,13 +152,50 @@ The first conversion takes longer (~30-60s) as the container loads ML models int
 | `-m, --mask` | ⚠️ **Deprecated**: PII masking not supported in current version |
 | `--gpu` | Use GPU-accelerated container (requires NVIDIA GPU and nvidia-container-toolkit) |
 | `--port PORT` | Container port (default: 5001) |
-| `--runtime RUNTIME` | Container runtime: docker or podman (auto-detected) |
+| `--runtime RUNTIME` | Container runtime: docker, podman, orbstack, colima, or container (auto-detected) |
 | `--image IMAGE` | Custom container image (default: ghcr.io/docling-project/docling-serve-cpu:main) |
 | `--pull POLICY` | Image pull policy: always, missing, never (default: missing) |
 | `--check-update` | Check for available updates and exit |
 | `--version` | Show version and exit |
 
-### Flat Mode
+### Container Runtime Selection
+
+mdify automatically detects and uses the best available container runtime. The detection order differs by platform:
+
+**macOS (recommended):**
+1. Apple Container (native, macOS 26+ required)
+2. OrbStack (lightweight, fast)
+3. Colima (open-source alternative)
+4. Podman (via Podman machine)
+5. Docker Desktop (full Docker)
+
+**Linux:**
+1. Docker
+2. Podman
+
+**Override runtime:**
+Use the `MDIFY_CONTAINER_RUNTIME` environment variable to force a specific runtime:
+
+```bash
+export MDIFY_CONTAINER_RUNTIME=orbstack
+mdify document.pdf
+```
+
+Or inline:
+```bash
+MDIFY_CONTAINER_RUNTIME=colima mdify document.pdf
+```
+
+**Supported values:** `docker`, `podman`, `orbstack`, `colima`, `container`
+
+If the selected runtime is installed but not running, mdify will display a helpful warning:
+```
+Warning: Found container runtime(s) but daemon is not running:
+  - orbstack (/opt/homebrew/bin/orbstack)
+
+Please start one of these tools before running mdify.
+macOS tip: Start OrbStack, Colima, or Podman Desktop application
+```
 
 With `--flat`, all output files are placed directly in the output directory. Directory paths are incorporated into filenames to prevent collisions:
 

mdify_cli-2.10.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+assets/mdify.png,sha256=qUj7WXWqNwpI2KNXOW79XJwqFqa-UI0JEkmt1mmy4Rg,1820418
+mdify/__init__.py,sha256=CjafoKZ-RjxyPtnUKVPmPjquU0FlfXDBkDDWZWb1ryw,91
+mdify/__main__.py,sha256=bhpJ00co6MfaVOdH4XLoW04NtLYDa_oJK7ODzfLrn9M,143
+mdify/cli.py,sha256=ZQMirATkanV0l8v0-A000uXPy7BaT5BPbVFSNSnpLJM,34817
+mdify/container.py,sha256=tkk0nv7EquL-rKUY4nkS_yGITb7mqw8B7eEfuqaeVrg,5239
+mdify/docling_client.py,sha256=xuQR6sC1v3EPloOSwExoHCqT4uUxE8myYq-Yeby3C2I,7975
+mdify_cli-2.10.0.dist-info/licenses/LICENSE,sha256=NWM66Uv-XuSMKaU-gaPmvfyk4WgE6zcIPr78wyg6GAo,1065
+mdify_cli-2.10.0.dist-info/METADATA,sha256=c2dtC7VEMeSqPhgbmQBLEM5N6zOkIXfWDPocCz9Ye8E,9623
+mdify_cli-2.10.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mdify_cli-2.10.0.dist-info/entry_points.txt,sha256=0Xki8f5lADQUtwdt6Eq_FEaieI6Byhk8UE7BuDhChMg,41
+mdify_cli-2.10.0.dist-info/top_level.txt,sha256=qltzf7h8owHq7dxCdfCkSHY8gT21hn1_E8P-VWS_OKM,6
+mdify_cli-2.10.0.dist-info/RECORD,,

mdify_cli-2.5.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-assets/mdify.png,sha256=qUj7WXWqNwpI2KNXOW79XJwqFqa-UI0JEkmt1mmy4Rg,1820418
-mdify/__init__.py,sha256=lH-hnX0KOG9_zJ_QZ-A_kQFPYghziohhpm7nmxVZc7w,90
-mdify/__main__.py,sha256=bhpJ00co6MfaVOdH4XLoW04NtLYDa_oJK7ODzfLrn9M,143
-mdify/cli.py,sha256=LqIibolYSKGCNYqxuIyFnvPkjJyNlXvfWeKaSaoOrqo,28542
-mdify/container.py,sha256=2oh9NyvFr9lCRb2YYpM_qKP3PPmAin0DbxvNP3m69jw,4158
-mdify/docling_client.py,sha256=_9qjL5yOOeJahOg6an2P6Iii1xkeR6wmNJZG4Q6NRkk,6553
-mdify_cli-2.5.0.dist-info/licenses/LICENSE,sha256=NWM66Uv-XuSMKaU-gaPmvfyk4WgE6zcIPr78wyg6GAo,1065
-mdify_cli-2.5.0.dist-info/METADATA,sha256=egwIWB2tV9F41fcUf3RvfszEJGb--AQVDN3ybI1FFt0,7923
-mdify_cli-2.5.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mdify_cli-2.5.0.dist-info/entry_points.txt,sha256=0Xki8f5lADQUtwdt6Eq_FEaieI6Byhk8UE7BuDhChMg,41
-mdify_cli-2.5.0.dist-info/top_level.txt,sha256=qltzf7h8owHq7dxCdfCkSHY8gT21hn1_E8P-VWS_OKM,6
-mdify_cli-2.5.0.dist-info/RECORD,,