mdify-cli 3.0.2__py3-none-any.whl → 3.0.4__py3-none-any.whl

mdify/__init__.py

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

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,154 +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,
-                        )
-                        
-                        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/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/ssh/transfer.py

@@ -231,13 +231,18 @@ class FileTransferManager:
                 local_sha256.update(chunk)
         local_checksum = local_sha256.hexdigest()
         
-        # Calculate remote checksum
-        stdout, stderr, code = await self.ssh_client.run_command(
-            f"sha256sum {remote_path} | awk '{{print $1}}'"
+        # Calculate remote checksum (sha256sum or shasum fallback)
+        checksum_cmd = (
+            f"(command -v sha256sum >/dev/null 2>&1 && sha256sum {remote_path} | awk '{{print $1}}') "
+            f"|| (command -v shasum >/dev/null 2>&1 && shasum -a 256 {remote_path} | awk '{{print $1}}')"
         )
+        stdout, stderr, code = await self.ssh_client.run_command(checksum_cmd)
         
         if code == 0:
             remote_checksum = stdout.strip()
+            if not remote_checksum:
+                logger.warning("Could not verify checksum: remote checksum unavailable")
+                return
             
             if local_checksum != remote_checksum:
                 raise ValueError(

{mdify_cli-3.0.2.dist-info → mdify_cli-3.0.4.dist-info}/METADATA

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

{mdify_cli-3.0.2.dist-info → mdify_cli-3.0.4.dist-info}/RECORD

@@ -1,18 +1,18 @@
 assets/mdify.png,sha256=qUj7WXWqNwpI2KNXOW79XJwqFqa-UI0JEkmt1mmy4Rg,1820418
-mdify/__init__.py,sha256=T6SyoOZjbytRoip9WM4THeDUbin7s6Xq7Cb_HZAAi5Q,90
+mdify/__init__.py,sha256=Le2ZtuARDsPg7kDbPBrwevy3J8cPp-j7fQLAlqx-Na8,90
 mdify/__main__.py,sha256=bhpJ00co6MfaVOdH4XLoW04NtLYDa_oJK7ODzfLrn9M,143
-mdify/cli.py,sha256=f7_3bka83jfvYXp2L6Zk4trPuMrN3hJ51iueK7J1Szk,74065
+mdify/cli.py,sha256=CSj3J-mLdGV58pm-eNpq-vhtkQOVKduMq9hiP_4lhWs,75655
 mdify/container.py,sha256=BjL5ZR__n1i_WHifXKllTPoqO7IuOUdPDo5esuNg0Iw,8213
 mdify/docling_client.py,sha256=xuQR6sC1v3EPloOSwExoHCqT4uUxE8myYq-Yeby3C2I,7975
 mdify/formatting.py,sha256=lJKhMbDPcaWCdyEa7aKwAm_desaWvkfDc8C3EP7LWp4,790
 mdify/ssh/__init__.py,sha256=SmRWgwEvAQZ_ARHlKTb9QDPwVAcz6dvPUks2pZFWLAU,271
-mdify/ssh/client.py,sha256=MNMBrL5Xk2rFo28Ytw80hWX2vQ3_CXlIL4VathNtK-I,14873
+mdify/ssh/client.py,sha256=nO7gAQ6eWxIXFIOplW2F2ya0-1ZEFlLmz3ovi1TEFTg,14997
 mdify/ssh/models.py,sha256=jpbDS1yGhd7Xwq2tW7bZv14mTBlR8DCfhT4x-Xf2Wq4,17676
 mdify/ssh/remote_container.py,sha256=kmScAlmHI9rJLKliYcYQXDZHF7PYYiD-_rRV-S0fffM,8462
-mdify/ssh/transfer.py,sha256=aZZgylDjoqx6PEpaMu2zxkDF04w7btiOnMExmtt922A,10574
-mdify_cli-3.0.2.dist-info/licenses/LICENSE,sha256=NWM66Uv-XuSMKaU-gaPmvfyk4WgE6zcIPr78wyg6GAo,1065
-mdify_cli-3.0.2.dist-info/METADATA,sha256=To3g3ZuGkKaTvMw6wPv8zMEJYDajPIOQ4_bJvJhZYX8,14766
-mdify_cli-3.0.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mdify_cli-3.0.2.dist-info/entry_points.txt,sha256=0Xki8f5lADQUtwdt6Eq_FEaieI6Byhk8UE7BuDhChMg,41
-mdify_cli-3.0.2.dist-info/top_level.txt,sha256=qltzf7h8owHq7dxCdfCkSHY8gT21hn1_E8P-VWS_OKM,6
-mdify_cli-3.0.2.dist-info/RECORD,,
+mdify/ssh/transfer.py,sha256=aQuWa_B81McrgZBBWo_CxnjwoiGHmoxAoqObm19JAk8,10940
+mdify_cli-3.0.4.dist-info/licenses/LICENSE,sha256=NWM66Uv-XuSMKaU-gaPmvfyk4WgE6zcIPr78wyg6GAo,1065
+mdify_cli-3.0.4.dist-info/METADATA,sha256=TUgq2AnSvYZtrMFLdDlgBoZTwhbwAcrd2nzoIVkLewU,14766
+mdify_cli-3.0.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mdify_cli-3.0.4.dist-info/entry_points.txt,sha256=0Xki8f5lADQUtwdt6Eq_FEaieI6Byhk8UE7BuDhChMg,41
+mdify_cli-3.0.4.dist-info/top_level.txt,sha256=qltzf7h8owHq7dxCdfCkSHY8gT21hn1_E8P-VWS_OKM,6
+mdify_cli-3.0.4.dist-info/RECORD,,