mdify-cli 3.0.3__tar.gz → 3.0.5__tar.gz

{mdify_cli-3.0.3 → mdify_cli-3.0.5}/PKG-INFO

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

{mdify_cli-3.0.3 → mdify_cli-3.0.5}/mdify/__init__.py

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

{mdify_cli-3.0.3 → mdify_cli-3.0.5}/mdify/cli.py

@@ -1238,6 +1238,12 @@ def main_async_remote(args) -> int:
             successful = 0
             failed = 0
             
+            def is_connection_error(exc: Exception) -> bool:
+                if isinstance(exc, SSHConnectionError):
+                    return True
+                msg = str(exc).lower()
+                return "broken pipe" in msg or "connection closed" in msg
+            
             try:
                 for idx, input_file in enumerate(files_to_convert, 1):
                     if not args.quiet:
@@ -1246,155 +1252,169 @@ def main_async_remote(args) -> int:
                             file=sys.stderr,
                         )
                     
-                    try:
-                        # Upload file
-                        remote_file_path = f"{work_dir}/{input_file.name}"
-                        
-                        if not args.quiet:
-                            print(f"  {color.cyan('Uploading to')} {remote_file_path}...", file=sys.stderr)
-                        
-                        await transfer_manager.upload_file(
-                            local_path=str(input_file),
-                            remote_path=remote_file_path,
-                            overwrite=True,
-                            compress=False,
-                        )
-                        
-                        if not args.quiet:
-                            print(f"  {color.green('✓ Upload complete')}", file=sys.stderr)
-                        
-                        # Convert via remote container
-                        if not args.quiet:
-                            print(f"  {color.cyan('Converting via remote container')}...", file=sys.stderr)
-                        
-                        # Determine output path
-                        output_dir = Path(args.out_dir)
-                        
-                        # Preserve directory structure if not flat
-                        if not args.flat and input_path.is_dir():
-                            try:
-                                rel_path = input_file.relative_to(input_path)
-                                output_subdir = output_dir / rel_path.parent
-                            except ValueError:
-                                output_subdir = output_dir
-                        else:
-                            output_subdir = output_dir
-                        
-                        output_subdir.mkdir(parents=True, exist_ok=True)
-                        output_file = output_subdir / f"{input_file.stem}.md"
-                        
-                        # Check if output exists and skip if not overwrite
-                        if output_file.exists() and not args.overwrite:
-                            if not args.quiet:
-                                print(
-                                    f"  {color.yellow('⊘ Skipped:')} {output_file} already exists (use --overwrite to replace)",
-                                    file=sys.stderr,
-                                )
-                            continue
-                        
-                        # Convert using remote container's HTTP API
-                        # The docling-serve API expects:
-                        # - Endpoint: /v1/convert/file
-                        # - Method: POST with multipart/form-data
-                        # - File field: "files" (note the plural)
-                        # - Additional fields: to_formats=md, do_ocr=true
-                        remote_output_path = f"{work_dir}/{input_file.stem}.md"
-                        
-                        # Build conversion command on remote - use -F for multipart form data
-                        convert_cmd = (
-                            f"curl -X POST "
-                            f"-F 'files=@{remote_file_path}' "
-                            f"-F 'to_formats=md' "
-                            f"-F 'do_ocr=true' "
-                        )
-                        if args.mask:
-                            convert_cmd += f"-F 'mask=true' "
-                        convert_cmd += f"http://localhost:{args.port}/v1/convert/file"
-                        
-                        stdout, stderr, code = await ssh_client.run_command(convert_cmd, timeout=timeout)
-                        
-                        if code != 0:
-                            print(f"  ✗ Conversion failed (curl error code {code}): {stderr}", file=sys.stderr)
-                            failed += 1
-                            continue
-                        
-                        # Parse JSON response to extract markdown content
+                    attempt = 0
+                    while True:
                         try:
-                            response_data = json.loads(stdout)
+                            # Upload file
+                            remote_file_path = f"{work_dir}/{input_file.name}"
                             
-                            # Extract content from response structure
-                            # Actual format: {"document": {"md_content": "..."}, "status": "success"}
-                            if "document" in response_data:
-                                document = response_data["document"]
-                                if "md_content" in document and document["md_content"]:
-                                    markdown_content = document["md_content"]
-                                elif "text_content" in document and document["text_content"]:
-                                    markdown_content = document["text_content"]
-                                else:
-                                    # Fallback - use whole document
-                                    markdown_content = json.dumps(document, indent=2)
+                            if not args.quiet:
+                                print(f"  {color.cyan('Uploading to')} {remote_file_path}...", file=sys.stderr)
+                            
+                            await transfer_manager.upload_file(
+                                local_path=str(input_file),
+                                remote_path=remote_file_path,
+                                overwrite=True,
+                                compress=False,
+                            )
+                            
+                            if not args.quiet:
+                                print(f"  {color.green('✓ Upload complete')}", file=sys.stderr)
+                            
+                            # Convert via remote container
+                            if not args.quiet:
+                                print(f"  {color.cyan('Converting via remote container')}...", file=sys.stderr)
+                            
+                            # Determine output path
+                            output_dir = Path(args.out_dir)
+                            
+                            # Preserve directory structure if not flat
+                            if not args.flat and input_path.is_dir():
+                                try:
+                                    rel_path = input_file.relative_to(input_path)
+                                    output_subdir = output_dir / rel_path.parent
+                                except ValueError:
+                                    output_subdir = output_dir
                             else:
-                                # Legacy format fallback
-                                if "results" in response_data and response_data["results"]:
-                                    result = response_data["results"][0]
-                                    if "content" in result:
-                                        content = result["content"]
-                                        if isinstance(content, dict) and "markdown" in content:
-                                            markdown_content = content["markdown"]
-                                        elif isinstance(content, str):
-                                            markdown_content = content
-                                        else:
-                                            markdown_content = str(content)
+                                output_subdir = output_dir
+                            
+                            output_subdir.mkdir(parents=True, exist_ok=True)
+                            output_file = output_subdir / f"{input_file.stem}.md"
+                            
+                            # Check if output exists and skip if not overwrite
+                            if output_file.exists() and not args.overwrite:
+                                if not args.quiet:
+                                    print(
+                                        f"  {color.yellow('⊘ Skipped:')} {output_file} already exists (use --overwrite to replace)",
+                                        file=sys.stderr,
+                                    )
+                                break
+                            
+                            # Convert using remote container's HTTP API
+                            # The docling-serve API expects:
+                            # - Endpoint: /v1/convert/file
+                            # - Method: POST with multipart/form-data
+                            # - File field: "files" (note the plural)
+                            # - Additional fields: to_formats=md, do_ocr=true
+                            remote_output_path = f"{work_dir}/{input_file.stem}.md"
+                            
+                            # Build conversion command on remote - use -F for multipart form data
+                            convert_cmd = (
+                                f"curl -X POST "
+                                f"-F 'files=@{remote_file_path}' "
+                                f"-F 'to_formats=md' "
+                                f"-F 'do_ocr=true' "
+                            )
+                            if args.mask:
+                                convert_cmd += f"-F 'mask=true' "
+                            convert_cmd += f"http://localhost:{args.port}/v1/convert/file"
+                            
+                            stdout, stderr, code = await ssh_client.run_command(convert_cmd, timeout=timeout)
+                            
+                            if code != 0:
+                                print(f"  ✗ Conversion failed (curl error code {code}): {stderr}", file=sys.stderr)
+                                failed += 1
+                                break
+                            
+                            # Parse JSON response to extract markdown content
+                            try:
+                                response_data = json.loads(stdout)
+                                
+                                # Extract content from response structure
+                                # Actual format: {"document": {"md_content": "..."}, "status": "success"}
+                                if "document" in response_data:
+                                    document = response_data["document"]
+                                    if "md_content" in document and document["md_content"]:
+                                        markdown_content = document["md_content"]
+                                    elif "text_content" in document and document["text_content"]:
+                                        markdown_content = document["text_content"]
                                     else:
-                                        markdown_content = str(result)
+                                        # Fallback - use whole document
+                                        markdown_content = json.dumps(document, indent=2)
                                 else:
-                                    # Ultimate fallback
-                                    markdown_content = stdout
+                                    # Legacy format fallback
+                                    if "results" in response_data and response_data["results"]:
+                                        result = response_data["results"][0]
+                                        if "content" in result:
+                                            content = result["content"]
+                                            if isinstance(content, dict) and "markdown" in content:
+                                                markdown_content = content["markdown"]
+                                            elif isinstance(content, str):
+                                                markdown_content = content
+                                            else:
+                                                markdown_content = str(content)
+                                        else:
+                                            markdown_content = str(result)
+                                    else:
+                                        # Ultimate fallback
+                                        markdown_content = stdout
+                                
+                                # Write markdown content to remote file
+                                write_cmd = f"cat > {remote_output_path} << 'MDIFY_EOF'\n{markdown_content}\nMDIFY_EOF"
+                                _, _, write_code = await ssh_client.run_command(write_cmd, timeout=30)
+                                
+                                if write_code != 0:
+                                    print(f"  ✗ Failed to write markdown output", file=sys.stderr)
+                                    failed += 1
+                                    break
+                                
+                            except (json.JSONDecodeError, KeyError, IndexError) as e:
+                                print(f"  ✗ Failed to parse conversion response: {e}", file=sys.stderr)
+                                if DEBUG:
+                                    print(f"  Response: {stdout[:500]}", file=sys.stderr)
+                                failed += 1
+                                break
                             
-                            # Write markdown content to remote file
-                            write_cmd = f"cat > {remote_output_path} << 'MDIFY_EOF'\n{markdown_content}\nMDIFY_EOF"
-                            _, _, write_code = await ssh_client.run_command(write_cmd, timeout=30)
+                            if not args.quiet:
+                                print(f"  ✓ Conversion complete", file=sys.stderr)
                             
-                            if write_code != 0:
-                                print(f"  ✗ Failed to write markdown output", file=sys.stderr)
-                                failed += 1
+                            # Download result
+                            if not args.quiet:
+                                print(f"  Downloading result to {output_file}...", file=sys.stderr)
+                            
+                            await transfer_manager.download_file(
+                                remote_path=remote_output_path,
+                                local_path=str(output_file),
+                                overwrite=True,
+                            )
+                            
+                            if not args.quiet:
+                                print(f"  ✓ Download complete: {output_file}", file=sys.stderr)
+                            
+                            successful += 1
+                            
+                            # Cleanup remote files
+                            await ssh_client.run_command(f"rm -f {remote_file_path} {remote_output_path}")
+                            
+                            break
+                        except Exception as e:
+                            if is_connection_error(e) and attempt == 0:
+                                attempt += 1
+                                if not args.quiet:
+                                    print("  ↻ Connection lost. Reconnecting...", file=sys.stderr)
+                                try:
+                                    await ssh_client.disconnect()
+                                except Exception:
+                                    pass
+                                await ssh_client.connect()
                                 continue
                             
-                        except (json.JSONDecodeError, KeyError, IndexError) as e:
-                            print(f"  ✗ Failed to parse conversion response: {e}", file=sys.stderr)
+                            print(f"  ✗ Failed: {e}", file=sys.stderr)
                             if DEBUG:
-                                print(f"  Response: {stdout[:500]}", file=sys.stderr)
+                                import traceback
+                                traceback.print_exc(file=sys.stderr)
                             failed += 1
-                            continue
-                        
-                        if not args.quiet:
-                            print(f"  ✓ Conversion complete", file=sys.stderr)
-                        
-                        # Download result
-                        if not args.quiet:
-                            print(f"  Downloading result to {output_file}...", file=sys.stderr)
-                        
-                        await transfer_manager.download_file(
-                            remote_path=remote_output_path,
-                            local_path=str(output_file),
-                            overwrite=True,
-                        )
-                        
-                        if not args.quiet:
-                            print(f"  ✓ Download complete: {output_file}", file=sys.stderr)
-                        
-                        successful += 1
-                        
-                        # Cleanup remote files
-                        await ssh_client.run_command(f"rm -f {remote_file_path} {remote_output_path}")
-                        
-                    except Exception as e:
-                        print(f"  ✗ Failed: {e}", file=sys.stderr)
-                        if DEBUG:
-                            import traceback
-                            traceback.print_exc(file=sys.stderr)
-                        failed += 1
-                        continue
+                            break
             
             finally:
                 # Stop and remove container

{mdify_cli-3.0.3 → mdify_cli-3.0.5}/mdify/ssh/client.py

@@ -47,6 +47,9 @@ class AsyncSSHClient:
                     "connect_timeout": self.config.timeout,
                     "known_hosts": None,  # Skip host key verification for now
                 }
+
+                if self.config.keepalive:
+                    connect_kwargs["keepalive_interval"] = self.config.keepalive
                 
                 # Add username if provided
                 if self.config.username:

{mdify_cli-3.0.3 → mdify_cli-3.0.5}/mdify/ssh/remote_container.py

@@ -54,14 +54,48 @@ class RemoteContainer(DoclingContainer):
         )
         self.is_healthy = False
     
+    async def _cleanup_port(self) -> None:
+        """Clean up any existing containers using this port.
+        
+        Attempts to find and stop containers that are bound to self.port.
+        This handles the case where a previous container wasn't properly cleaned up.
+        """
+        try:
+            # Find containers using this port
+            # Using docker inspect with port filter
+            cmd = f"{self.runtime} ps -a --filter 'publish={self.port}' --format '{{{{.ID}}}}'"
+            stdout, stderr, code = await self.ssh_client.run_command(cmd, timeout=10)
+            
+            if code == 0 and stdout.strip():
+                container_ids = stdout.strip().split('\n')
+                for container_id in container_ids:
+                    container_id = container_id.strip()
+                    if not container_id:
+                        continue
+                    
+                    logger.info(f"Cleaning up existing container on port {self.port}: {container_id}")
+                    
+                    # Stop the container
+                    stop_cmd = f"{self.runtime} stop {container_id}"
+                    await self.ssh_client.run_command(stop_cmd, timeout=10)
+                    
+                    # Remove the container
+                    rm_cmd = f"{self.runtime} rm {container_id}"
+                    await self.ssh_client.run_command(rm_cmd, timeout=10)
+                    
+                    logger.debug(f"Container removed: {container_id}")
+        except Exception as e:
+            logger.debug(f"Port cleanup check failed (non-blocking): {e}")
+
     async def start(self) -> None:
         """Start container on remote server.
         
         Operations:
-        1. Detect container runtime on remote
-        2. Run docker/podman run command
-        3. Extract container ID
-        4. Wait for health check
+        1. Clean up any existing containers using this port
+        2. Detect container runtime on remote
+        3. Run docker/podman run command
+        4. Extract container ID
+        5. Wait for health check
         
         Raises:
             RuntimeError: Container already running or start failed
@@ -72,6 +106,9 @@ class RemoteContainer(DoclingContainer):
         
         logger.info(f"Starting remote container: {self.name}")
         
+        # Clean up any existing containers on this port
+        await self._cleanup_port()
+        
         try:
             # Detect runtime if needed
             if not self.runtime:

{mdify_cli-3.0.3 → mdify_cli-3.0.5}/mdify_cli.egg-info/PKG-INFO

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

{mdify_cli-3.0.3 → mdify_cli-3.0.5}/pyproject.toml

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