hud-python 0.4.35__py3-none-any.whl → 0.4.37__py3-none-any.whl

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
 
@@ -57,7 +58,7 @@ def ensure_vllm_deployed(model_name: str, gpu_type: str = "A100", timeout: int =
                 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,48 +71,71 @@ 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
 
     if not settings.api_key:
         hud_console.error("API key not found")
-        console.print("[yellow]Please set HUD_API_KEY environment variable[/yellow]")
+        console.print(
+            "[yellow]Set it in your environment or run: hud set HUD_API_KEY=your-key-here[/yellow]"
+        )
         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()
@@ -135,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__"
@@ -153,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
@@ -172,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}")
@@ -201,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}")
@@ -221,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}...")
@@ -264,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...")
@@ -292,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)
@@ -306,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:
@@ -351,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()

hud/cli/rl/wait_utils.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import select
+import sys
+import threading
+import time as _time
+from typing import TYPE_CHECKING
+
+from watchfiles import watch
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def wait_for_enter_cancel_or_change(file_path: Path) -> tuple[bool, bool, bool]:
+    """Block until Enter (start), 'q' (cancel), or file change.
+
+    Returns (start_training, cancelled, changed).
+    - start_training: True if Enter (or any non-'q' line on POSIX) was received
+    - cancelled: True if 'q' was received or Ctrl-C
+    - changed: True if the file changed on disk
+    """
+    start_training = False
+    cancelled = False
+    changed = False
+
+    stop_evt: threading.Event = threading.Event()
+    changed_evt: threading.Event = threading.Event()
+
+    def _watcher() -> None:
+        with contextlib.suppress(Exception):
+            for _ in watch(file_path, stop_event=stop_evt, debounce=200):
+                changed_evt.set()
+                break
+
+    t = threading.Thread(target=_watcher, daemon=True)
+    t.start()
+
+    try:
+        if os.name == "nt":
+            import msvcrt  # type: ignore[attr-defined]
+
+            while True:
+                if changed_evt.is_set():
+                    changed = True
+                    break
+
+                if msvcrt.kbhit():
+                    ch = msvcrt.getwch()
+                    if ch in ("\r", "\n"):
+                        start_training = True
+                        break
+                    if ch.lower() == "q":
+                        cancelled = True
+                        break
+                _time.sleep(0.15)
+        else:
+            while True:
+                if changed_evt.is_set():
+                    changed = True
+                    break
+
+                rlist, _, _ = select.select([sys.stdin], [], [], 0.25)
+                if rlist:
+                    line = sys.stdin.readline()
+                    if line is None:
+                        continue
+                    stripped = line.strip().lower()
+                    if stripped == "q":
+                        cancelled = True
+                        break
+                    # Any other (including empty) => start
+                    start_training = True
+                    break
+                _time.sleep(0.05)
+
+    except KeyboardInterrupt:
+        cancelled = True
+    finally:
+        stop_evt.set()
+        with contextlib.suppress(Exception):
+            t.join(timeout=1)
+
+    return start_training, cancelled, changed
+
+
+__all__ = ["wait_for_enter_cancel_or_change"]

hud/cli/tests/test_build.py

@@ -235,14 +235,10 @@ class TestAnalyzeMcpEnvironment:
         # Setup mock client to fail
         mock_client = mock.AsyncMock()
         mock_client_class.return_value = mock_client
-        mock_client.initialize.side_effect = Exception("Connection failed")
+        mock_client.initialize.side_effect = ConnectionError("Connection failed")
 
-        result = await analyze_mcp_environment("test:latest")
-
-        assert result["success"] is False
-        assert result["toolCount"] == 0
-        assert "error" in result
-        assert "Connection failed" in result["error"]
+        with pytest.raises(ConnectionError):
+            await analyze_mcp_environment("test:latest")
 
     @mock.patch("hud.cli.build.MCPClient")
     async def test_analyze_verbose_mode(self, mock_client_class):
@@ -404,23 +400,3 @@ ENV API_KEY
 
         with pytest.raises(typer.Exit):
             build_environment(str(env_dir))
-
-    @mock.patch("hud.cli.build.build_docker_image")
-    @mock.patch("hud.cli.build.analyze_mcp_environment")
-    def test_build_environment_analysis_failure(self, mock_analyze, mock_build, tmp_path):
-        """Test when MCP analysis fails."""
-        env_dir = tmp_path / "test-env"
-        env_dir.mkdir()
-        (env_dir / "pyproject.toml").write_text("[tool.hud]")
-        (env_dir / "Dockerfile").write_text("FROM python:3.11")
-
-        mock_build.return_value = True
-        mock_analyze.return_value = {
-            "success": False,
-            "error": "Connection failed",
-            "toolCount": 0,
-            "tools": [],
-        }
-
-        with pytest.raises(typer.Exit):
-            build_environment(str(env_dir))

hud/cli/tests/test_mcp_server.py

@@ -11,7 +11,6 @@ from hud.cli.dev import (
     create_proxy_server,
     get_docker_cmd,
     get_image_name,
-    inject_supervisor,
     run_mcp_dev_server,
     update_pyproject_toml,
 )
@@ -52,16 +51,6 @@ class TestDockerUtils:
             cmd = get_docker_cmd("test-image:latest")
             assert cmd is None
 
-    def test_inject_supervisor(self) -> None:
-        """Test supervisor injection into Docker CMD."""
-        original_cmd = ["python", "-m", "server"]
-        modified = inject_supervisor(original_cmd)
-
-        assert modified[0] == "sh"
-        assert modified[1] == "-c"
-        assert "watchfiles" in modified[2]
-        assert "python -m server" in modified[2]
-
 
 class TestImageResolution:
     """Test image name resolution."""
@@ -90,7 +79,7 @@ image = "my-project:latest"
         test_dir.mkdir()
 
         name, source = get_image_name(str(test_dir))
-        assert name == "hud-my-test-project:dev"
+        assert name == "my-test-project:dev"
         assert source == "auto"
 
     def test_update_pyproject_toml(self, tmp_path: Path) -> None: