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

hud/cli/pull.py

@@ -154,6 +154,9 @@ def pull_environment(
             # Check for API key (not required for pulling, but good to inform)
             if not settings.api_key:
                 hud_console.info("No HUD API key set (pulling from public registry)")
+                hud_console.info(
+                    "Set it in your environment or run: hud set HUD_API_KEY=your-key-here"
+                )
 
             lock_data = fetch_lock_from_registry(target)
 
@@ -166,6 +169,9 @@ def pull_environment(
                     hud_console.info(
                         "Not found in HUD registry (try setting HUD_API_KEY for private environments)"  # noqa: E501
                     )
+                    hud_console.info(
+                        "Set it in your environment or run: hud set HUD_API_KEY=your-key-here"
+                    )
                 else:
                     hud_console.info("Not found in HUD registry, treating as Docker image")
 

hud/cli/push.py

@@ -11,6 +11,7 @@ import requests
 import typer
 import yaml
 
+from hud.cli.utils.env_check import ensure_built
 from hud.utils.hud_console import HUDConsole
 
 
@@ -131,6 +132,14 @@ def push_environment(
 
     # Find hud.lock.yaml in specified directory
     env_dir = Path(directory)
+
+    # Ensure environment is built and up-to-date (hash-based); interactive prompt
+    try:
+        ensure_built(env_dir, interactive=True)
+    except typer.Exit:
+        raise
+    except Exception as e:
+        HUDConsole().debug(f"Skipping pre-push build check: {e}")
     lock_path = env_dir / "hud.lock.yaml"
 
     if not lock_path.exists():
@@ -144,7 +153,7 @@ def push_environment(
         hud_console.warning("A HUD API key is required to push environments.")
         hud_console.info("\nTo get started:")
         hud_console.info("1. Get your API key at: https://hud.so/settings")
-        hud_console.command_example("export HUD_API_KEY=your-key-here", "Set your API key")
+        hud_console.info("Set it in your environment or run: hud set HUD_API_KEY=your-key-here")
         hud_console.command_example("hud push", "Try again")
         hud_console.info("")
         raise typer.Exit(1)
@@ -414,6 +423,7 @@ def push_environment(
             hud_console.error("Authentication failed")
             hud_console.info("Check your HUD_API_KEY is valid")
             hud_console.info("Get a new key at: https://hud.so/settings")
+            hud_console.info("Set it in your environment or run: hud set HUD_API_KEY=your-key-here")
         elif response.status_code == 403:
             hud_console.error("Permission denied")
             hud_console.info("You may not have access to push to this namespace")

hud/cli/rl/__init__.py

@@ -25,7 +25,7 @@ def rl_command(
     ),
     model: str | None = typer.Argument(
         None,
-        help="Model to train (default: interactive selection)",
+        help="Model to train from https://hud.so/models (default: interactive selection)",
     ),
     config_file: Path | None = typer.Option(  # noqa: B008
         None,
@@ -72,6 +72,12 @@ def rl_command(
         "--local",
         help="Run training locally instead of using remote API server",
     ),
+    yes: bool = typer.Option(
+        False,
+        "--yes",
+        "-y",
+        help="Auto-accept all prompts and use defaults (lazy mode)",
+    ),
     # Internal flag
     skip_vllm_startup: bool = typer.Option(
         False,
@@ -122,8 +128,7 @@ def rl_command(
         try:
             from hud.cli.flows.tasks import convert_tasks_to_remote
 
-            console.print("\n[cyan]Preparing remote training tasks...[/cyan]")
-            console.print("[cyan](build/push if needed)[/cyan]")
+            console.print("[cyan]Preparing remote training tasks...[/cyan]")
             tasks_file = convert_tasks_to_remote(tasks_file)
         except typer.Exit:
             raise
@@ -137,7 +142,11 @@ def rl_command(
             from .remote_runner import run_remote_training
 
             run_remote_training(
-                tasks_file=tasks_file, model=model, config_file=config_file, output_dir=output_dir
+                tasks_file=tasks_file,
+                model=model,
+                config_file=config_file,
+                output_dir=output_dir,
+                yes=yes,
             )
             return
         except Exception as e:
@@ -152,6 +161,7 @@ def rl_command(
         model=model,
         config_file=config_file,
         output_dir=output_dir,
+        yes=yes,
         restart=restart,
         verbose=verbose,
         no_ddp=no_ddp,

hud/cli/rl/celebrate.py

@@ -0,0 +1,187 @@
+# ruff: noqa: S311
+from __future__ import annotations
+
+import random
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, ClassVar
+
+from rich.live import Live
+from rich.text import Text
+
+from hud.utils.hud_console import hud_console
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+
+@dataclass
+class Particle:
+    """A confetti particle with physics."""
+
+    x: float
+    y: float
+    vx: float  # velocity x
+    vy: float  # velocity y
+    char: str
+    color: str
+
+    def update(self, gravity: float = 0.5, fps: float = 30.0) -> None:
+        """Update particle position and velocity."""
+        dt = 1.0 / fps
+        self.x += self.vx * dt
+        self.vy += gravity  # Apply gravity
+        self.y += self.vy * dt
+
+
+class ConfettiSystem:
+    """Minimal confetti system inspired by confetty."""
+
+    # Confetty-style colors
+    COLORS: ClassVar[list[str]] = ["#a864fd", "#29cdff", "#78ff44", "#ff718d", "#fdff6a"]
+    # Confetty-style characters
+    CHARS: ClassVar[list[str]] = ["█", "▓", "▒", "░", "▄", "▀"]
+
+    def __init__(self, width: int, height: int) -> None:
+        self.width = width
+        self.height = height
+        self.particles: list[Particle] = []
+
+    def spawn_burst(self, num_particles: int = 75) -> None:
+        """Spawn a burst of confetti particles from the top center."""
+        center_x = self.width / 2
+
+        for _ in range(num_particles):
+            # Start from top center with some horizontal spread
+            x = center_x + (self.width / 4) * (random.random() - 0.5)
+            y = 0
+
+            # Random velocities - horizontal spread and upward/slight downward initial velocity
+            vx = (random.random() - 0.5) * 100
+            vy = random.random() * 50 - 25  # Some go up first
+
+            particle = Particle(
+                x=x,
+                y=y,
+                vx=vx,
+                vy=vy,
+                char=random.choice(self.CHARS),
+                color=random.choice(self.COLORS),
+            )
+            self.particles.append(particle)
+
+    def update(self) -> None:
+        """Update all particles and remove off-screen ones."""
+        # Update physics
+        for particle in self.particles:
+            particle.update()
+
+        # Remove particles that are off-screen
+        self.particles = [p for p in self.particles if 0 <= p.x < self.width and p.y < self.height]
+
+    def render(self) -> str:
+        """Render the particle system to a string."""
+        # Create empty grid
+        grid = [[" " for _ in range(self.width)] for _ in range(self.height)]
+
+        # Place particles
+        for particle in self.particles:
+            x, y = int(particle.x), int(particle.y)
+            if 0 <= x < self.width and 0 <= y < self.height:
+                grid[y][x] = particle.char
+
+        # Convert to string
+        return "\n".join("".join(row) for row in grid)
+
+    def render_with_colors(self) -> Text:
+        """Render the particle system with colors for Rich."""
+        text = Text()
+
+        # Create empty grid with color info
+        grid: list[list[tuple[str, str] | None]] = [
+            [None for _ in range(self.width)] for _ in range(self.height)
+        ]
+
+        # Place particles with their colors
+        for particle in self.particles:
+            x, y = int(particle.x), int(particle.y)
+            if 0 <= x < self.width and 0 <= y < self.height:
+                grid[y][x] = (particle.char, particle.color)
+
+        # Build colored text
+        for row in grid:
+            for cell in row:
+                if cell:
+                    char, color = cell
+                    text.append(char, style=color)
+                else:
+                    text.append(" ")
+            text.append("\n")
+
+        return text
+
+
+def show_confetti(console: Console, seconds: float = 2.5) -> None:
+    """Display celebratory confetti animation inspired by confetty.
+
+    Shows "Starting training!" message first, then creates two bursts of
+    falling confetti particles that fall away completely.
+
+    Args:
+        console: Rich console instance
+        seconds: Duration to show confetti
+    """
+    # Show celebratory message first
+    console.print(
+        "[bold green]🎉 Starting training! See your model on https://hud.so/models[/bold green]"
+    )
+    time.sleep(0.3)  # Brief pause to see the message
+
+    width = min(console.size.width, 120)  # Cap width for performance
+    height = min(console.size.height - 2, 30)  # Leave room for message
+
+    # Create confetti system
+    system = ConfettiSystem(width, height)
+
+    fps = 30
+    frame_time = 1.0 / fps
+
+    # First burst at the beginning
+    system.spawn_burst(num_particles=60)
+
+    # Track when to spawn second burst
+    second_burst_frame = int(fps * 0.4)  # Second burst after 0.4 seconds
+
+    with Live("", refresh_per_second=fps, console=console, transient=True) as live:
+        frame = 0
+        # Keep running until all particles have fallen off screen
+        while frame < seconds * fps or len(system.particles) > 0:
+            # Spawn second burst
+            if frame == second_burst_frame:
+                system.spawn_burst(num_particles=60)
+
+            system.update()
+            live.update(system.render_with_colors())
+            time.sleep(frame_time)
+            frame += 1
+
+
+def show_confetti_async(console: Console, seconds: float = 2.5) -> None:
+    """Non-blocking confetti animation that runs in a background thread.
+
+    The animation will run independently while training starts immediately.
+    """
+    import threading
+
+    def _run_confetti() -> None:
+        try:
+            show_confetti(console, seconds)
+        except Exception:
+            hud_console.info("Launching training...")
+
+    thread = threading.Thread(target=_run_confetti, daemon=True)
+    thread.start()
+    # Don't wait - let training start immediately while confetti plays
+
+
+__all__ = ["show_confetti", "show_confetti_async"]

hud/cli/rl/config.py

@@ -21,22 +21,29 @@ console = Console()
 def generate_config_interactive(
     model_name: str,
     presets: list[dict[str, Any]],
+    yes: bool = False,
 ) -> tuple[Config, float]:
     """Generate RL training configuration interactively."""
     # Validate model is a VL model
     validate_vl_model(model_name)
 
     # Display preset options
-    display_preset_table(presets, 80.0)  # Assuming A100 80GB
+    if not yes:
+        display_preset_table(presets, 80.0)  # Assuming A100 80GB
 
     # Let user select preset
-    preset_choice = hud_console.select(
-        "Select a training configuration preset:",
-        choices=[{"name": p["name"], "value": i} for i, p in enumerate(presets)],
-        default=1 if len(presets) > 1 else 0,  # Default to "Balanced" if available
-    )
-
-    selected_preset = presets[preset_choice]  # type: ignore
+    if yes:
+        # Use default preset (Balanced if available, otherwise first)
+        preset_choice = 1 if len(presets) > 1 else 0
+        selected_preset = presets[preset_choice]
+        hud_console.info(f"Auto-selecting preset: {selected_preset['name']} (--yes mode)")
+    else:
+        preset_choice = hud_console.select(
+            "Select a training configuration preset:",
+            choices=[{"name": p["name"], "value": i} for i, p in enumerate(presets)],
+            default=1 if len(presets) > 1 else 0,  # Default to "Balanced" if available
+        )
+        selected_preset = presets[preset_choice]  # type: ignore
 
     # Use preset values directly
     max_steps_per_episode = selected_preset["max_steps_per_episode"]

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)