server/app.py

import contextlib
import json
import os
import re
import shutil
import signal
import subprocess
import threading
import time
import urllib.request
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

from fastapi import Depends, FastAPI, File, Header, HTTPException, UploadFile
from pydantic import BaseModel, Field, model_validator

app = FastAPI(title="Qwen 3.5 SFT Fine-Tuning API", version="2.0.0")

API_SECRET = os.environ.get("API_SECRET", "")
WORKSPACE = Path("/workspace")
DATA_DIR = WORKSPACE / "data"
OUTPUT_DIR = WORKSPACE / "output"
CONFIG_DIR = WORKSPACE / "config"
LOG_FILE = WORKSPACE / "training.log"

DATA_DIR.mkdir(parents=True, exist_ok=True)
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
CONFIG_DIR.mkdir(parents=True, exist_ok=True)

# Global event: set when training + HF push are fully done.
# The SIGTERM handler waits on this before allowing the process to exit,
# so the container is never killed while a push is in flight.
_training_done = threading.Event()
_training_done.set()  # starts "done" (no training in progress)
_training_thread: threading.Thread | None = None


# ---------------------------------------------------------------------------
# Multi-node readiness barrier
# ---------------------------------------------------------------------------
# In a cluster, every node pre-downloads model/dataset independently.
# Once done, workers POST to the master's /barrier/ready.  The master
# counts itself + all workers, then every node polls /barrier/wait until
# the count reaches num_nodes.  Only then does any node start torchrun.



# ---------------------------------------------------------------------------
# HuggingFace Hub push helpers
# ---------------------------------------------------------------------------


def _ensure_readme_metadata(checkpoint_path: Path, model_id: str):
    """Ensure the checkpoint has a README.md with correct base_model metadata.

    ms-swift either writes a local cache path as base_model (which HF rejects)
    or the README may be missing entirely.  This function fixes existing READMEs
    or creates a minimal one so HF Hub always has the base_model field set to
    the canonical model ID (e.g. ``Qwen/Qwen3.5-4B``).
    """
    readme = checkpoint_path / "README.md"

    if readme.exists():
        text = readme.read_text(encoding="utf-8")
        fm_match = re.match(r"^---\n(.*?\n)---", text, re.DOTALL)

        if fm_match:
            front_matter = fm_match.group(1)
            original = front_matter

            # Fix base_model values that are local paths
            front_matter = re.sub(
                r'(base_model\s*:\s*)["\']?(/[^\s"\']+)["\']?',
                rf"\1{model_id}",
                front_matter,
            )

            # If base_model is missing entirely, add it
            if "base_model" not in front_matter:
                front_matter = f"base_model: {model_id}\n{front_matter}"

            if front_matter != original:
                text = f"---\n{front_matter}---" + text[fm_match.end() :]
                readme.write_text(text, encoding="utf-8")
                print(
                    f"[HF Push] Fixed README metadata in {checkpoint_path.name} → base_model: {model_id}",
                    flush=True,
                )
            return

    # No README or no front-matter — create a minimal one
    readme.write_text(
        f"---\nbase_model: {model_id}\ntags:\n- fine-tuned\n- ms-swift\nlibrary_name: transformers\n---\n\n"
        f"# {checkpoint_path.name}\n\nFine-tuned from [{model_id}](https://huggingface.co/{model_id}) using [ms-swift](https://github.com/modelscope/ms-swift).\n",
        encoding="utf-8",
    )
    print(
        f"[HF Push] Created README.md for {checkpoint_path.name} with base_model: {model_id}",
        flush=True,
    )


def _fix_adapter_config_base_model(checkpoint_path: Path, model_id: str):
    """Rewrite base_model_name_or_path in adapter_config.json from a local
    cache path (e.g. /workspace/hf-cache/hub/models--Qwen--Qwen3.5-9B/...)
    to the canonical HF model ID (e.g. Qwen/Qwen3.5-9B)."""
    adapter_cfg = checkpoint_path / "adapter_config.json"
    if not adapter_cfg.exists():
        return
    try:
        cfg = json.loads(adapter_cfg.read_text(encoding="utf-8"))
        base = cfg.get("base_model_name_or_path", "")
        if base.startswith("/") or "--" in base:
            cfg["base_model_name_or_path"] = model_id
            adapter_cfg.write_text(
                json.dumps(cfg, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
            )
            print(
                f"[HF Push] Fixed adapter_config.json base_model_name_or_path: {base} → {model_id}",
                flush=True,
            )
    except Exception as e:
        print(f"[HF Push] Warning: could not fix adapter_config.json: {e}", flush=True)


CHECKPOINT_IGNORE_PATTERNS = [
    "optimizer.pt",
    "optim_states.pt",
    "scheduler.pt",
    "rng_state*.pth",
    "global_step*",
    "zero_to_fp32.py",
    "*.distcp",
]


def _checkpoint_is_ready(checkpoint_path: Path, settle_seconds: float = 30) -> bool:
    """Return True only when no file in the checkpoint has been modified recently.

    This prevents uploading a half-written checkpoint while the trainer is
    still flushing large .safetensors / optimizer files to disk.
    """
    cutoff = time.time() - settle_seconds
    try:
        for f in checkpoint_path.rglob("*"):
            if f.is_file() and f.stat().st_mtime > cutoff:
                return False
    except OSError:
        return False
    return True


def _hf_push_checkpoint(
    checkpoint_path: Path, repo_id: str, hf_token: str, commit_message: str, model_id: str = ""
):
    """Push a single checkpoint directory to HuggingFace Hub."""
    try:
        if model_id:
            _ensure_readme_metadata(checkpoint_path, model_id)
            _fix_adapter_config_base_model(checkpoint_path, model_id)

        from huggingface_hub import HfApi

        api = HfApi(token=hf_token)
        api.create_repo(repo_id, exist_ok=True, private=True)
        api.upload_folder(
            folder_path=str(checkpoint_path),
            repo_id=repo_id,
            commit_message=commit_message,
            path_in_repo=checkpoint_path.name,
            ignore_patterns=CHECKPOINT_IGNORE_PATTERNS,
        )
        print(f"[HF Push] Pushed {checkpoint_path.name} to {repo_id}")
    except Exception as e:
        print(f"[HF Push] Failed to push {checkpoint_path.name}: {e}")


_HF_PUSH_STATE_FILE = OUTPUT_DIR / ".hf_push_state.json"


def _save_push_state(repo_id: str, hf_token: str, model_id: str, checkpoint_name: str):
    """Persist push intent so it can be recovered after a crash/restart."""
    try:
        _HF_PUSH_STATE_FILE.write_text(
            json.dumps(
                {
                    "repo_id": repo_id,
                    "hf_token": hf_token,
                    "model_id": model_id,
                    "checkpoint_name": checkpoint_name,
                    "created_at": datetime.now(timezone.utc).isoformat(),
                }
            )
        )
    except Exception as e:
        print(f"[HF Push] Warning: could not save push state: {e}", flush=True)


def _clear_push_state():
    with contextlib.suppress(Exception):
        _HF_PUSH_STATE_FILE.unlink(missing_ok=True)


def _verify_hf_push(repo_id: str, hf_token: str, checkpoint_name: str | None = None) -> bool:
    """Verify that the model was actually pushed to HuggingFace by checking for key files."""
    try:
        from huggingface_hub import HfApi

        api = HfApi(token=hf_token)
        # list_repo_files returns strings (file paths relative to repo root)
        files = list(api.list_repo_files(repo_id))

        prefix = f"{checkpoint_name}/" if checkpoint_name else ""
        has_config = f"{prefix}config.json" in files
        has_weights = any(
            f.startswith(prefix) and (f.endswith(".safetensors") or f.endswith(".bin"))
            for f in files
        )
        return has_config and has_weights
    except Exception as e:
        print(f"[HF Push] Verification failed: {e}", flush=True)
        return False


def _hf_push_final_model(
    output_dir: Path,
    repo_id: str,
    hf_token: str,
    model_id: str = "",
    tuner_type: str = "full",
    max_retries: int = 3,
) -> bool:
    """Push the final trained model to HuggingFace Hub as the repo root.

    Returns True if the push succeeded and was verified, False otherwise.
    Retries on transient failures.
    """
    best = _find_best_checkpoint(output_dir)
    if not best:
        print("[HF Push] No checkpoint found for final push", flush=True)
        return False

    _save_push_state(repo_id, hf_token, model_id, best.name)

    upload_dir = best
    if model_id:
        _ensure_readme_metadata(upload_dir, model_id)

    from huggingface_hub import HfApi

    for attempt in range(1, max_retries + 1):
        try:
            print(
                f"[HF Push] Final push attempt {attempt}/{max_retries}: {best.name} -> {repo_id}",
                flush=True,
            )
            api = HfApi(token=hf_token)
            api.create_repo(repo_id, exist_ok=True, private=True)
            api.upload_folder(
                folder_path=str(upload_dir),
                repo_id=repo_id,
                commit_message=f"Final model from {best.name}",
                ignore_patterns=CHECKPOINT_IGNORE_PATTERNS,
            )
            print("[HF Push] Upload complete, verifying...", flush=True)

            if _verify_hf_push(repo_id, hf_token):
                print(
                    f"[HF Push] Verified: final model from {best.name} is on {repo_id}", flush=True
                )
                _clear_push_state()
                return True
            else:
                print(f"[HF Push] Verification failed after upload (attempt {attempt})", flush=True)
        except Exception as e:
            print(f"[HF Push] Attempt {attempt} failed: {e}", flush=True)

        if attempt < max_retries:
            wait = 15 * attempt
            print(f"[HF Push] Retrying in {wait}s...", flush=True)
            time.sleep(wait)

    print(f"[HF Push] CRITICAL: All {max_retries} attempts to push final model failed!", flush=True)
    return False


def _recover_pending_push():
    """On startup, check if a previous push was interrupted and retry it."""
    if not _HF_PUSH_STATE_FILE.exists():
        return

    try:
        push_state = json.loads(_HF_PUSH_STATE_FILE.read_text())
    except Exception:
        _clear_push_state()
        return

    repo_id = push_state.get("repo_id")
    hf_token = push_state.get("hf_token")
    model_id = push_state.get("model_id", "")
    checkpoint_name = push_state.get("checkpoint_name", "")

    if not repo_id or not hf_token:
        _clear_push_state()
        return

    print(f"[HF Push] Recovering interrupted push: {checkpoint_name} -> {repo_id}", flush=True)

    if _verify_hf_push(repo_id, hf_token):
        print("[HF Push] Recovery: push already completed (verified on HF)", flush=True)
        _clear_push_state()
        return

    if _verify_hf_push(repo_id, hf_token, checkpoint_name):
        print(
            f"[HF Push] Recovery: checkpoint {checkpoint_name} already on HF (verified)", flush=True
        )
        _clear_push_state()
        return

    success = _hf_push_final_model(OUTPUT_DIR, repo_id, hf_token, model_id=model_id)
    if success:
        print("[HF Push] Recovery push succeeded", flush=True)
    else:
        print("[HF Push] Recovery push FAILED — manual intervention needed", flush=True)


def _find_best_checkpoint(output_dir: Path) -> Path | None:
    """Find the best checkpoint in the output directory.

    Prefers the checkpoint marked as best_model_checkpoint in trainer_state.json
    (written when load_best_model_at_end is enabled). Falls back to the most
    recent checkpoint by modification time.
    """
    best_from_state = _best_checkpoint_from_trainer_state(output_dir)
    if best_from_state and best_from_state.exists():
        print(f"[Checkpoint] Using best by eval metric: {best_from_state}", flush=True)
        return best_from_state

    candidates = sorted(output_dir.glob("*/checkpoint-*"), key=lambda p: p.stat().st_mtime)
    if candidates:
        return candidates[-1]
    candidates = sorted(output_dir.glob("checkpoint-*"), key=lambda p: p.stat().st_mtime)
    return candidates[-1] if candidates else None


def _best_checkpoint_from_trainer_state(output_dir: Path) -> Path | None:
    """Read trainer_state.json to find the checkpoint with the best eval metric."""
    for state_file in output_dir.rglob("trainer_state.json"):
        try:
            ts = json.loads(state_file.read_text(encoding="utf-8"))
            best = ts.get("best_model_checkpoint")
            if best:
                best_path = Path(best)
                if best_path.exists():
                    return best_path
                relative = output_dir / best_path.name
                if relative.exists():
                    return relative
        except Exception:
            continue
    return None


def _find_latest_checkpoint(output_dir: Path) -> Path | None:
    """Find the most recent checkpoint by step number across all run directories."""
    all_ckpts: list[tuple[int, Path]] = []
    for pattern in ("*/checkpoint-*", "checkpoint-*"):
        for p in output_dir.glob(pattern):
            m = re.search(r"checkpoint-(\d+)$", p.name)
            if m and p.is_dir():
                all_ckpts.append((int(m.group(1)), p))
    if not all_ckpts:
        return None
    all_ckpts.sort(key=lambda t: t[0])
    return all_ckpts[-1][1]


class _HFPushQueue:
    """Watches the output directory for new checkpoints and pushes them to HF.

    Uploads are serialized through a single worker thread to prevent concurrent
    commits to the same repo (which cause commit-race failures on HF Hub).

    Checkpoints are enqueued as soon as they are discovered so they cannot be
    deleted by the trainer (save_total_limit rotation) before the upload starts.
    The upload worker waits for the checkpoint to settle before pushing.
    """

    def __init__(
        self,
        repo_id: str,
        hf_token: str,
        model_id: str = "",
        output_dir: Path = OUTPUT_DIR,
        poll_interval: float = 15,
    ):
        self.repo_id = repo_id
        self.hf_token = hf_token
        self.model_id = model_id
        self._output_dir = output_dir
        self._poll_interval = poll_interval
        self._pushed: set[str] = set()
        self._queue: list[Path] = []
        self._queue_lock = threading.Lock()
        self._stop = threading.Event()
        self._has_work = threading.Event()

        self._watcher = threading.Thread(target=self._watch, daemon=False, name="hf-push-watcher")
        self._worker = threading.Thread(
            target=self._upload_worker, daemon=False, name="hf-push-worker"
        )
        self._watcher.start()
        self._worker.start()

    def _discover_checkpoints(self) -> list[Path]:
        """Find all checkpoint-* dirs under output_dir (any nesting depth)."""
        found = []
        for pattern in ("*/checkpoint-*", "checkpoint-*"):
            for p in self._output_dir.glob(pattern):
                if p.is_dir() and p.name not in self._pushed:
                    found.append(p)
        return sorted(found, key=lambda p: p.stat().st_mtime)

    def _watch(self):
        """Poll for new checkpoints and enqueue immediately on discovery."""
        while not self._stop.is_set():
            self._stop.wait(self._poll_interval)
            if self._stop.is_set():
                break
            for ckpt in self._discover_checkpoints():
                self._pushed.add(ckpt.name)
                self._enqueue(ckpt)

    def _enqueue(self, checkpoint_path: Path):
        with self._queue_lock:
            self._queue.append(checkpoint_path)
        self._has_work.set()
        print(f"[HF Push] Queued upload for {checkpoint_path.name}", flush=True)

    def _upload_worker(self):
        """Sequentially process queued uploads — one commit at a time.

        Waits for each checkpoint to settle (files stop changing) before
        uploading. If the checkpoint directory is deleted before it settles
        (e.g. by save_total_limit rotation), the upload is skipped.
        """
        while True:
            self._has_work.wait(timeout=5)
            self._has_work.clear()

            while True:
                with self._queue_lock:
                    if not self._queue:
                        break
                    ckpt = self._queue.pop(0)

                if not ckpt.exists():
                    print(f"[HF Push] {ckpt.name} was deleted before upload, skipping", flush=True)
                    continue

                for _ in range(12):
                    if _checkpoint_is_ready(ckpt):
                        break
                    if not ckpt.exists():
                        break
                    time.sleep(5)

                if not ckpt.exists():
                    print(f"[HF Push] {ckpt.name} was deleted before upload, skipping", flush=True)
                    continue

                _hf_push_checkpoint(
                    ckpt, self.repo_id, self.hf_token, f"Checkpoint {ckpt.name}", self.model_id
                )

            if self._stop.is_set():
                with self._queue_lock:
                    if not self._queue:
                        break

    def stop_and_wait(self, timeout: float = 600):
        """Stop watching and drain any remaining uploads."""
        self._stop.set()
        self._watcher.join(timeout=10)

        for ckpt in self._discover_checkpoints():
            self._pushed.add(ckpt.name)
            self._enqueue(ckpt)

        self._has_work.set()
        self._worker.join(timeout=timeout)
        print("[HF Push] All uploads done.", flush=True)


# ---------------------------------------------------------------------------
# Webhook helper
# ---------------------------------------------------------------------------


class _PostRedirectHandler(urllib.request.HTTPRedirectHandler):
    """Preserve POST method and body through 301/302/307/308 redirects."""

    def redirect_request(self, req, fp, code, msg, headers, newurl):
        new_req = urllib.request.Request(
            newurl,
            data=req.data,
            headers=dict(req.headers),
            method="POST",
        )
        return new_req


def _fire_webhook(url: str, secret: str, payload: dict):
    """POST JSON to the dashboard webhook."""
    if url.startswith("http://") and "localhost" not in url and "127.0.0.1" not in url:
        url = url.replace("http://", "https://", 1)
    try:
        data = json.dumps(payload).encode()
        req = urllib.request.Request(
            url,
            data=data,
            headers={
                "Content-Type": "application/json",
                "X-Webhook-Secret": secret,
            },
            method="POST",
        )
        opener = urllib.request.build_opener(_PostRedirectHandler)
        with opener.open(req, timeout=15) as resp:
            print(f"[Webhook] Fired to {url} — status {resp.status}")
    except Exception as e:
        print(f"[Webhook] Failed to fire to {url}: {e}")


def _fire_completion_webhook(config: dict, hf_push_ok: bool = False):
    """Notify the dashboard that training completed successfully.

    Only called after a real successful training run (returncode 0)
    AND after the final HF push has been attempted.
    """
    url = config.get("webhook_url")
    secret = config.get("webhook_secret") or ""
    job_id = config.get("training_job_id")
    if not url or not job_id:
        return
    _fire_webhook(
        url,
        secret,
        {
            "jobId": job_id,
            "status": "completed",
            "hfPushOk": hf_push_ok,
        },
    )


# ---------------------------------------------------------------------------
# Training state
# ---------------------------------------------------------------------------


class TrainingState:
    def __init__(self):
        self.status = "idle"
        self.started_at: str | None = None
        self.finished_at: str | None = None
        self.error: str | None = None
        self.pid: int | None = None
        self.config: dict = {}
        self.hf_push_status: str | None = None  # None, "pushing", "success", "failed"

    def to_dict(self):
        tail = ""
        if LOG_FILE.exists():
            try:
                lines = LOG_FILE.read_text().splitlines()
                tail = "\n".join(lines[-50:])
            except Exception:
                pass
        return {
            "status": self.status,
            "started_at": self.started_at,
            "finished_at": self.finished_at,
            "error": self.error,
            "pid": self.pid,
            "config": self.config,
            "log_tail": tail,
            "hf_push_status": self.hf_push_status,
            "push_in_progress": not _training_done.is_set(),
        }


state = TrainingState()


def verify_secret(authorization: str = Header(...)):
    if not API_SECRET:
        raise HTTPException(500, "API_SECRET env var not set on server")
    expected = f"Bearer {API_SECRET}"
    if authorization != expected:
        raise HTTPException(401, "Invalid or missing API secret")


def _to_snake_case(key: str) -> str:
    """Convert camelCase, PascalCase, UPPER_CASE, or kebab-case to snake_case."""
    key = key.replace("-", "_")
    key = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", key)
    key = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", key)
    return key.lower()


class TrainRequest(BaseModel):
    model: str = Field("Qwen/Qwen3.5-4B", description="HuggingFace model ID or local path")
    dataset: str | None = Field(
        None,
        description="HuggingFace dataset ID (e.g. 'tatsu-lab/alpaca') or leave empty to use uploaded JSONL",
    )
    dataset_subset: str | None = Field(None, description="Dataset subset/config name")
    val_split_ratio: float | None = Field(
        None,
        ge=0.0,
        le=0.5,
        description="Fraction of training data to hold out for validation (0.0-0.5). Ignored when val_dataset is set",
    )
    val_dataset: str | None = Field(
        None, description="HuggingFace dataset ID for validation, or leave empty"
    )
    num_epochs: int = Field(3, ge=1, le=100, description="Number of training epochs")
    batch_size: int = Field(1, ge=1, description="Per-device training batch size")
    grad_accum: int = Field(
        4,
        ge=1,
        description="Gradient accumulation steps (effective batch = batch_size * grad_accum * num_gpus)",
    )
    learning_rate: float = Field(2e-5, gt=0, description="Peak learning rate")
    max_length: int = Field(
        2048,
        ge=128,
        description="Max sequence length in tokens. Rows exceeding this are dropped. Qwen 3.5 supports up to 32768",
    )
    save_steps: int = Field(10, ge=1, description="Save a checkpoint every N steps")
    eval_steps: int | None = Field(
        None, ge=1, description="Run evaluation every N steps. Defaults to save_steps if not set"
    )
    save_total_limit: int = Field(
        2, ge=1, description="Max number of checkpoints to keep on disk (oldest are deleted)"
    )
    logging_steps: int = Field(5, ge=1, description="Log metrics every N steps")
    tuner_type: str = Field("full", description="Tuning strategy (only 'full' is supported)")
    warmup_ratio: float = Field(
        0.1,
        ge=0.0,
        le=1.0,
        description="Fraction of total steps used for linear LR warmup (0.0-1.0)",
    )
    lr_scheduler_type: str = Field(
        "cosine",
        description="LR scheduler: cosine, linear, cosine_with_restarts, polynomial, constant, constant_with_warmup, inverse_sqrt",
    )
    weight_decay: float = Field(0.1, ge=0.0, description="L2 weight decay coefficient")
    max_grad_norm: float = Field(
        1.0, ge=0.0, description="Max gradient norm for clipping (0 = no clipping)"
    )
    optimizer: str = Field(
        "adamw_torch",
        description="Optimizer: adamw_torch, adamw_torch_fused, adamw_8bit, paged_adamw_8bit, paged_adamw_32bit, adafactor, sgd",
    )
    seed: int = Field(42, ge=0, description="Random seed for reproducibility")
    neftune_alpha: float | None = Field(
        None,
        ge=0.0,
        description="NEFTune noise alpha for embedding regularization (null/0 = off, try 5-15)",
    )
    packing: bool = Field(
        False,
        description="Pack multiple samples into uniform-length sequences to reduce padding waste",
    )
    shuffle_dataset: bool = Field(
        False,
        description="Explicitly shuffle the dataset before training. The dataloader already uses a random sampler by default, so this adds an extra pre-shuffle pass",
    )
    lazy_tokenize: bool = Field(
        True,
        description="Tokenize samples on-the-fly during training instead of pre-tokenizing the entire dataset into memory. Prevents OOM on large datasets",
    )
    dataset_num_proc: int = Field(
        4,
        ge=1,
        le=128,
        description="Number of processes for dataset preprocessing. Higher values speed up tokenization but use more CPU/RAM",
    )
    attn_impl: str = Field(
        "flash_attn",
        description="Attention implementation: 'flash_attn' (recommended, O(n) memory), 'sdpa' (PyTorch native), or 'eager' (naive, O(n^2) memory). Qwen3.5 has full-attention layers that OOM without flash_attn at long sequences",
    )
    deepspeed: str | None = Field(
        None,
        description="DeepSpeed config: 'zero2', 'zero3', or null. Auto-set to 'zero2' when num_gpus > 1",
    )
    num_gpus: int | None = Field(
        None, description="Number of GPUs to use. null = auto-detect all available GPUs"
    )
    num_nodes: int | None = Field(
        None,
        ge=1,
        le=64,
        description="Number of nodes for multi-node training. null = auto-detect from NUM_NODES env var (set by RunPod Instant Clusters). 1 = single-node",
    )
    node_rank: int | None = Field(
        None,
        ge=0,
        description="This node's rank in the cluster. null = auto-detect from NODE_RANK env var. 0 = primary node",
    )
    master_addr: str | None = Field(
        None,
        description="Primary node address for distributed training. null = auto-detect from MASTER_ADDR env var",
    )
    master_port: str | None = Field(
        None,
        description="Primary node port for distributed training. null = auto-detect from MASTER_PORT env var",
    )
    gradient_checkpointing: bool = Field(
        True,
        description="Enable gradient checkpointing to reduce VRAM at the cost of ~20% slower training",
    )
    use_flash_ckpt: bool = Field(
        False,
        description="Use flash checkpointing (experimental, requires dlrover). Disabled by default due to dlrover/ms-swift compatibility issues",
    )
    resume_from_checkpoint: str | None = Field(
        None,
        description=(
            "Resume training from a checkpoint. Values: "
            "'auto' = find the latest local checkpoint automatically; "
            "a local path like '/workspace/output/v0-.../checkpoint-100'; "
            "or null to start fresh"
        ),
    )
    hf_token: str | None = Field(None, description="HuggingFace token (overrides HF_TOKEN env var)")
    hf_repo_id: str | None = Field(
        None, description="HuggingFace repo to push checkpoints/final model (e.g. 'org/model-name')"
    )
    wandb_project: str | None = Field(None, description="W&B project name (enables wandb logging)")
    wandb_entity: str | None = Field(None, description="W&B entity/team name")
    wandb_run_name: str | None = Field(None, description="W&B run name")
    wandb_api_key: str | None = Field(
        None, description="W&B API key (overrides WANDB_API_KEY env var)"
    )
    webhook_url: str | None = Field(None, description="URL to POST when training completes")
    webhook_secret: str | None = Field(None, description="Secret sent in X-Webhook-Secret header")
    training_job_id: str | None = Field(None, description="Dashboard job ID passed back in webhook")
    max_pixels: int | None = Field(
        None,
        ge=1024,
        description="Max pixels per image for multimodal training (controls image resolution/VRAM). e.g. 1003520 for ~1M pixels. null = model default",
    )
    min_pixels: int | None = Field(
        None,
        ge=256,
        description="Min pixels per image for multimodal training. null = model default",
    )
    early_stopping_patience: int | None = Field(
        None,
        ge=1,
        description="Stop training when eval loss hasn't improved for this many eval rounds. Requires validation data (val_dataset or val_split_ratio). null = disabled",
    )
    early_stopping_threshold: float = Field(
        0.0,
        ge=0.0,
        description="Minimum eval loss improvement to count as 'better' (0.0 = any improvement counts)",
    )
    extra_args: dict | None = Field(
        None,
        description='Extra args passed directly to swift sft (e.g. {"truncation_strategy": "truncation_left"})',
    )

    _VALID_LR_SCHEDULERS = frozenset(
        {
            "cosine",
            "linear",
            "cosine_with_restarts",
            "polynomial",
            "constant",
            "constant_with_warmup",
            "inverse_sqrt",
        }
    )
    _VALID_OPTIMIZERS = frozenset(
        {
            "adamw_torch",
            "adamw_torch_fused",    
            "adamw_8bit",
            "adamw_bnb_8bit",
            "paged_adamw_8bit",
            "paged_adamw_32bit",
            "adafactor",
            "sgd",
        }
    )
    _VALID_ATTN_IMPLS = frozenset(
        {
            "flash_attn",
            "flash_attention_2",
            "sdpa",
            "eager",
        }
    )

    @model_validator(mode="before")
    @classmethod
    def _normalize_keys(cls, data: Any) -> Any:
        if not isinstance(data, dict):
            return data
        known = set(cls.model_fields.keys())
        normalized: dict[str, Any] = {}
        for key, value in data.items():
            snake = _to_snake_case(key)
            if snake in known:
                normalized[snake] = value
            else:
                normalized[key] = value
        return normalized

    @model_validator(mode="after")
    def _validate_enums(self):
        if self.lr_scheduler_type not in self._VALID_LR_SCHEDULERS:
            raise ValueError(
                f"lr_scheduler_type must be one of {sorted(self._VALID_LR_SCHEDULERS)}, got '{self.lr_scheduler_type}'"
            )
        if self.optimizer not in self._VALID_OPTIMIZERS:
            raise ValueError(
                f"optimizer must be one of {sorted(self._VALID_OPTIMIZERS)}, got '{self.optimizer}'"
            )
        if self.attn_impl not in self._VALID_ATTN_IMPLS:
            raise ValueError(
                f"attn_impl must be one of {sorted(self._VALID_ATTN_IMPLS)}, got '{self.attn_impl}'"
            )
        return self


# ---------------------------------------------------------------------------
# Pre-flight checks
# ---------------------------------------------------------------------------


def _preflight_fla_check():
    """Verify flash-linear-attention is importable before training starts.

    Qwen 3.5 models use GatedDeltaNet for ~75% of their attention layers.
    Without the `fla` package these layers silently fall back to a naive
    O(n²) recurrence that uses 2-3x the VRAM — no warning, no error.
    This check fails fast so we don't burn GPU hours on a doomed run.
    """
    try:
        import fla  # noqa: F401
        from fla.ops.gated_delta_rule import fused_recurrent_gated_delta_rule  # noqa: F401

        print(
            "[Pre-flight] flash-linear-attention OK — GatedDeltaNet layers will use FLA kernels",
            flush=True,
        )
    except ImportError as e:
        print(
            f"[Pre-flight] WARNING: flash-linear-attention not importable: {e}\n"
            "  GatedDeltaNet layers will fall back to naive O(n²) recurrence.\n"
            "  This will use 2-3x more VRAM and likely OOM on sequences >4k.\n"
            "  Install: pip install git+https://github.com/fla-org/flash-linear-attention",
            flush=True,
        )
    except Exception as e:
        print(f"[Pre-flight] flash-linear-attention import issue (non-fatal): {e}", flush=True)

    try:
        import causal_conv1d  # noqa: F401

        print("[Pre-flight] causal-conv1d OK", flush=True)
    except ImportError:
        print(
            "[Pre-flight] WARNING: causal-conv1d not available — some FLA ops may be slower",
            flush=True,
        )


# ---------------------------------------------------------------------------
# Training runner
# ---------------------------------------------------------------------------


def _log_cluster_diagnostics(
    num_nodes: int,
    node_rank: int,
    master_addr: str,
    master_port: str | int,
):
    """Log network interfaces and cluster env vars for debugging."""
    import subprocess as _sp

    try:
        ifaces = _sp.check_output(["ip", "-4", "addr", "show"], timeout=5).decode()
        print(f"[Cluster] Network interfaces:\n{ifaces}", flush=True)
    except Exception as e:
        print(f"[Cluster] Could not list interfaces: {e}", flush=True)

    node_addr = os.environ.get("NODE_ADDR", "")
    primary_addr = os.environ.get("PRIMARY_ADDR", "")
    print(
        f"[Cluster] rank={node_rank}/{num_nodes}, "
        f"MASTER_ADDR={master_addr}, MASTER_PORT={master_port}, "
        f"NODE_ADDR={node_addr}, PRIMARY_ADDR={primary_addr}",
        flush=True,
    )


def _prepare_hf_dataset(snap_path: str, dataset_name: str) -> str | None:
    """Copy JSONL from a HF snapshot to /workspace/data/ with absolute image paths.

    ms-swift resolves relative image paths from the CWD, not from the JSONL
    location.  When a dataset is pulled from HuggingFace Hub the images live
    inside the snapshot cache dir, so relative paths like ``images/foo.jpg``
    break.  This function rewrites them to absolute paths and writes a local
    copy that ``swift sft`` can consume directly.

    Returns the path to the local train JSONL, or None on failure.
    """
    import json as _json
    snap = Path(snap_path)

    jsonl_files = sorted(snap.rglob("*.jsonl"))
    if not jsonl_files:
        print(f"[Dataset] No .jsonl files found in {snap_path}", flush=True)
        return None

    train_src = None
    test_src = None
    for jf in jsonl_files:
        name = jf.stem.lower()
        if "test" in name or "val" in name:
            test_src = test_src or jf
        else:
            train_src = train_src or jf

    if not train_src:
        train_src = jsonl_files[0]

    DATA_DIR.mkdir(parents=True, exist_ok=True)

    def _rewrite_jsonl(src: Path, dst: Path):
        count = 0
        with open(src) as fin, open(dst, "w") as fout:
            for line in fin:
                line = line.strip()
                if not line:
                    continue
                row = _json.loads(line)
                for key in ("images", "videos", "audios"):
                    paths = row.get(key)
                    if not paths:
                        continue
                    resolved = []
                    for p in paths:
                        if p.startswith(("http://", "https://", "data:", "/")):
                            resolved.append(p)
                        else:
                            abs_p = str(snap / p)
                            if Path(abs_p).exists():
                                resolved.append(abs_p)
                            else:
                                resolved.append(p)
                    row[key] = resolved
                fout.write(_json.dumps(row, ensure_ascii=False) + "\n")
                count += 1
        return count

    local_train = DATA_DIR / "train.jsonl"
    n = _rewrite_jsonl(train_src, local_train)
    print(f"[Dataset] Prepared {n} samples: {train_src} -> {local_train}", flush=True)

    if test_src:
        local_test = DATA_DIR / "test.jsonl"
        n_test = _rewrite_jsonl(test_src, local_test)
        print(f"[Dataset] Prepared {n_test} val samples: {test_src} -> {local_test}", flush=True)

    return str(local_train)


def _run_training(config: dict):
    global state
    push_queue: _HFPushQueue | None = None
    is_primary = True

    _training_done.clear()
    try:
        state.status = "running"
        state.started_at = datetime.now(timezone.utc).isoformat()
        state.finished_at = None
        state.error = None
        state.config = config

        print(
            f"[Training] Thread started, dataset={config.get('dataset')}, model={config.get('model')}",
            flush=True,
        )

        # Pre-flight: verify flash-linear-attention is usable.
        # Qwen 3.5 has ~75% GatedDeltaNet layers that silently fall back to
        # a naive O(n²) implementation if `fla` isn't importable, causing
        # 2-3x VRAM usage with zero warning.
        _preflight_fla_check()

        env = os.environ.copy()

        env["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
        env["HF_HUB_DISABLE_PROGRESS_BARS"] = "0"
        env["TRANSFORMERS_VERBOSITY"] = "info"
        env["TORCHELASTIC_LOG_LEVEL"] = "INFO"

        num_gpus = config.get("num_gpus") or _detect_gpu_count()

        if num_gpus > 1:
            gpu_ids = ",".join(str(i) for i in range(num_gpus))
            env["CUDA_VISIBLE_DEVICES"] = gpu_ids
            env["NPROC_PER_NODE"] = str(num_gpus)

        # Multi-node: detect from config or RunPod Instant Cluster env vars
        num_nodes = config.get("num_nodes") or int(os.environ.get("NUM_NODES", "1"))
        node_rank = config.get("node_rank")
        if node_rank is None:
            node_rank = int(os.environ.get("NODE_RANK", "0"))
        master_addr = config.get("master_addr") or os.environ.get("MASTER_ADDR", "")
        master_port = config.get("master_port") or os.environ.get("MASTER_PORT", "29500")

        if num_nodes > 1:
            if not master_addr:
                print(
                    "[Training] WARNING: num_nodes > 1 but MASTER_ADDR is empty. "
                    "RunPod Instant Clusters should set this automatically. "
                    "Distributed training will likely fail without it.",
                    flush=True,
                )
            env["NNODES"] = str(num_nodes)
            env["NODE_RANK"] = str(node_rank)
            env["MASTER_ADDR"] = master_addr
            env["MASTER_PORT"] = str(master_port)

            if not env.get("NCCL_SOCKET_IFNAME") and os.environ.get("PRIMARY_ADDR"):
                env["NCCL_SOCKET_IFNAME"] = "ens1"

            env.setdefault("NCCL_DEBUG", "INFO")
            env.setdefault("NCCL_TIMEOUT", "1800000")
            env.setdefault("TORCHELASTIC_MAX_RESTARTS", "0")

            print(
                f"[Training] Multi-node: {num_nodes} nodes, rank={node_rank}, "
                f"master={master_addr}:{master_port}, NCCL_IFNAME={env.get('NCCL_SOCKET_IFNAME', 'default')}",
                flush=True,
            )

        is_primary = node_rank == 0

        if (num_gpus > 1 or num_nodes > 1) and not config.get("deepspeed"):
            config["deepspeed"] = "zero3"

        hf_token = config.get("hf_token") or os.environ.get("HF_TOKEN", "")
        if hf_token:
            env["HF_TOKEN"] = hf_token

        wandb_key = config.get("wandb_api_key") or os.environ.get("WANDB_API_KEY", "")
        if wandb_key:
            env["WANDB_API_KEY"] = wandb_key
        if config.get("wandb_project"):
            env["WANDB_PROJECT"] = config["wandb_project"]
        if config.get("wandb_entity"):
            env["WANDB_ENTITY"] = config["wandb_entity"]
        if config.get("wandb_run_name"):
            env["WANDB_NAME"] = config["wandb_run_name"]

        hf_repo_id = config.get("hf_repo_id")
        if hf_repo_id and hf_token and is_primary:
            push_queue = _HFPushQueue(
                hf_repo_id, hf_token, model_id=config["model"], output_dir=OUTPUT_DIR
            )

        dataset_arg = config.get("dataset") or "/workspace/data/train.jsonl"

        # For HF datasets with multimodal data: download, rewrite relative
        # image/video/audio paths to absolute, and use the local copy.
        if dataset_arg and not dataset_arg.startswith("/"):
            try:
                from huggingface_hub import snapshot_download
                ds_repo = dataset_arg.split(":")[0]
                print(f"[Training] Pre-downloading dataset: {ds_repo}", flush=True)
                snap_path = snapshot_download(ds_repo, repo_type="dataset", token=hf_token or None)
                print(f"[Training] Dataset cached: {ds_repo} -> {snap_path}", flush=True)

                local_jsonl = _prepare_hf_dataset(snap_path, dataset_arg)
                if local_jsonl:
                    dataset_arg = local_jsonl
            except Exception as e:
                print(f"[Training] Dataset pre-download note: {e} (swift will retry)", flush=True)

        if config.get("dataset_subset"):
            dataset_arg = f"{dataset_arg}:{config['dataset_subset']}"

        cmd = [
            "swift",
            "sft",
            "--model",
            config["model"],
            "--dataset",
            dataset_arg,
            "--tuner_type",
            config["tuner_type"],
            "--torch_dtype",
            "bfloat16",
            "--num_train_epochs",
            str(config["num_epochs"]),
            "--per_device_train_batch_size",
            str(config["batch_size"]),
            "--per_device_eval_batch_size",
            str(config["batch_size"]),
            "--learning_rate",
            str(config["learning_rate"]),
            "--gradient_accumulation_steps",
            str(config["grad_accum"]),
            "--eval_strategy",
            "steps",
            "--eval_steps",
            str(config.get("eval_steps") or config["save_steps"]),
            "--save_steps",
            str(config["save_steps"]),
            "--save_total_limit",
            str(config.get("save_total_limit", 2)),
            "--logging_steps",
            str(config["logging_steps"]),
            "--max_length",
            str(config["max_length"]),
            "--output_dir",
            str(OUTPUT_DIR),
            "--warmup_ratio",
            str(config.get("warmup_ratio", 0.1)),
            "--lr_scheduler_type",
            config.get("lr_scheduler_type", "cosine"),
            "--weight_decay",
            str(config.get("weight_decay", 0.1)),
            "--max_grad_norm",
            str(config.get("max_grad_norm", 1.0)),
            "--optim",
            config.get("optimizer", "adamw_torch"),
            "--seed",
            str(config.get("seed", 42)),
            "--dataloader_num_workers",
            "4",
            "--lazy_tokenize",
            str(config.get("lazy_tokenize", True)),
            "--dataset_num_proc",
            str(config.get("dataset_num_proc", 4)),
            "--attn_impl",
            config.get("attn_impl", "flash_attn"),
            "--use_hf",
            "true",
        ]

        if config.get("max_pixels") is not None:
            cmd += ["--max_pixels", str(config["max_pixels"])]
        if config.get("min_pixels") is not None:
            cmd += ["--min_pixels", str(config["min_pixels"])]

        if config.get("neftune_alpha") and config["neftune_alpha"] > 0:
            cmd += ["--neftune_noise_alpha", str(config["neftune_alpha"])]

        if config.get("packing"):
            cmd += ["--packing", "true"]

        if config.get("shuffle_dataset"):
            cmd += ["--dataset_shuffle", "true"]

        if config.get("gradient_checkpointing"):
            cmd += ["--gradient_checkpointing", "true"]

        if config.get("use_flash_ckpt", False):
            cmd += ["--use_flash_ckpt", "true"]

        if config.get("deepspeed"):
            cmd += ["--deepspeed", config["deepspeed"]]

        if is_primary and (config.get("wandb_project") or wandb_key):
            cmd += ["--report_to", "wandb"]

        val = config.get("val_dataset")
        if val:
            cmd += ["--val_dataset", val]
        elif Path("/workspace/data/test.jsonl").exists():
            cmd += ["--val_dataset", "/workspace/data/test.jsonl"]

        val_split = config.get("val_split_ratio")
        if val_split and val_split > 0 and not val:
            cmd += ["--split_dataset_ratio", str(val_split)]

        has_val = (
            bool(val)
            or (val_split and val_split > 0)
            or Path("/workspace/data/test.jsonl").exists()
        )
        patience = config.get("early_stopping_patience")
        if patience and has_val:
            cmd += [
                "--load_best_model_at_end",
                "true",
                "--metric_for_best_model",
                "eval_loss",
                "--greater_is_better",
                "false",
                "--early_stopping_patience",
                str(patience),
            ]
            threshold = config.get("early_stopping_threshold", 0.0)
            if threshold > 0:
                cmd += ["--early_stopping_threshold", str(threshold)]
            save_limit = config.get("save_total_limit", 2)
            if save_limit < 2:
                cmd += ["--save_total_limit", "2"]
                print(
                    "[Training] Bumped save_total_limit to 2 (required for load_best_model_at_end)",
                    flush=True,
                )
        elif patience and not has_val:
            print(
                "[Training] WARNING: early_stopping_patience ignored — no validation data configured",
                flush=True,
            )

        resume = config.get("resume_from_checkpoint")
        if resume:
            if resume == "auto":
                ckpt = _find_latest_checkpoint(OUTPUT_DIR)
                if ckpt:
                    print(f"[Training] Auto-resume: found {ckpt}", flush=True)
                    cmd += ["--resume_from_checkpoint", str(ckpt)]
                else:
                    print("[Training] Auto-resume: no checkpoint found, starting fresh", flush=True)
            else:
                cmd += ["--resume_from_checkpoint", resume]

        if config.get("extra_args"):
            for k, v in config["extra_args"].items():
                flag = f"--{k}" if not k.startswith("--") else k
                cmd += [flag, str(v)]

        # Pre-download model so torchrun doesn't do it silently
        model_name = config["model"]
        print(f"[Training] Pre-downloading model: {model_name}", flush=True)
        try:
            from huggingface_hub import snapshot_download
            snapshot_download(model_name, token=hf_token or None)
            print(f"[Training] Model cached: {model_name}", flush=True)
        except Exception as e:
            print(f"[Training] Model pre-download note: {e} (torchrun will retry)", flush=True)

        if num_nodes > 1 and master_addr:
            _log_cluster_diagnostics(num_nodes, node_rank, master_addr, master_port)

        print(f"[Training] Running: {' '.join(cmd)}", flush=True)

        with open(LOG_FILE, "w") as log:
            proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env)
            state.pid = proc.pid
            for line in iter(proc.stdout.readline, b""):
                decoded = line.decode("utf-8", errors="replace")
                log.write(decoded)
                log.flush()
                print(decoded, end="", flush=True)

            proc.wait()

        if proc.returncode != 0:
            state.status = "failed"
            state.error = f"Training exited with code {proc.returncode}"
            print(f"[Training] FAILED with exit code {proc.returncode}", flush=True)
        else:
            state.status = "completed"
            print("[Training] Completed successfully", flush=True)

    except Exception as e:
        state.status = "failed"
        state.error = str(e)
        print(f"[Training] Exception: {e}", flush=True)
    finally:
        state.finished_at = datetime.now(timezone.utc).isoformat()
        state.pid = None

        if push_queue is not None:
            push_queue.stop_and_wait()

        hf_push_ok = False
        if is_primary and state.status == "completed" and hf_repo_id and hf_token:
            state.hf_push_status = "pushing"
            print(
                "[HF Push] Starting final model push — container MUST stay alive until this completes",
                flush=True,
            )
            hf_push_ok = _hf_push_final_model(
                OUTPUT_DIR,
                hf_repo_id,
                hf_token,
                model_id=config["model"],
                tuner_type=config["tuner_type"],
            )
            state.hf_push_status = "success" if hf_push_ok else "failed"
            if not hf_push_ok:
                state.error = "Training completed but final HF push failed after all retries"
            print(f"[HF Push] Final push finished (success={hf_push_ok})", flush=True)

        if is_primary and state.status == "completed":
            _fire_completion_webhook(config, hf_push_ok=hf_push_ok)
        elif not is_primary:
            print(f"[Training] Worker node (rank {config.get('node_rank', '?')}) — skipping HF push and webhook", flush=True)

        _training_done.set()
        print("[Training] Training thread fully done (push complete, safe to exit)", flush=True)


# ---------------------------------------------------------------------------
# Graceful shutdown: wait for training + HF push before allowing exit
# ---------------------------------------------------------------------------

_original_sigterm = signal.getsignal(signal.SIGTERM)
_original_sigint = signal.getsignal(signal.SIGINT)


def _graceful_shutdown(signum, frame):
    """Block container exit until the HF push is finished."""
    sig_name = "SIGTERM" if signum == signal.SIGTERM else "SIGINT"
    if not _training_done.is_set():
        print(
            f"[Shutdown] {sig_name} received but training/push still in progress — waiting up to 30 min...",
            flush=True,
        )
        finished = _training_done.wait(timeout=1800)
        if finished:
            print("[Shutdown] Training + push completed, proceeding with shutdown", flush=True)
        else:
            print(
                "[Shutdown] CRITICAL: Timed out waiting for push after 30 min, forcing exit",
                flush=True,
            )
    else:
        print(
            f"[Shutdown] {sig_name} received, no training in progress — shutting down immediately",
            flush=True,
        )

    # Re-raise to the original handler (uvicorn's) so the server actually stops
    original = _original_sigterm if signum == signal.SIGTERM else _original_sigint
    if callable(original):
        original(signum, frame)
    else:
        raise SystemExit(0)


# ---------------------------------------------------------------------------
# Startup: recover interrupted HF pushes + install signal handlers
# ---------------------------------------------------------------------------


@app.on_event("startup")
def _on_startup():
    signal.signal(signal.SIGTERM, _graceful_shutdown)
    signal.signal(signal.SIGINT, _graceful_shutdown)
    threading.Thread(target=_recover_pending_push, daemon=True, name="hf-push-recovery").start()


# ---------------------------------------------------------------------------
# API endpoints
# ---------------------------------------------------------------------------


@app.get("/health")
def health():
    gpus = _gpu_info()
    num_nodes = int(os.environ.get("NUM_NODES", "1"))
    node_rank = int(os.environ.get("NODE_RANK", "0"))
    resp: dict[str, Any] = {"status": "ok", "num_gpus": len(gpus), "gpus": gpus}
    if num_nodes > 1:
        resp["cluster"] = {
            "num_nodes": num_nodes,
            "node_rank": node_rank,
            "master_addr": os.environ.get("MASTER_ADDR", ""),
            "master_port": os.environ.get("MASTER_PORT", "29500"),
        }
    return resp


@app.get("/status", dependencies=[Depends(verify_secret)])
def get_status():
    return state.to_dict()


@app.post("/train", dependencies=[Depends(verify_secret)])
def start_training(req: TrainRequest):
    if state.status == "running":
        raise HTTPException(409, "Training already in progress")

    config = req.model_dump()
    if not config.get("dataset") and not Path("/workspace/data/train.jsonl").exists():
        raise HTTPException(
            400,
            "No dataset specified and no train.jsonl found. "
            "Either set 'dataset' to a HuggingFace ID or upload a JSONL file first.",
        )

    global _training_thread
    thread = threading.Thread(
        target=_run_training, args=(config,), daemon=False, name="training-main"
    )
    _training_thread = thread
    thread.start()
    return {"message": "Training started", "config": config}


@app.get("/train/config")
def get_train_config():
    """Return the full training configuration schema with defaults, types, and descriptions.

    No auth required so dashboards can populate forms before the user enters a secret.
    """
    schema = TrainRequest.model_json_schema()
    props = schema.get("properties", {})

    fields: list[dict] = []
    for name, info in props.items():
        field_type = info.get("type")
        any_of = info.get("anyOf")
        if not field_type and any_of:
            types = [t.get("type") for t in any_of if t.get("type") and t.get("type") != "null"]
            field_type = types[0] if types else "string"
            nullable = any(t.get("type") == "null" for t in any_of)
        else:
            nullable = False

        entry: dict[str, Any] = {
            "name": name,
            "type": field_type or "string",
            "nullable": nullable,
            "default": info.get("default"),
            "description": info.get("description", ""),
        }
        if "minimum" in info:
            entry["min"] = info["minimum"]
        if "exclusiveMinimum" in info:
            entry["exclusive_min"] = info["exclusiveMinimum"]
        if "maximum" in info:
            entry["max"] = info["maximum"]
        if "enum" in info:
            entry["options"] = info["enum"]

        fields.append(entry)

    defaults = TrainRequest().model_dump()
    return {"fields": fields, "defaults": defaults}


@app.post("/stop", dependencies=[Depends(verify_secret)])
def stop_training():
    if state.status != "running" or not state.pid:
        if not _training_done.is_set():
            return {
                "message": "Training finished but HF push still in progress — container will stay alive"
            }
        raise HTTPException(400, "No training in progress")
    try:
        os.kill(state.pid, signal.SIGTERM)
        state.status = "stopped"
        state.finished_at = datetime.now(timezone.utc).isoformat()
        return {
            "message": "Training stop signal sent (HF push will still complete before container exits)"
        }
    except ProcessLookupError:
        state.status = "idle"
        return {"message": "Process already exited"}


@app.post("/upload/dataset", dependencies=[Depends(verify_secret)])
async def upload_dataset(
    train_file: UploadFile = File(...),
    test_file: UploadFile | None = File(None),
):
    train_path = DATA_DIR / "train.jsonl"
    with open(train_path, "wb") as f:
        shutil.copyfileobj(train_file.file, f)
    result = {"train_file": str(train_path), "train_size": train_path.stat().st_size}

    if test_file:
        test_path = DATA_DIR / "test.jsonl"
        with open(test_path, "wb") as f:
            shutil.copyfileobj(test_file.file, f)
        result["test_file"] = str(test_path)
        result["test_size"] = test_path.stat().st_size

    return result


@app.post("/upload/config", dependencies=[Depends(verify_secret)])
async def upload_config(config_file: UploadFile = File(...)):
    dest = CONFIG_DIR / config_file.filename
    with open(dest, "wb") as f:
        shutil.copyfileobj(config_file.file, f)
    return {"config_file": str(dest), "size": dest.stat().st_size}


@app.get("/logs", dependencies=[Depends(verify_secret)])
def get_logs(lines: int = 100):
    if not LOG_FILE.exists():
        return {"logs": ""}
    all_lines = LOG_FILE.read_text().splitlines()
    return {"logs": "\n".join(all_lines[-lines:])}


@app.get("/checkpoints", dependencies=[Depends(verify_secret)])
def list_checkpoints():
    checkpoints = []
    for d in sorted(OUTPUT_DIR.glob("*/checkpoint-*")):
        checkpoints.append(
            {
                "path": str(d),
                "name": d.name,
                "run": d.parent.name,
            }
        )
    for d in sorted(OUTPUT_DIR.glob("checkpoint-*")):
        checkpoints.append(
            {
                "path": str(d),
                "name": d.name,
                "run": "root",
            }
        )
    return {"checkpoints": checkpoints}


def _detect_gpu_count() -> int:
    try:
        out = subprocess.check_output(["nvidia-smi", "-L"], text=True)
        count = len([l for l in out.strip().splitlines() if l.strip()])
        return max(count, 1)
    except Exception:
        return 1


def _gpu_info():
    try:
        out = subprocess.check_output(
            [
                "nvidia-smi",
                "--query-gpu=name,memory.total,memory.used,memory.free",
                "--format=csv,noheader,nounits",
            ],
            text=True,
        )
        gpus = []
        for line in out.strip().splitlines():
            parts = [p.strip() for p in line.split(",")]
            gpus.append(
                {
                    "name": parts[0],
                    "memory_total_mb": int(parts[1]),
                    "memory_used_mb": int(parts[2]),
                    "memory_free_mb": int(parts[3]),
                }
            )
        return gpus
    except Exception:
        return []