scripts/backup.py

"""
Auto-backup system: sync checkpoints, data, and configs to HuggingFace Hub.
Supports resume training from any new VPS.

Setup:
  1. huggingface-cli login
  2. python3 backup.py --init (tạo repos trên HF)
  3. python3 backup.py --backup (push lên HF)
  4. python3 backup.py --restore (pull về VPS mới)
"""
import argparse
import subprocess
import time
import threading
from pathlib import Path
from huggingface_hub import HfApi, create_repo, snapshot_download, upload_folder, upload_file


PROJECT_DIR = Path("/home/adminuser/chungcat")
HF_ORG = None  # Set to your HF username or org

REPOS = {
    "checkpoints": "{user}/4k-image-model-checkpoints",
    "data_meta": "{user}/4k-image-model-data",
    "scripts": "{user}/4k-image-model-scripts",
}

BACKUP_PATHS = {
    "checkpoints": [
        PROJECT_DIR / "checkpoints",
    ],
    "data_meta": [
        PROJECT_DIR / "data" / "raw" / "coyo_filtered",
        PROJECT_DIR / "configs",
    ],
    "scripts": [
        PROJECT_DIR / "scripts",
        PROJECT_DIR / "configs",
        PROJECT_DIR / "PLAN.md",
    ],
}


def get_hf_user():
    api = HfApi()
    info = api.whoami()
    return info["name"]


def init_repos(user):
    """Create HF repos if they don't exist."""
    api = HfApi()
    for key, repo_template in REPOS.items():
        repo_id = repo_template.format(user=user)
        try:
            create_repo(repo_id, repo_type="model" if key == "checkpoints" else "dataset", exist_ok=True)
            print(f"  Repo ready: {repo_id}")
        except Exception as e:
            print(f"  Error creating {repo_id}: {e}")


def backup_checkpoints(user):
    """Upload latest checkpoint to HF."""
    api = HfApi()
    repo_id = REPOS["checkpoints"].format(user=user)
    ckpt_dir = PROJECT_DIR / "checkpoints"

    if not ckpt_dir.exists():
        print("  No checkpoints to backup")
        return

    # Find all checkpoint dirs
    for model_dir in ckpt_dir.iterdir():
        if not model_dir.is_dir():
            continue

        # Upload latest checkpoint only (save bandwidth)
        checkpoints = sorted(model_dir.glob("checkpoint-*"), key=lambda p: int(p.name.split("-")[1]) if p.name.split("-")[1].isdigit() else 0)
        final = model_dir / "final"

        to_upload = None
        if final.exists():
            to_upload = final
        elif checkpoints:
            to_upload = checkpoints[-1]

        if to_upload:
            path_in_repo = f"{model_dir.name}/{to_upload.name}"
            print(f"  Uploading {to_upload} → {repo_id}/{path_in_repo}")
            upload_folder(
                folder_path=str(to_upload),
                repo_id=repo_id,
                path_in_repo=path_in_repo,
                repo_type="model",
            )


def backup_data_meta(user):
    """Upload filtered parquets and configs."""
    api = HfApi()
    repo_id = REPOS["data_meta"].format(user=user)

    for path in BACKUP_PATHS["data_meta"]:
        if not path.exists():
            continue
        rel_path = path.relative_to(PROJECT_DIR)
        print(f"  Uploading {rel_path} → {repo_id}")
        upload_folder(
            folder_path=str(path),
            repo_id=repo_id,
            path_in_repo=str(rel_path),
            repo_type="dataset",
        )


def backup_scripts(user):
    """Upload all scripts and configs."""
    api = HfApi()
    repo_id = REPOS["scripts"].format(user=user)

    for path in BACKUP_PATHS["scripts"]:
        if not path.exists():
            continue
        rel_path = path.relative_to(PROJECT_DIR)
        if path.is_file():
            print(f"  Uploading {rel_path}")
            upload_file(
                path_or_fileobj=str(path),
                repo_id=repo_id,
                path_in_repo=str(rel_path),
                repo_type="dataset",
            )
        else:
            print(f"  Uploading {rel_path}/")
            upload_folder(
                folder_path=str(path),
                repo_id=repo_id,
                path_in_repo=str(rel_path),
                repo_type="dataset",
            )


def backup_all(user):
    """Full backup."""
    print("\n=== Backing up scripts ===")
    backup_scripts(user)
    print("\n=== Backing up data metadata ===")
    backup_data_meta(user)
    print("\n=== Backing up checkpoints ===")
    backup_checkpoints(user)
    print("\n=== Backup complete! ===")


def restore(user):
    """Restore everything from HF to a new VPS."""
    print("\n=== Restoring from HuggingFace ===")

    # Restore scripts
    repo_id = REPOS["scripts"].format(user=user)
    print(f"\n  Restoring scripts from {repo_id}...")
    try:
        snapshot_download(
            repo_id=repo_id,
            repo_type="dataset",
            local_dir=str(PROJECT_DIR),
        )
    except Exception as e:
        print(f"  Warning: {e}")

    # Restore data metadata
    repo_id = REPOS["data_meta"].format(user=user)
    print(f"\n  Restoring data metadata from {repo_id}...")
    try:
        snapshot_download(
            repo_id=repo_id,
            repo_type="dataset",
            local_dir=str(PROJECT_DIR),
        )
    except Exception as e:
        print(f"  Warning: {e}")

    # Restore checkpoints
    repo_id = REPOS["checkpoints"].format(user=user)
    print(f"\n  Restoring checkpoints from {repo_id}...")
    try:
        snapshot_download(
            repo_id=repo_id,
            repo_type="model",
            local_dir=str(PROJECT_DIR / "checkpoints"),
        )
    except Exception as e:
        print(f"  Warning: {e}")

    print("\n=== Restore complete! ===")


class AutoBackup:
    """Background thread that backs up every N minutes."""

    def __init__(self, user, interval_minutes=30):
        self.user = user
        self.interval = interval_minutes * 60
        self.running = False
        self.thread = None

    def start(self):
        self.running = True
        self.thread = threading.Thread(target=self._loop, daemon=True)
        self.thread.start()
        print(f"Auto-backup started (every {self.interval // 60} minutes)")

    def stop(self):
        self.running = False
        if self.thread:
            self.thread.join()

    def _loop(self):
        while self.running:
            time.sleep(self.interval)
            if not self.running:
                break
            try:
                print(f"\n[Auto-backup] Starting backup at {time.strftime('%H:%M:%S')}...")
                backup_all(self.user)
                print(f"[Auto-backup] Done at {time.strftime('%H:%M:%S')}")
            except Exception as e:
                print(f"[Auto-backup] Error: {e}")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Backup/restore to HuggingFace Hub")
    parser.add_argument("--init", action="store_true", help="Create HF repos")
    parser.add_argument("--backup", action="store_true", help="Backup to HF")
    parser.add_argument("--restore", action="store_true", help="Restore from HF")
    parser.add_argument("--auto", action="store_true", help="Start auto-backup daemon")
    parser.add_argument("--interval", type=int, default=30, help="Auto-backup interval (minutes)")
    parser.add_argument("--user", default=None, help="HF username (auto-detected if logged in)")
    args = parser.parse_args()

    user = args.user or get_hf_user()
    print(f"HuggingFace user: {user}")

    if args.init:
        print("\nInitializing repos...")
        init_repos(user)
    elif args.backup:
        backup_all(user)
    elif args.restore:
        restore(user)
    elif args.auto:
        ab = AutoBackup(user, args.interval)
        ab.start()
        try:
            while True:
                time.sleep(1)
        except KeyboardInterrupt:
            ab.stop()
    else:
        print("Specify --init, --backup, --restore, or --auto")