File Transfer

from cmdop import AsyncCMDOPClient
 
async with AsyncCMDOPClient.remote(api_key="cmd_xxx") as client:
    # Download a single file from the remote server to a local path
    await client.files.download(
        "my-server",
        "/var/log/app.log",
        "./app.log"
    )

from tqdm import tqdm
 
async def download_with_progress(hostname, remote_path, local_path):
    # Fetch file metadata to determine the total size for the progress bar
    info = await client.files.info(hostname, remote_path)
 
    with tqdm(total=info.size, unit='B', unit_scale=True) as pbar:
        # Callback invoked periodically with bytes downloaded so far
        async def on_progress(downloaded, total):
            pbar.update(downloaded - pbar.n)
 
        await client.files.download(
            hostname,
            remote_path,
            local_path,
            on_progress=on_progress
        )
 
await download_with_progress("my-server", "/data/backup.tar.gz", "./backup.tar.gz")

# Resume downloading from where it left off (skips already-downloaded bytes)
await client.files.download(
    "my-server",
    "/data/large.iso",
    "./large.iso",
    resume=True  # Continues from where it stopped
)

# Upload a local file to the specified path on the remote server
await client.files.upload(
    "./config.yaml",
    "my-server",
    "/app/config.yaml"
)

import os
from tqdm import tqdm
 
async def upload_with_progress(local_path, hostname, remote_path):
    # Get local file size for the progress bar total
    file_size = os.path.getsize(local_path)
 
    with tqdm(total=file_size, unit='B', unit_scale=True) as pbar:
        # Callback invoked periodically with bytes uploaded so far
        async def on_progress(uploaded, total):
            pbar.update(uploaded - pbar.n)
 
        await client.files.upload(
            local_path,
            hostname,
            remote_path,
            on_progress=on_progress
        )
 
await upload_with_progress("./data.tar.gz", "my-server", "/tmp/data.tar.gz")

# Upload a script and make it executable in one step
await client.files.upload(
    "./deploy.sh",
    "my-server",
    "/app/deploy.sh",
    mode=0o755
)

# Recursively download every file in the remote directory to a local folder
await client.files.download_dir(
    "my-server",
    "/app/logs",
    "./logs"
)

# Recursively upload every file in the local directory to the remote server
await client.files.upload_dir(
    "./dist",
    "my-server",
    "/app/public"
)

# Download only files matching a glob pattern
await client.files.download_dir(
    "my-server",
    "/app/logs",
    "./logs",
    pattern="*.log"  # Only .log files
)
 
# Upload a project directory but exclude build artifacts
await client.files.upload_dir(
    "./project",
    "my-server",
    "/app",
    exclude=["node_modules", "*.pyc", "__pycache__"]
)

# Compress the remote directory into a tar.gz and download (faster for many small files)
await client.files.download_archive(
    "my-server",
    "/app/logs",
    "./logs.tar.gz",
    format="tar.gz"
)

# Upload a local archive and automatically extract it at the destination
await client.files.upload_archive(
    "./dist.tar.gz",
    "my-server",
    "/app/public",
    extract=True
)

# Use larger chunks for high-bandwidth connections (default varies)
await client.files.download(
    "my-server",
    "/data/file.iso",
    "./file.iso",
    chunk_size=1024 * 1024  # 1MB chunks
)

# Download and automatically compare MD5 checksums after transfer
await client.files.download(
    "my-server",
    "/data/backup.tar.gz",
    "./backup.tar.gz",
    verify_checksum=True  # Compares MD5 after transfer
)
 
# Retrieve the MD5 checksum of a remote file without downloading it
checksum = await client.files.checksum("my-server", "/data/backup.tar.gz")
print(f"MD5: {checksum}")

# Sync a local directory to remote, transferring only modified files
result = await client.files.sync(
    "./project",
    "my-server",
    "/app",
    delete=False  # Don't delete remote files not in local
)
 
print(f"Transferred: {result.transferred_files}")
print(f"Skipped: {result.skipped_files}")
print(f"Total bytes: {result.total_bytes}")

from cmdop.exceptions import (
    TransferError,
    DiskFullError,
    ConnectionLostError
)
 
try:
    await client.files.upload("./large.iso", "my-server", "/data/large.iso")
except DiskFullError:
    # Raised when the remote disk has insufficient space
    print("Not enough space on remote")
except ConnectionLostError:
    # Raised when the network connection drops during transfer
    print("Connection lost during transfer")
    # Can resume later with resume=True
except TransferError as e:
    # Catch-all for any other transfer failure
    print(f"Transfer failed: {e}")

import asyncio
 
async def transfer_many():
    files = [
        ("file1.log", "/logs/file1.log"),
        ("file2.log", "/logs/file2.log"),
        ("file3.log", "/logs/file3.log"),
    ]
 
    # Upload all files in parallel using asyncio.gather
    await asyncio.gather(*[
        client.files.upload(local, "my-server", remote)
        for local, remote in files
    ])
 
await transfer_many()

# Transfer a file directly from one remote server to another (no local download)
await client.files.remote_copy(
    source_host="server-a",
    source_path="/data/file.tar.gz",
    dest_host="server-b",
    dest_path="/backup/file.tar.gz"
)

# Upload to a temp path first, then atomically move to the final location
temp_path = f"/tmp/{uuid.uuid4()}"
 
await client.files.upload("./config.yaml", "my-server", temp_path)
await client.files.move("my-server", temp_path, "/app/config.yaml")

# Instead of transferring 10000 small files individually,
# create an archive, transfer it, then extract on the remote

# Always enable resume for large files to handle network interruptions
await client.files.download(
    "my-server", "/data/10gb.iso", "./10gb.iso",
    resume=True
)

# Enable checksum verification for important files (backups, releases, etc.)
await client.files.upload(
    "./backup.tar.gz", "my-server", "/data/backup.tar.gz",
    verify_checksum=True
)

# Sync only transfers changed files, making deployments much faster
await client.files.sync("./dist", "my-server", "/app/public")