hud-python 0.4.45__py3-none-any.whl → 0.5.1__py3-none-any.whl

hud/cli/tests/test_mcp_server.py

@@ -2,124 +2,36 @@
 
 from __future__ import annotations
 
-from pathlib import Path  # noqa: TC003
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 import pytest
 
 from hud.cli.dev import (
-    create_proxy_server,
-    get_docker_cmd,
-    get_image_name,
     run_mcp_dev_server,
-    update_pyproject_toml,
 )
 
 
-class TestCreateMCPServer:
-    """Test MCP server creation."""
-
-    def test_create_mcp_server(self) -> None:
-        """Test that MCP server is created with correct configuration."""
-        mcp = create_proxy_server(".", "test-image:latest")
-        assert mcp._mcp_server.name == "HUD Dev Proxy - test-image:latest"
-        # Proxy server doesn't define its own tools, it forwards to Docker containers
-
-
-class TestDockerUtils:
-    """Test Docker utility functions."""
-
-    def test_get_docker_cmd(self) -> None:
-        """Test extracting CMD from Docker image."""
-        with patch("subprocess.run") as mock_run:
-            mock_result = MagicMock()
-            mock_result.returncode = 0
-            mock_result.stdout = '["python", "-m", "server"]'
-            mock_run.return_value = mock_result
-
-            cmd = get_docker_cmd("test-image:latest")
-            assert cmd is None
-
-    def test_get_docker_cmd_failure(self) -> None:
-        """Test handling when Docker inspect fails."""
-        import subprocess
-
-        with patch("subprocess.run") as mock_run:
-            # check=True causes CalledProcessError on non-zero return
-            mock_run.side_effect = subprocess.CalledProcessError(1, "docker inspect")
-
-            cmd = get_docker_cmd("test-image:latest")
-            assert cmd is None
-
-
-class TestImageResolution:
-    """Test image name resolution."""
-
-    def test_get_image_name_override(self) -> None:
-        """Test image name with override."""
-        name, source = get_image_name(".", "custom-image:v1")
-        assert name == "custom-image:v1"
-        assert source == "override"
-
-    def test_get_image_name_from_pyproject(self, tmp_path: Path) -> None:
-        """Test image name from pyproject.toml."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("""
-[tool.hud]
-image = "my-project:latest"
-""")
-
-        name, source = get_image_name(str(tmp_path))
-        assert name == "my-project:latest"
-        assert source == "cache"
-
-    def test_get_image_name_auto_generate(self, tmp_path: Path) -> None:
-        """Test auto-generated image name."""
-        test_dir = tmp_path / "my_test_project"
-        test_dir.mkdir()
-
-        name, source = get_image_name(str(test_dir))
-        assert name == "my-test-project:dev"
-        assert source == "auto"
-
-    def test_update_pyproject_toml(self, tmp_path: Path) -> None:
-        """Test updating pyproject.toml with image name."""
-        pyproject = tmp_path / "pyproject.toml"
-        pyproject.write_text("""
-[project]
-name = "test"
-""")
-
-        update_pyproject_toml(str(tmp_path), "new-image:v1", silent=True)
-
-        content = pyproject.read_text()
-        assert "[tool.hud]" in content
-        assert 'image = "new-image:v1"' in content
-
-
 class TestRunMCPDevServer:
     """Test the main server runner."""
 
     def test_run_dev_server_image_not_found(self) -> None:
-        """Test handling when Docker image doesn't exist."""
-        import click
+        """When using Docker mode without a lock file, exits with typer.Exit(1)."""
+        import typer
 
         with (
-            patch("hud.cli.dev.image_exists", return_value=False),
-            patch("click.confirm", return_value=False),
-            pytest.raises(click.Abort),
+            patch("hud.cli.dev.should_use_docker_mode", return_value=True),
+            patch("hud.cli.dev.Path.cwd"),
+            patch("hud.cli.dev.hud_console"),
+            pytest.raises(typer.Exit),
         ):
             run_mcp_dev_server(
-                directory=".",
-                image="missing:latest",
-                build=False,
-                no_cache=False,
-                transport="http",
+                module=None,
+                stdio=False,
                 port=8765,
-                no_reload=False,
                 verbose=False,
                 inspector=False,
-                no_logs=False,
-                docker_args=[],
                 interactive=False,
+                watch=[],
+                docker=True,
+                docker_args=[],
             )

hud/cli/tests/test_push_happy.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from typing import TYPE_CHECKING
+from unittest.mock import patch
+
+from hud.cli.push import push_environment
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@patch("hud.cli.push.get_docker_username", return_value="tester")
+@patch(
+    "hud.cli.push.get_docker_image_labels",
+    return_value={"org.hud.manifest.head": "abc", "org.hud.version": "0.1.0"},
+)
+@patch("hud.cli.push.requests.post")
+@patch("hud.cli.push.subprocess.Popen")
+@patch("hud.cli.push.subprocess.run")
+def test_push_happy_path(
+    mock_run, mock_popen, mock_post, _labels, _user, tmp_path: Path, monkeypatch
+):
+    # Prepare minimal environment with lock file
+    env_dir = tmp_path
+    (env_dir / "hud.lock.yaml").write_text(
+        "images:\n  local: org/env:latest\nbuild:\n  version: 0.1.0\n"
+    )
+
+    # Provide API key via main settings module
+    monkeypatch.setattr("hud.settings.settings.api_key", "sk-test", raising=False)
+
+    # ensure_built noop - patch from the right module
+    monkeypatch.setattr("hud.cli.utils.env_check.ensure_built", lambda *_a, **_k: {})
+
+    # Mock subprocess.run behavior depending on command
+    def run_side_effect(args, *a, **k):
+        cmd = list(args)
+        # docker inspect checks
+        if cmd[:2] == ["docker", "inspect"]:
+            # For label digest query at end
+            if "--format" in cmd and "{{index .RepoDigests 0}}" in cmd:
+                return SimpleNamespace(returncode=0, stdout="org/env@sha256:deadbeef")
+            # Existence checks succeed
+            return SimpleNamespace(returncode=0, stdout="")
+        # docker tag success
+        if cmd[:2] == ["docker", "tag"]:
+            return SimpleNamespace(returncode=0, stdout="")
+        return SimpleNamespace(returncode=0, stdout="")
+
+    mock_run.side_effect = run_side_effect
+
+    # Mock Popen push pipeline
+    class _Proc:
+        def __init__(self):
+            self.stdout = ["digest: sha256:deadbeef\n", "pushed\n"]
+            self.returncode = 0
+
+        def wait(self):
+            return 0
+
+    mock_popen.return_value = _Proc()
+
+    # Mock registry POST success
+    mock_post.return_value = SimpleNamespace(status_code=201, json=lambda: {"ok": True}, text="")
+
+    # Execute
+    push_environment(
+        directory=str(env_dir), image=None, tag=None, sign=False, yes=True, verbose=False
+    )
+
+    # Lock file updated with pushed entry
+    data = (env_dir / "hud.lock.yaml").read_text()
+    assert "pushed:" in data

hud/cli/tests/test_push_wrapper.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import patch
+
+import pytest
+import typer
+
+from hud.cli.push import push_environment
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@patch("hud.cli.push.ensure_built")
+@patch("hud.cli.push.HUDConsole")
+@patch("hud.cli.push.subprocess.run")
+def test_push_environment_missing_lock_raises(mock_run, mock_console, _ensure, tmp_path: Path):
+    # No hud.lock.yaml → Exit(1)
+    with pytest.raises(typer.Exit):
+        push_environment(
+            directory=str(tmp_path), image=None, tag=None, sign=False, yes=True, verbose=False
+        )

hud/cli/tests/test_registry.py

@@ -189,7 +189,7 @@ class TestLoadFromRegistry:
             digest_dir = registry_dir / "abc123"
             digest_dir.mkdir(parents=True)
 
-            lock_data = {"image": "test:latest", "version": "1.0"}
+            lock_data = {"image": "test:latest", "version": "1.3"}
             lock_file = digest_dir / "hud.lock.yaml"
             lock_file.write_text(yaml.dump(lock_data))
 

hud/cli/tests/test_utils.py

@@ -22,7 +22,7 @@ class TestColors:
         assert Colors.YELLOW == "\033[93m"
         assert Colors.GOLD == "\033[33m"
         assert Colors.RED == "\033[91m"
-        assert Colors.GRAY == "\033[90m"
+        assert Colors.GRAY == "\033[37m"
         assert Colors.ENDC == "\033[0m"
         assert Colors.BOLD == "\033[1m"
 

hud/cli/{rl → utils}/celebrate.py

@@ -1,4 +1,6 @@
 # ruff: noqa: S311
+"""Confetti celebration animation for CLI."""
+
 from __future__ import annotations
 
 import random
@@ -121,20 +123,20 @@ class ConfettiSystem:
         return text
 
 
-def show_confetti(console: Console, seconds: float = 2.5) -> None:
-    """Display celebratory confetti animation inspired by confetty.
+def show_confetti(console: Console, seconds: float = 2.5, message: str | None = None) -> None:
+    """Display celebratory confetti animation.
 
-    Shows "Starting training!" message first, then creates two bursts of
+    Shows a message first, then creates two bursts of
     falling confetti particles that fall away completely.
 
     Args:
         console: Rich console instance
         seconds: Duration to show confetti
+        message: Custom message to display (default: "🎉 Success!")
     """
     # Show celebratory message first
-    console.print(
-        "[bold green]🎉 Starting training! See your model on https://hud.so/models[/bold green]"
-    )
+    msg = message or "[bold green]🎉 Success![/bold green]"
+    console.print(msg)
     time.sleep(0.3)  # Brief pause to see the message
 
     width = min(console.size.width, 120)  # Cap width for performance
@@ -166,22 +168,22 @@ def show_confetti(console: Console, seconds: float = 2.5) -> None:
             frame += 1
 
 
-def show_confetti_async(console: Console, seconds: float = 2.5) -> None:
+def show_confetti_async(console: Console, seconds: float = 2.5, message: str | None = None) -> None:
     """Non-blocking confetti animation that runs in a background thread.
 
-    The animation will run independently while training starts immediately.
+    The animation will run independently while other operations continue.
     """
     import threading
 
     def _run_confetti() -> None:
         try:
-            show_confetti(console, seconds)
+            show_confetti(console, seconds, message)
         except Exception:
-            hud_console.info("Launching training...")
+            hud_console.info("Continuing...")
 
     thread = threading.Thread(target=_run_confetti, daemon=True)
     thread.start()
-    # Don't wait - let training start immediately while confetti plays
+    # Don't wait - let operations continue while confetti plays
 
 
-__all__ = ["show_confetti", "show_confetti_async"]
+__all__ = ["ConfettiSystem", "Particle", "show_confetti", "show_confetti_async"]

hud/cli/utils/config.py

@@ -27,7 +27,9 @@ def parse_env_file(contents: str) -> dict[str, str]:
     """Parse simple KEY=VALUE lines into a dict.
 
     - Ignores blank lines and lines starting with '#'.
-    - Does not perform variable substitution or quoting.
+    - Strips inline comments (# and everything after) from unquoted values.
+    - Respects single and double quoted values (comments inside quotes are preserved).
+    - Does not perform variable substitution.
     """
     data: dict[str, str] = {}
     for raw_line in contents.splitlines():
@@ -39,6 +41,21 @@ def parse_env_file(contents: str) -> dict[str, str]:
         key, value = line.split("=", 1)
         key = key.strip()
         value = value.strip()
+
+        # Handle quoted values - preserve everything inside quotes
+        if value and value[0] in ('"', "'"):
+            quote_char = value[0]
+            # Find the closing quote
+            end_quote = value.find(quote_char, 1)
+            # Extract value without quotes (or strip opening quote if no closing quote)
+            value = value[1:end_quote] if end_quote != -1 else value[1:]
+        else:
+            # Unquoted value - strip inline comments
+            # Find # that's not escaped and treat as comment start
+            comment_idx = value.find("#")
+            if comment_idx != -1:
+                value = value[:comment_idx].rstrip()
+
         if key:
             data[key] = value
     return data

hud/cli/utils/docker.py

@@ -1,4 +1,9 @@
-"""Docker utilities for HUD CLI."""
+"""Docker utilities for HUD CLI.
+
+This module centralizes helpers for constructing Docker commands and
+standardizes environment variable handling for "folder mode" (environment
+directories that include a `.env` file and/or `hud.lock.yaml`).
+"""
 
 from __future__ import annotations
 
@@ -6,6 +11,12 @@ import json
 import platform
 import shutil
 import subprocess
+from pathlib import Path
+
+from .config import parse_env_file
+
+# Note: we deliberately avoid the stricter is_environment_directory() check here
+# to allow folder mode with only a Dockerfile or only a pyproject.toml.
 
 
 def get_docker_cmd(image: str) -> list[str] | None:
@@ -103,6 +114,118 @@ def build_run_command(image: str, docker_args: list[str] | None = None) -> list[
     ]
 
 
+def detect_environment_dir(start_dir: Path | None = None) -> Path | None:
+    """Detect an environment directory for folder mode.
+
+    Detection order:
+    - Current directory containing `hud.lock.yaml`
+    - Parent directory containing `hud.lock.yaml`
+    - Current directory that looks like an environment if it has either a
+      `Dockerfile.hud`, `Dockerfile`, or a `pyproject.toml` (looser than `is_environment_directory`)
+
+    Returns the detected directory path or None if not found.
+    """
+    base = (start_dir or Path.cwd()).resolve()
+
+    # Check current then parent for lock file
+    for candidate in [base, base.parent]:
+        if (candidate / "hud.lock.yaml").exists():
+            return candidate
+
+    # Fallback: treat as env if it has Dockerfile.hud, Dockerfile, or pyproject.toml
+    if (
+        (base / "Dockerfile.hud").exists()
+        or (base / "Dockerfile").exists()
+        or (base / "pyproject.toml").exists()
+    ):
+        return base
+
+    return None
+
+
+def load_env_vars_for_dir(env_dir: Path) -> dict[str, str]:
+    """Load KEY=VALUE pairs from `<env_dir>/.env` if present.
+
+    Returns an empty dict if no file is found or parsing fails.
+    """
+    env_file = env_dir / ".env"
+    if not env_file.exists():
+        return {}
+    try:
+        contents = env_file.read_text(encoding="utf-8")
+        return parse_env_file(contents)
+    except Exception:
+        return {}
+
+
+def build_env_flags(env_vars: dict[str, str]) -> list[str]:
+    """Convert an env dict into a flat list of `-e KEY=VALUE` flags."""
+    flags: list[str] = []
+    for key, value in env_vars.items():
+        flags.extend(["-e", f"{key}={value}"])
+    return flags
+
+
+def create_docker_run_command(
+    image: str,
+    docker_args: list[str] | None = None,
+    env_dir: Path | str | None = None,
+    extra_env: dict[str, str] | None = None,
+    name: str | None = None,
+    interactive: bool = True,
+    remove: bool = True,
+) -> list[str]:
+    """Create a standardized `docker run` command with folder-mode envs.
+
+    - If `env_dir` is provided (or auto-detected), `.env` entries are injected as
+      `-e KEY=VALUE` flags before the image.
+    - `extra_env` allows callers to provide additional env pairs that override
+      variables from `.env`.
+
+    Args:
+        image: Docker image to run
+        docker_args: Additional docker args (volumes, ports, etc.)
+        env_dir: Environment directory to load `.env` from; if None, auto-detect
+        extra_env: Additional env variables to inject (takes precedence)
+        name: Optional container name
+        interactive: Include `-i` flag (default True)
+        remove: Include `--rm` flag (default True)
+
+    Returns:
+        Fully constructed docker run command
+    """
+    cmd: list[str] = ["docker", "run"]
+    if remove:
+        cmd.append("--rm")
+    if interactive:
+        cmd.append("-i")
+    if name:
+        cmd.extend(["--name", name])
+
+    # Load env from `.env` in detected env directory
+    env_dir_path: Path | None = (
+        Path(env_dir).resolve() if isinstance(env_dir, str | Path) else detect_environment_dir()
+    )
+
+    merged_env: dict[str, str] = {}
+    if env_dir_path is not None:
+        merged_env.update(load_env_vars_for_dir(env_dir_path))
+    if extra_env:
+        # Caller-provided values override .env
+        merged_env.update(extra_env)
+
+    # Insert env flags before other args
+    if merged_env:
+        cmd.extend(build_env_flags(merged_env))
+
+    # Add remaining args (volumes, ports, etc.)
+    if docker_args:
+        cmd.extend(docker_args)
+
+    cmd.append(image)
+    return cmd
+
+
 def _emit_docker_hints(error_text: str) -> None:
     """Parse common Docker connectivity errors and print platform-specific hints."""
     from hud.utils.hud_console import hud_console
@@ -189,7 +312,10 @@ def require_docker_running() -> None:
             "Is Docker running? Open Docker Desktop and wait until it reports 'Running'"
         )
         raise typer.Exit(1) from e
-    except Exception as e:
-        hud_console.error(f"Docker check failed: {e}")
+    except typer.Exit:
+        # Propagate cleanly without extra noise; hints already printed above
+        raise
+    except Exception:
+        # Unknown failure - keep output minimal and avoid stack traces
         hud_console.hint("Is the Docker daemon running?")
-        raise typer.Exit(1) from e
+        raise typer.Exit(1)  # noqa: B904

hud/cli/utils/env_check.py

@@ -175,16 +175,16 @@ def ensure_built(env_dir: Path, *, interactive: bool = True) -> dict[str, Any]:
             _print_section("Added files", diffs.get("added", []))
             _print_section("Removed files", diffs.get("removed", []))
 
-            if interactive:
-                if hud_console.confirm("Rebuild now (runs 'hud build')?", default=True):
-                    require_docker_running()
-                    build_environment(str(env_dir), platform="linux/amd64")
-                    with open(lock_path) as f:
-                        lock_data = yaml.safe_load(f) or {}
-                else:
-                    hud_console.hint("Continuing without rebuild; this may use an outdated image.")
+            # if interactive:
+            if hud_console.confirm("Rebuild now (runs 'hud build')?", default=True):
+                require_docker_running()
+                build_environment(str(env_dir), platform="linux/amd64")
+                with open(lock_path) as f:
+                    lock_data = yaml.safe_load(f) or {}
             else:
-                hud_console.hint("Run 'hud build' to update the image before proceeding.")
+                hud_console.hint("Continuing without rebuild; this may use an outdated image.")
+            # else:
+            #     hud_console.hint("Run 'hud build' to update the image before proceeding.")
         elif not stored_hash:
             hud_console.dim_info(
                 "Info",

hud/cli/utils/git.py

@@ -0,0 +1,136 @@
+"""Git utilities for extracting repository information."""
+
+from __future__ import annotations
+
+import logging
+import subprocess
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def get_git_remote_url(cwd: Path | None = None) -> str | None:
+    """
+    Get the git remote origin URL for the current repository.
+
+    Args:
+        cwd: Working directory (defaults to current directory)
+
+    Returns:
+        Git remote URL if available, None otherwise
+    """
+    cwd = cwd or Path.cwd()
+
+    try:
+        # Check if we're in a git repository
+        subprocess.run(
+            ["git", "rev-parse", "--git-dir"],  # noqa: S607
+            cwd=cwd,
+            capture_output=True,
+            check=True,
+        )
+
+        # Get the remote origin URL
+        result = subprocess.run(
+            ["git", "config", "--get", "remote.origin.url"],  # noqa: S607
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        url = result.stdout.strip()
+        if url:
+            return normalize_github_url(url)
+        return None
+
+    except subprocess.CalledProcessError:
+        # Not a git repository or no remote origin
+        return None
+    except Exception as e:
+        logger.debug("Error getting git remote URL: %s", e)
+        return None
+
+
+def normalize_github_url(url: str) -> str:
+    """
+    Normalize various git URL formats to standard HTTPS GitHub URL.
+
+    Examples:
+        git@github.com:user/repo.git -> https://github.com/user/repo
+        https://github.com/user/repo.git -> https://github.com/user/repo
+        git://github.com/user/repo.git -> https://github.com/user/repo
+
+    Args:
+        url: Git remote URL in any format
+
+    Returns:
+        Normalized HTTPS GitHub URL
+    """
+    # Remove trailing .git
+    if url.endswith(".git"):
+        url = url[:-4]
+
+    # Handle SSH format (git@github.com:user/repo)
+    if url.startswith("git@github.com:"):
+        url = url.replace("git@github.com:", "https://github.com/")
+
+    # Handle git:// protocol
+    elif url.startswith("git://"):
+        url = url.replace("git://", "https://")
+
+    # Ensure HTTPS
+    elif not url.startswith("https://") and "github.com:" in url:
+        parts = url.split("github.com:")
+        url = f"https://github.com/{parts[1]}"
+
+    return url
+
+
+def get_git_info(cwd: Path | None = None) -> dict[str, Any]:
+    """
+    Get comprehensive git repository information.
+
+    Args:
+        cwd: Working directory (defaults to current directory)
+
+    Returns:
+        Dictionary with git info including:
+        - remote_url: The remote origin URL
+        - branch: Current branch name
+        - commit: Current commit hash (short)
+    """
+    cwd = cwd or Path.cwd()
+    info: dict[str, Any] = {}
+
+    # Get remote URL
+    info["remote_url"] = get_git_remote_url(cwd)
+
+    try:
+        # Get current branch
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],  # noqa: S607
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        info["branch"] = result.stdout.strip()
+
+        # Get current commit (short hash)
+        result = subprocess.run(
+            ["git", "rev-parse", "--short", "HEAD"],  # noqa: S607
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        info["commit"] = result.stdout.strip()
+
+    except subprocess.CalledProcessError:
+        pass
+    except Exception as e:
+        logger.debug("Error getting git info: %s", e)
+
+    return info