mdify-cli 2.11.7__py3-none-any.whl → 2.11.9__py3-none-any.whl

mdify/__init__.py

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

mdify/cli.py

@@ -41,6 +41,140 @@ OTHER_RUNTIMES_PRIORITY = ("docker", "podman")
 # Debug mode
 DEBUG = os.environ.get("MDIFY_DEBUG", "").lower() in ("1", "true", "yes")
 
+# Resource profiles for container execution
+RESOURCE_PROFILES = {
+    "minimal": {"cpus": 4, "memory": "8g", "description": "Small PDFs, text-only documents"},
+    "default": {"cpus": 6, "memory": "12g", "description": "Large PDFs, OCR, tables (recommended)"},
+    "heavy": {"cpus": 8, "memory": "16g", "description": "Batch processing, very large files"},
+}
+
+
+def get_available_memory_gb() -> float:
+    """Get available system memory in GB.
+    
+    Returns:
+        Available memory in GB, or -1 if unable to determine
+    """
+    system = platform.system()
+    try:
+        if system == "Darwin":  # macOS
+            # Get page size
+            result = subprocess.run(["pagesize"], capture_output=True, text=True, check=True)
+            page_size = int(result.stdout.strip())
+            
+            # Get memory stats
+            result = subprocess.run(["vm_stat"], capture_output=True, text=True, check=True)
+            free_pages = 0
+            inactive_pages = 0
+            speculative_pages = 0
+            
+            for line in result.stdout.split("\n"):
+                if "Pages free" in line:
+                    free_pages = int(line.split(":")[1].strip().rstrip("."))
+                elif "Pages inactive" in line:
+                    inactive_pages = int(line.split(":")[1].strip().rstrip("."))
+                elif "Pages speculative" in line:
+                    speculative_pages = int(line.split(":")[1].strip().rstrip("."))
+            
+            # Available memory = free + inactive + speculative
+            available_pages = free_pages + inactive_pages + speculative_pages
+            available_bytes = available_pages * page_size
+            return available_bytes / (1024**3)  # Convert to GB
+        elif system == "Linux":
+            # Read from /proc/meminfo
+            with open("/proc/meminfo") as f:
+                for line in f:
+                    if line.startswith("MemAvailable:"):
+                        kb = int(line.split()[1])
+                        return kb / (1024**2)  # Convert to GB
+    except Exception:
+        pass
+    
+    return -1
+
+
+def parse_memory_string(mem_str: str) -> float:
+    """Parse memory string (e.g., '12g', '8192m') to GB.
+    
+    Args:
+        mem_str: Memory string with unit (g, m, gb, mb)
+        
+    Returns:
+        Memory in GB
+    """
+    mem_str = mem_str.lower().strip()
+    
+    if mem_str.endswith("gb"):
+        return float(mem_str[:-2])
+    elif mem_str.endswith("g"):
+        return float(mem_str[:-1])
+    elif mem_str.endswith("mb"):
+        return float(mem_str[:-2]) / 1024
+    elif mem_str.endswith("m"):
+        return float(mem_str[:-1]) / 1024
+    else:
+        raise ValueError(f"Invalid memory format: {mem_str}")
+
+
+def validate_memory_availability(
+    required_gb: float,
+    profile_name: str = "default",
+    suggest_profile: Optional[str] = None,
+) -> tuple[bool, str]:
+    """Check if system has sufficient available memory.
+    
+    Args:
+        required_gb: Required memory in GB
+        profile_name: Name of current profile being used
+        suggest_profile: Name of smaller profile to suggest (auto-detected if None)
+        
+    Returns:
+        Tuple of (is_sufficient, error_message)
+    """
+    available_gb = get_available_memory_gb()
+    
+    if available_gb < 0:
+        # Unable to determine, allow startup with warning
+        return True, ""
+    
+    if available_gb < required_gb:
+        # Determine which smaller profile to suggest
+        if suggest_profile is None:
+            if profile_name == "heavy":
+                suggest_profile = "default"
+            elif profile_name == "default":
+                suggest_profile = "minimal"
+            else:
+                suggest_profile = None  # Already on minimal
+        
+        error = (
+            f"Insufficient memory available for container startup.\n"
+            f"  Current profile: {profile_name}\n"
+            f"  Required: {required_gb:.1f} GB\n"
+            f"  Available: {available_gb:.1f} GB\n"
+            f"  Short by: {required_gb - available_gb:.1f} GB\n\n"
+        )
+        
+        if suggest_profile:
+            suggested = RESOURCE_PROFILES[suggest_profile]
+            error += (
+                f"Suggested solutions:\n"
+                f"  1. Close other applications to free up memory\n"
+                f"  2. Use a smaller profile: --profile {suggest_profile} "
+                f"({suggested['cpus']} CPUs, {suggested['memory']} memory)\n"
+                f"  3. Skip memory check: --skip-memory-check (not recommended)"
+            )
+        else:
+            error += (
+                f"Suggested solutions:\n"
+                f"  1. Close other applications to free up memory\n"
+                f"  2. Skip memory check: --skip-memory-check (not recommended)"
+            )
+        
+        return False, error
+    
+    return True, ""
+
 
 # =============================================================================
 # Update checking functions
@@ -756,7 +890,28 @@ Examples:
         "--memory",
         type=str,
         default=None,
-        help="Container memory limit (e.g., 2g, 512m, 4096m). Default: no limit",
+        help="Container memory limit (e.g., 2g, 512m, 4096m). Overrides --profile setting",
+    )
+
+    parser.add_argument(
+        "--cpus",
+        type=int,
+        default=None,
+        help="Number of CPUs to allocate to container. Overrides --profile setting",
+    )
+
+    parser.add_argument(
+        "--profile",
+        type=str,
+        choices=["minimal", "default", "heavy"],
+        default="default",
+        help="Resource profile for container: minimal (4 CPU, 8GB), default (6 CPU, 12GB), heavy (8 CPU, 16GB)",
+    )
+
+    parser.add_argument(
+        "--skip-memory-check",
+        action="store_true",
+        help="Skip memory availability validation (not recommended)",
     )
 
     # Utility options
@@ -959,7 +1114,27 @@ def main() -> int:
 
     try:
         if not args.quiet:
-            print(f"Starting docling-serve container...")
+            print(f"Starting docling-serve container...\n")
+
+        # Apply resource profile
+        profile = RESOURCE_PROFILES[args.profile]
+        cpus = args.cpus if args.cpus is not None else profile["cpus"]
+        memory = args.memory if args.memory is not None else profile["memory"]
+        
+        # Validate memory availability unless skipped
+        if not args.skip_memory_check:
+            required_gb = parse_memory_string(memory)
+            is_sufficient, error_msg = validate_memory_availability(
+                required_gb, profile_name=args.profile
+            )
+            if not is_sufficient:
+                print(f"Error: {error_msg}", file=sys.stderr)
+                return 1
+        
+        if not args.quiet:
+            print(f"Resource profile: {args.profile} ({cpus} CPUs, {memory} memory)")
+            if args.cpus or args.memory:
+                print("  (customized via command-line arguments)")
             print()
 
         with DoclingContainer(
@@ -968,7 +1143,8 @@ def main() -> int:
             args.port,
             timeout=timeout,
             keep_container=DEBUG,
-            memory=args.memory,
+            memory=memory,
+            cpus=cpus,
         ) as container:
             # Convert files
             conversion_start = time.time()

mdify/container.py

@@ -28,6 +28,7 @@ class DoclingContainer:
         timeout: int = 1200,
         keep_container: bool = False,
         memory: Optional[str] = None,
+        cpus: Optional[int] = None,
     ):
         """Initialize container manager.
 
@@ -38,6 +39,7 @@ class DoclingContainer:
             timeout: Conversion timeout in seconds (default: 1200)
             keep_container: If True, do not auto-remove container (preserve logs)
             memory: Memory limit (e.g., "2g", "512m"). None for no limit.
+            cpus: Number of CPUs to allocate. None for no limit.
         """
         self.runtime = runtime
         self.image = image
@@ -45,6 +47,7 @@ class DoclingContainer:
         self.timeout = timeout
         self.keep_container = keep_container
         self.memory = memory
+        self.cpus = cpus
         self.container_name = f"mdify-serve-{uuid.uuid4().hex[:8]}"
         self.container_id: Optional[str] = None
 
@@ -114,7 +117,11 @@ class DoclingContainer:
         if not self.keep_container:
             cmd.insert(3, "--rm")  # Auto-remove on stop
         
-        # Add memory limit if specified
+        # Add resource limits if specified
+        if self.cpus:
+            cmd.insert(3, str(self.cpus))
+            cmd.insert(3, "--cpus")
+        
         if self.memory:
             cmd.insert(3, self.memory)
             cmd.insert(3, "-m")

{mdify_cli-2.11.7.dist-info → mdify_cli-2.11.9.dist-info}/METADATA

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

mdify_cli-2.11.9.dist-info/RECORD

@@ -0,0 +1,12 @@
+assets/mdify.png,sha256=qUj7WXWqNwpI2KNXOW79XJwqFqa-UI0JEkmt1mmy4Rg,1820418
+mdify/__init__.py,sha256=x2PxT1laVq9WFwgXBDy1TJ_qCOBN4cxlmLYbSBcb7qA,91
+mdify/__main__.py,sha256=bhpJ00co6MfaVOdH4XLoW04NtLYDa_oJK7ODzfLrn9M,143
+mdify/cli.py,sha256=Mv3ClwC84fkorZgwM1IqGMvZ0-hT_V77qhHo2p0ueCU,49638
+mdify/container.py,sha256=ARdFs-TOSh5vHGtBJ0CppfpZFaiprIuRdQ5wDH0NfrY,8377
+mdify/docling_client.py,sha256=xuQR6sC1v3EPloOSwExoHCqT4uUxE8myYq-Yeby3C2I,7975
+mdify_cli-2.11.9.dist-info/licenses/LICENSE,sha256=NWM66Uv-XuSMKaU-gaPmvfyk4WgE6zcIPr78wyg6GAo,1065
+mdify_cli-2.11.9.dist-info/METADATA,sha256=NHwtbgGo2CAPqZIOT7ebPk5mTwsmxRBo5pg0l71xenE,9623
+mdify_cli-2.11.9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mdify_cli-2.11.9.dist-info/entry_points.txt,sha256=0Xki8f5lADQUtwdt6Eq_FEaieI6Byhk8UE7BuDhChMg,41
+mdify_cli-2.11.9.dist-info/top_level.txt,sha256=qltzf7h8owHq7dxCdfCkSHY8gT21hn1_E8P-VWS_OKM,6
+mdify_cli-2.11.9.dist-info/RECORD,,

mdify_cli-2.11.7.dist-info/RECORD

@@ -1,12 +0,0 @@
-assets/mdify.png,sha256=qUj7WXWqNwpI2KNXOW79XJwqFqa-UI0JEkmt1mmy4Rg,1820418
-mdify/__init__.py,sha256=QROoTzZ7DPEkOz5xppOPbt6mrhz2S9R4qPalnU_JuXY,91
-mdify/__main__.py,sha256=bhpJ00co6MfaVOdH4XLoW04NtLYDa_oJK7ODzfLrn9M,143
-mdify/cli.py,sha256=Bq6E-U-TMBDPPduHz6pOfFcVHPGSOhrwsvxVOTnA8KA,43261
-mdify/container.py,sha256=TEVfWXVQoF8OdMX3K_X460K4sJ59ysVOOy5z5E1RH84,8139
-mdify/docling_client.py,sha256=xuQR6sC1v3EPloOSwExoHCqT4uUxE8myYq-Yeby3C2I,7975
-mdify_cli-2.11.7.dist-info/licenses/LICENSE,sha256=NWM66Uv-XuSMKaU-gaPmvfyk4WgE6zcIPr78wyg6GAo,1065
-mdify_cli-2.11.7.dist-info/METADATA,sha256=ksvj2cFwDeDb36tYVfUe3YpHp306Mt4QyON62voR9s0,9623
-mdify_cli-2.11.7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mdify_cli-2.11.7.dist-info/entry_points.txt,sha256=0Xki8f5lADQUtwdt6Eq_FEaieI6Byhk8UE7BuDhChMg,41
-mdify_cli-2.11.7.dist-info/top_level.txt,sha256=qltzf7h8owHq7dxCdfCkSHY8gT21hn1_E8P-VWS_OKM,6
-mdify_cli-2.11.7.dist-info/RECORD,,