hud-python 0.4.36__py3-none-any.whl → 0.4.38__py3-none-any.whl

hud/cli/rl/local_runner.py

@@ -30,6 +30,7 @@ def run_local_training(
     model: str | None,
     config_file: Path | None,
     output_dir: str,
+    yes: bool,
     restart: bool,
     verbose: bool,
     no_ddp: bool,
@@ -63,8 +64,11 @@ def run_local_training(
         try:
             import typer
 
-            if not typer.confirm("\nDo you want to continue anyway?", default=False):
-                raise typer.Exit(1)
+            if not yes:
+                if not typer.confirm("\nDo you want to continue anyway?", default=False):
+                    raise typer.Exit(1)
+            else:
+                hud_console.warning("Auto-continuing despite Python 3.13+ (--yes mode)")
         except Exception as e:
             hud_console.warning(f"Failed to confirm: {e}")
             return
@@ -113,7 +117,13 @@ def run_local_training(
         try:
             import typer
 
-            continue_training = typer.confirm("\nContinue with healthy GPUs only?", default=True)
+            if yes:
+                continue_training = True
+                hud_console.info("Auto-continuing with healthy GPUs only (--yes mode)")
+            else:
+                continue_training = typer.confirm(
+                    "\nContinue with healthy GPUs only?", default=True
+                )
         except Exception:
             continue_training = True
 
@@ -200,21 +210,25 @@ def run_local_training(
 
     # Step 3: Model selection (if not provided)
     if model is None and not config_file:
-        model = hud_console.select(
-            "Select a model for RL training:",
-            choices=[
-                {
-                    "name": "Qwen 2.5 VL 3B (Recommended - Vision-Language)",
-                    "value": "Qwen/Qwen2.5-VL-3B-Instruct",
-                },
-                {"name": "Custom model", "value": "custom"},
-            ],
-            default=0,
-        )
+        if yes:
+            model = "Qwen/Qwen2.5-VL-3B-Instruct"  # Default model in yes mode
+            hud_console.info(f"Auto-selecting model: {model} (--yes mode)")
+        else:
+            model = hud_console.select(
+                "Select a model for RL training:",
+                choices=[
+                    {
+                        "name": "Qwen 2.5 VL 3B (Recommended - Vision-Language)",
+                        "value": "Qwen/Qwen2.5-VL-3B-Instruct",
+                    },
+                    {"name": "Custom model", "value": "custom"},
+                ],
+                default=0,
+            )
 
-        if model == "custom":
-            console.print("Enter the model name (HuggingFace ID):")
-            model = input().strip()
+            if model == "custom":
+                console.print("Enter the model name (HuggingFace ID):")
+                model = input().strip()
 
     # Validate model is a VL model (whether provided via CLI or selected)
     if model:
@@ -277,6 +291,7 @@ def run_local_training(
         config, estimated_memory = generate_config_interactive(
             model_name=model,
             presets=presets,
+            yes=yes,
         )
 
     # Step 5: Save temporary config and display summary
@@ -288,8 +303,8 @@ def run_local_training(
     # Display configuration summary
     display_config_summary(config, len(tasks), gpu_info, estimated_memory)
 
-    # Step 6: Ask for confirmation (skip if config was provided)
-    if not config_file:
+    # Step 6: Ask for confirmation (skip if config was provided or in yes mode)
+    if not config_file and not yes:
         console.print("\n[bold yellow]Options:[/bold yellow]")
         console.print("  • Type [green]'start'[/green] to begin training")
         console.print("  • Type [cyan]'edit'[/cyan] to open config in your editor")
@@ -346,7 +361,12 @@ def run_local_training(
                 try:
                     import typer
 
-                    if typer.confirm("Save this configuration for later?", default=True):
+                    if yes:
+                        # Always save in yes mode
+                        config_path = Path("rl_config.json")
+                        save_config(config, config_path)
+                        hud_console.info("Auto-saved configuration (--yes mode)")
+                    elif typer.confirm("Save this configuration for later?", default=True):
                         config_path = Path("rl_config.json")
                         save_config(config, config_path)
                 except Exception as e:
@@ -367,6 +387,10 @@ def run_local_training(
                 console.print(
                     "[red]Invalid choice. Type 'start', 'edit', or 'cancel':[/red] ", end=""
                 )
+    elif yes:
+        # In yes mode, auto-start training
+        hud_console.info("Auto-starting training (--yes mode)")
+        config = load_config(temp_config_path)
     else:
         console.print("\n[dim]Using provided configuration file...[/dim]")
         config = load_config(temp_config_path)

hud/cli/rl/remote_runner.py

@@ -6,14 +6,15 @@ This module implements the new interactive flow for RL training.
 
 from __future__ import annotations
 
-import os
-import subprocess
 import time
 import uuid
 from pathlib import Path
 
 from rich.console import Console
 
+from hud.cli.rl.celebrate import show_confetti_async
+from hud.cli.rl.viewer import show_json_interactive
+from hud.cli.rl.wait_utils import wait_for_enter_cancel_or_change
 from hud.utils.hud_console import hud_console
 from hud.utils.tasks import load_tasks
 
@@ -51,13 +52,13 @@ def ensure_vllm_deployed(model_name: str, gpu_type: str = "A100", timeout: int =
     hud_console.info("Waiting for vLLM server to be ready...")
     start_time = time.time()
     with hud_console.progress() as progress:
-        progress.update("Checking deployment status (see live status on https://app.hud.so/models)")
+        progress.update("Checking deployment status (see live status on https://hud.so/models)")
         while True:
             if time.time() - start_time > timeout:
                 hud_console.error("Timeout waiting for vLLM deployment")
                 raise ValueError("vLLM deployment timeout")
             info = rl_api.get_model(model_name)
-            if info.vllm_url or info.status == "ready":
+            if info.status == "ready":
                 hud_console.success(
                     f"vLLM server ready at http://rl.hud.so/v1/models/{model_name}/vllm"
                 )
@@ -70,6 +71,7 @@ def run_remote_training(
     model: str | None,
     config_file: Path | None,
     output_dir: str,
+    yes: bool = False,
 ) -> None:
     """Run RL training remotely via the API server following the new interactive flow."""
     from hud.settings import settings
@@ -81,39 +83,59 @@ def run_remote_training(
         )
         raise ValueError("API key not found")
 
-    # Step 1: CONFIRMATION - Load tasks and show example
+    # Step 1: CONFIRMATION - Load tasks
     if tasks_file:
-        tasks = load_tasks(tasks_file)
+        tasks: list[Task] = load_tasks(tasks_file)  # type: ignore[assignment]
+        # Resolve tasks immediately after loading (validate + fill defaults)
+        from hud.types import Task
+
+        resolved_tasks: list[dict] = []
+        for t in tasks:
+            try:
+                resolved = Task(**t.model_dump()).model_dump()
+            except Exception:
+                resolved = t.model_dump()
+            resolved_tasks.append(resolved)
+
+        # Preview resolved task
+        if resolved_tasks and not yes:
+            try:
+                show_json_interactive(resolved_tasks[0], title="Task Preview")
+            except Exception as e:
+                hud_console.warning(f"Interactive viewer failed: {e}")
     else:
         raise ValueError("Tasks file not found")
 
     # Show example task for confirmation
-    hud_console.section_title("Example Task from Dataset")
-
-    if tasks:
-        # Display task with truncated values
-        task_data = tasks[0].model_dump()
-        truncated_data = {}
-        max_value_length = 120  # Maximum characters to show per line
-
-        for key, value in task_data.items():
-            value_str = str(value)
-            if len(value_str) > max_value_length:
-                truncated_data[key] = value_str[:max_value_length] + "..."
-            else:
-                truncated_data[key] = value_str
-
-        hud_console.key_value_table(truncated_data)
-
-        if not hud_console.confirm("Proceed with training on this dataset?", default=True):
-            hud_console.error("Training cancelled")
-            return
+    # hud_console.section_title("Example Task from Dataset")
+
+    # if tasks:
+    #     # Display task with truncated values
+    #     try:
+    #         task_data = resolved_tasks[0]
+    #     except Exception:
+    #         task_data = tasks[0].model_dump()
+    #     truncated_data = {}
+    #     max_value_length = 120  # Maximum characters to show per line
+
+    #     for key, value in task_data.items():
+    #         value_str = str(value)
+    #         if len(value_str) > max_value_length:
+    #             truncated_data[key] = value_str[:max_value_length] + "..."
+    #         else:
+    #             truncated_data[key] = value_str
+
+    #     hud_console.key_value_table(truncated_data)
+
+    #     if not hud_console.confirm("Proceed with training on this dataset?", default=True):
+    #         hud_console.error("Training cancelled")
+    #         return
 
     # Step 2: MODEL SELECTION
     hud_console.section_title("Model Selection")
 
     # Fetch existing models
-    hud_console.info("Fetching your models from https://app.hud.so/models")
+    hud_console.info("Fetching your models from https://hud.so/models")
 
     try:
         models = rl_api.list_models()
@@ -137,7 +159,11 @@ def run_remote_training(
             choices.append({"name": "Create new model", "value": "__new__"})
 
             if not model:
-                if choices:
+                if yes:
+                    # In yes mode, always create a new model to avoid conflicts
+                    selected = "__new__"
+                    hud_console.info("Auto-creating new model (--yes mode)")
+                elif choices:
                     selected = hud_console.select("Select a model:", choices=choices)
                 else:
                     selected = "__new__"
@@ -155,14 +181,18 @@ def run_remote_training(
             hud_console.info("Creating new model...")
 
             # Ask for model type
-            model_type = hud_console.select(
-                "Select base model type:",
-                choices=[
-                    {"name": "Qwen2.5-VL-3B-Instruct", "value": "Qwen/Qwen2.5-VL-3B-Instruct"},
-                    # {"name": "Qwen2.5-VL-7B-Instruct", "value": "Qwen/Qwen2.5-VL-7B-Instruct"},
-                ],
-                default=0,
-            )
+            if yes:
+                model_type = "Qwen/Qwen2.5-VL-3B-Instruct"  # Default model in yes mode
+                hud_console.info(f"Auto-selecting base model: {model_type} (--yes mode)")
+            else:
+                model_type = hud_console.select(
+                    "Select base model type:",
+                    choices=[
+                        {"name": "Qwen2.5-VL-3B-Instruct", "value": "Qwen/Qwen2.5-VL-3B-Instruct"},
+                        # {"name": "Qwen2.5-VL-7B-Instruct", "value": "Qwen/Qwen2.5-VL-7B-Instruct"}, # noqa: E501
+                    ],
+                    default=0,
+                )
             from rich.prompt import Prompt
 
             # Ask for model name
@@ -174,9 +204,13 @@ def run_remote_training(
                 default_name = f"{base_default}-{suffix}"
                 suffix += 1
 
-            hud_console.info(f"Enter model name (default: {default_name}):")
-            model_name = Prompt.ask("Model name", default=default_name)
-            model_name = model_name.replace("/", "-").lower()
+            if yes:
+                model_name = default_name
+                hud_console.info(f"Auto-using model name: {model_name} (--yes mode)")
+            else:
+                hud_console.info(f"Enter model name (default: {default_name}):")
+                model_name = Prompt.ask("Model name", default=default_name)
+                model_name = model_name.replace("/", "-").lower()
 
             # Create the model with retry on name conflict
             hud_console.info(f"Creating model: {model_name}")
@@ -203,7 +237,11 @@ def run_remote_training(
                     try:
                         from rich.prompt import Prompt as _Prompt
 
-                        chosen = _Prompt.ask("Use different name", default=alt_name)
+                        if yes:
+                            chosen = alt_name
+                            hud_console.info(f"Auto-using suggested name: {chosen} (--yes mode)")
+                        else:
+                            chosen = _Prompt.ask("Use different name", default=alt_name)
                         chosen = chosen.replace("/", "-").lower()
                         rl_api.create_model(chosen, model_type)
                         hud_console.success(f"Created model: {chosen}")
@@ -223,7 +261,11 @@ def run_remote_training(
 
             # Check if model is in training
             if model_info.status == "training":
-                if hud_console.confirm(
+                if yes:
+                    # In yes mode, skip training if model is already training
+                    hud_console.warning(f"{model_name} is already training, skipping (--yes mode)")
+                    return
+                elif hud_console.confirm(
                     f"{model_name} is currently training. Stop current training?", default=False
                 ):
                     hud_console.info(f"Stopping training for {model_name}...")
@@ -266,25 +308,33 @@ def run_remote_training(
 
         # console.print(gpu_table)
 
-        gpu_choice = hud_console.select(
-            "Select GPU type:",
-            choices=[
-                {"name": "A100 80GB", "value": "A100"},
-                {"name": "H100 80GB", "value": "H100"},
-            ],
-            default=0,
-        )
+        if yes:
+            gpu_choice = "A100"  # Default GPU in yes mode
+            hud_console.info(f"Auto-selecting GPU: {gpu_choice} 80GB (--yes mode)")
+        else:
+            gpu_choice = hud_console.select(
+                "Select GPU type:",
+                choices=[
+                    {"name": "A100 80GB", "value": "A100"},
+                    {"name": "H100 80GB", "value": "H100"},
+                ],
+                default=0,
+            )
 
-        num_gpus = hud_console.select(
-            "Number of GPUs:",
-            choices=[
-                {"name": "1 GPU", "value": 1},
-                {"name": "2 GPUs", "value": 2},
-                {"name": "4 GPUs", "value": 4},
-                {"name": "8 GPUs", "value": 8},
-            ],
-            default=1,
-        )
+        if yes:
+            num_gpus = 1  # Default to 1 GPU in yes mode
+            hud_console.info(f"Auto-selecting {num_gpus} GPU(s) (--yes mode)")
+        else:
+            num_gpus = hud_console.select(
+                "Number of GPUs:",
+                choices=[
+                    {"name": "1 GPU", "value": 1},
+                    {"name": "2 GPUs", "value": 2},
+                    {"name": "4 GPUs", "value": 4},
+                    {"name": "8 GPUs", "value": 8},
+                ],
+                default=1,
+            )
 
         # Generate config with presets
         hud_console.info("Generating training configuration...")
@@ -294,6 +344,7 @@ def run_remote_training(
         config, _ = generate_config_interactive(
             model_name=model_info.base_model,
             presets=presets,
+            yes=yes,
         )
 
         # Use a short label for tasks (avoid full absolute paths)
@@ -308,39 +359,61 @@ def run_remote_training(
 
         config.job_name = f"RL {model_name} on {tasks_label}"
 
-        # Save config for editing
+        # Save config so user can review/edit externally
         temp_config_path = Path(f".rl_config_temp_{model_name}.json")
         save_config(config, temp_config_path)
 
-        # Ask to edit config
+        # Interactive review loop: show preview, allow external edits, press Enter to start
         hud_console.info(
             f"Using training configuration from [underline cyan]{temp_config_path.absolute()}[/underline cyan]"  # noqa: E501
         )
-        edit_choice = hud_console.select(
-            "Would you like to start training?",
-            choices=[
-                {"name": "🚀 Start training!", "value": "start"},
-                {"name": "✏️  Review configuration", "value": "edit"},
-                {"name": "❌ Cancel", "value": "cancel"},
-            ],
-        )
-
-        if edit_choice == "cancel":
-            hud_console.error("Training cancelled")
-            return
-        elif edit_choice == "edit":
-            # Open editor
-            editor = os.environ.get("EDITOR", "nano")
-            hud_console.info(f"Opening {editor} to edit configuration...")
 
+        if yes:
+            # In yes mode, skip the interactive review loop
+            hud_console.info("Auto-accepting config (--yes mode)")
+            # Still show the config briefly
             try:
-                subprocess.run([editor, str(temp_config_path)], check=True)  # noqa: S603
-                # Reload config
-                config = load_config(temp_config_path)
-                hud_console.success("Configuration updated")
+                show_json_interactive(
+                    config.to_dict() if hasattr(config, "to_dict") else {},
+                    title="RL Config Preview",
+                    prompt=False,
+                )
             except Exception as e:
-                hud_console.error(f"Failed to edit config: {e}")
-                return
+                hud_console.warning(f"Interactive viewer failed: {e}")
+        else:
+            while True:
+                # Reload latest config from file each cycle
+                try:
+                    config = load_config(temp_config_path)
+                except Exception as e:
+                    hud_console.warning(f"Failed to load config from disk, using in-memory: {e}")
+
+                # Preview current config (no extra prompt here; main loop handles start/cancel)
+                try:
+                    show_json_interactive(
+                        config.to_dict() if hasattr(config, "to_dict") else {},
+                        title="RL Config Preview",
+                        prompt=False,
+                    )
+                except Exception as e:
+                    hud_console.warning(f"Interactive viewer failed: {e}")
+
+                console.print(
+                    "\n[dim]Edit the config file above if needed, then save.[/dim]\n"
+                    "[bold]Press Enter to start training[/bold], or press 'q' to cancel."
+                )
+
+                start_training, cancelled, changed = wait_for_enter_cancel_or_change(
+                    temp_config_path
+                )
+
+                if cancelled:
+                    hud_console.error("Training cancelled")
+                    return
+                if start_training:
+                    break  # proceed
+                if changed:
+                    hud_console.info("Detected configuration changes. Reloading preview...")
 
         config_dict = config.to_dict()
     else:
@@ -353,17 +426,21 @@ def run_remote_training(
 
     # Launch training
     try:
+        # Little celebration before launching
+        try:
+            show_confetti_async(console)
+        except Exception:
+            hud_console.info("Launching training...")
+
         rl_api.launch_training(
             model_name=model_name,
             config=config_dict,
-            tasks=[task.model_dump() for task in tasks],
+            tasks=resolved_tasks,
             gpu_type=gpu_choice,
             gpu_count=int(num_gpus),
         )
 
-        hud_console.success("Training Started Successfully!")
-
-        hud_console.info(f"See your model {model_name} training on https://app.hud.so/models")
+        hud_console.info(f"Your model {model_name} has started training")
         hud_console.hint("Launch another training run via: hud rl <tasks_file>")
         hud_console.hint("Or evaluate the model via: hud eval <tasks_file>")
 

hud/cli/rl/viewer.py

@@ -0,0 +1,141 @@
+"""Inline JSON preview with expandable view for RL flow.
+
+Uses minimal terminal interaction for inline display.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from blessed import Terminal
+from rich.console import Console
+from rich.json import JSON as RichJSON
+from rich.panel import Panel
+from rich.table import Table
+
+
+def _mask_secrets(value: Any) -> Any:
+    """Recursively mask common secret-looking values."""
+    secret_keys = {"authorization", "api-key", "apikey", "token", "secret", "password"}
+
+    def _is_secret_key(k: str) -> bool:
+        lowered = k.lower()
+        if lowered in secret_keys:
+            return True
+        return any(s in lowered for s in ["api", "key", "token", "secret", "password"])
+
+    if isinstance(value, dict):
+        result: dict[str, Any] = {}
+        for k, v in value.items():
+            if _is_secret_key(str(k)) and isinstance(v, str) and v:
+                prefix = v[:4]
+                suffix = v[-4:] if len(v) > 8 else ""
+                result[k] = f"{prefix}…{suffix}"
+            else:
+                result[k] = _mask_secrets(v)
+        return result
+    if isinstance(value, list):
+        return [_mask_secrets(v) for v in value]
+    return value
+
+
+def _truncate_value(value: Any, max_len: int = 60) -> str:
+    """Truncate a value for preview display."""
+    if isinstance(value, str):
+        if len(value) > max_len:
+            return value[:max_len] + "…"
+        return value
+    elif isinstance(value, (dict, list)):
+        s = json.dumps(value, separators=(",", ":"))
+        if len(s) > max_len:
+            return s[:max_len] + "…"
+        return s
+    else:
+        return str(value)
+
+
+def show_json_interactive(
+    data: Any,
+    *,
+    title: str | None = None,
+    max_string_len: int = 60,
+    prompt: bool = True,
+    initial_expanded: bool = False,
+) -> None:
+    """Display JSON inline with keyboard-based expand/collapse."""
+    console = Console()
+    safe_data = _mask_secrets(data)
+
+    # Create preview table
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_column("Key", style="cyan", no_wrap=True)
+    table.add_column("Value", style="green")
+
+    if title:
+        console.print(f"\n[bold cyan]{title}[/bold cyan]")
+
+    # Show preview
+    if isinstance(safe_data, dict):
+        items = list(safe_data.items())
+        for _, (key, value) in enumerate(items[:5]):
+            truncated = _truncate_value(value, max_string_len)
+            table.add_row(key + ":", truncated)
+
+        if len(items) > 5:
+            table.add_row("", f"[dim]... and {len(items) - 5} more items[/dim]")
+    else:
+        table.add_row("", _truncate_value(safe_data, max_string_len))
+
+    # Display with border
+    if not initial_expanded:
+        console.print(Panel(table, expand=False, border_style="dim"))
+    else:
+        # Expanded view
+        if title:
+            console.rule(f"[bold cyan]{title} (expanded)[/bold cyan]")
+        try:
+            console.print(RichJSON.from_data(safe_data))
+        except Exception:
+            console.print(json.dumps(safe_data, indent=2))
+
+    if not prompt:
+        console.print()
+        return
+
+    # Prompt for expansion (interactive mode)
+    console.print("[dim]Press 'e' to expand, Enter to continue[/dim] ", end="")
+
+    try:
+        term = Terminal()
+        with term.cbreak():
+            key = term.inkey(timeout=30)  # 30 second timeout
+            if key and key.lower() == "e":
+                console.print()  # New line
+                if title:
+                    console.rule(f"[bold cyan]{title} (expanded)[/bold cyan]")
+
+                try:
+                    console.print(RichJSON.from_data(safe_data))
+                except Exception:
+                    console.print(json.dumps(safe_data, indent=2))
+
+                console.print("\n[dim]Press Enter to continue...[/dim]")
+                term.inkey()
+    except Exception:
+        console.print()  # Ensure we're on a new line
+        choice = input().strip().lower()
+
+        if choice == "e":
+            if title:
+                console.rule(f"[bold cyan]{title} (expanded)[/bold cyan]")
+
+            try:
+                console.print(RichJSON.from_data(safe_data))
+            except Exception:
+                console.print(json.dumps(safe_data, indent=2))
+
+            console.print("\n[dim]Press Enter to continue...[/dim]")
+            input()
+
+    console.print()