hud-python 0.4.11__py3-none-any.whl → 0.4.13__py3-none-any.whl

hud/cli/tests/test_push.py

@@ -5,12 +5,9 @@ from __future__ import annotations
 import base64
 import json
 import subprocess
-from datetime import datetime
-from pathlib import Path
 from unittest import mock
 
 import pytest
-import requests
 import typer
 import yaml
 
@@ -30,7 +27,7 @@ class TestGetDockerUsername:
         # Create mock Docker config
         docker_dir = tmp_path / ".docker"
         docker_dir.mkdir()
-        
+
         config_file = docker_dir / "config.json"
         config = {
             "auths": {
@@ -40,37 +37,31 @@ class TestGetDockerUsername:
             }
         }
         config_file.write_text(json.dumps(config))
-        
+
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             username = get_docker_username()
-        
+
         assert username == "testuser"
 
     def test_get_username_no_config(self, tmp_path):
         """Test when no Docker config exists."""
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             username = get_docker_username()
-        
+
         assert username is None
 
     def test_get_username_token_auth(self, tmp_path):
         """Test skipping token-based auth."""
         docker_dir = tmp_path / ".docker"
         docker_dir.mkdir()
-        
+
         config_file = docker_dir / "config.json"
-        config = {
-            "auths": {
-                "docker.io": {
-                    "auth": base64.b64encode(b"token:xyz").decode()
-                }
-            }
-        }
+        config = {"auths": {"docker.io": {"auth": base64.b64encode(b"token:xyz").decode()}}}
         config_file.write_text(json.dumps(config))
-        
+
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             username = get_docker_username()
-        
+
         assert username is None
 
     @mock.patch("subprocess.run")
@@ -78,20 +69,20 @@ class TestGetDockerUsername:
         """Test getting username from credential helper."""
         docker_dir = tmp_path / ".docker"
         docker_dir.mkdir()
-        
+
         config_file = docker_dir / "config.json"
         config = {"credsStore": "desktop"}
         config_file.write_text(json.dumps(config))
-        
+
         # Mock credential helper calls
         mock_run.side_effect = [
             mock.Mock(returncode=0, stdout='{"https://index.docker.io/v1/": "creds"}'),
-            mock.Mock(returncode=0, stdout='{"Username": "helperuser", "Secret": "pass"}')
+            mock.Mock(returncode=0, stdout='{"Username": "helperuser", "Secret": "pass"}'),
         ]
-        
+
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             username = get_docker_username()
-        
+
         assert username == "helperuser"
 
 
@@ -101,16 +92,9 @@ class TestGetDockerImageLabels:
     @mock.patch("subprocess.run")
     def test_get_labels_success(self, mock_run):
         """Test successfully getting image labels."""
-        labels = {
-            "org.hud.manifest.head": "abc123",
-            "org.hud.version": "1.0.0"
-        }
-        mock_run.return_value = mock.Mock(
-            returncode=0,
-            stdout=json.dumps(labels),
-            stderr=""
-        )
-        
+        labels = {"org.hud.manifest.head": "abc123", "org.hud.version": "1.0.0"}
+        mock_run.return_value = mock.Mock(returncode=0, stdout=json.dumps(labels), stderr="")
+
         result = get_docker_image_labels("test:latest")
         assert result == labels
 
@@ -118,7 +102,7 @@ class TestGetDockerImageLabels:
     def test_get_labels_failure(self, mock_run):
         """Test handling failure to get labels."""
         mock_run.side_effect = Exception("Command failed")
-        
+
         result = get_docker_image_labels("test:latest")
         assert result == {}
 
@@ -131,10 +115,10 @@ class TestPushEnvironment:
         """Test pushing when no lock file exists."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         with pytest.raises(typer.Exit) as exc_info:
             push_environment(str(tmp_path))
-        
+
         assert exc_info.value.exit_code == 1
         mock_design.error.assert_called()
 
@@ -145,14 +129,14 @@ class TestPushEnvironment:
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
         mock_settings.api_key = None
-        
+
         # Create lock file
         lock_file = tmp_path / "hud.lock.yaml"
         lock_file.write_text(yaml.dump({"image": "test:latest"}))
-        
+
         with pytest.raises(typer.Exit) as exc_info:
             push_environment(str(tmp_path))
-        
+
         assert exc_info.value.exit_code == 1
 
     @mock.patch("requests.post")
@@ -162,8 +146,14 @@ class TestPushEnvironment:
     @mock.patch("hud.cli.push.settings")
     @mock.patch("hud.cli.push.HUDDesign")
     def test_push_auto_detect_username(
-        self, mock_design_class, mock_settings, mock_get_username,
-        mock_run, mock_popen, mock_post, tmp_path
+        self,
+        mock_design_class,
+        mock_settings,
+        mock_get_username,
+        mock_run,
+        mock_popen,
+        mock_post,
+        tmp_path,
     ):
         """Test auto-detecting Docker username and pushing."""
         # Setup mocks
@@ -172,15 +162,12 @@ class TestPushEnvironment:
         mock_settings.api_key = "test-key"
         mock_settings.hud_telemetry_url = "https://api.hud.test"
         mock_get_username.return_value = "testuser"
-        
+
         # Create lock file
-        lock_data = {
-            "image": "original/image:v1.0",
-            "build": {"version": "0.1.0"}
-        }
+        lock_data = {"image": "original/image:v1.0", "build": {"version": "0.1.0"}}
         lock_file = tmp_path / "hud.lock.yaml"
         lock_file.write_text(yaml.dump(lock_data))
-        
+
         # Mock docker commands
         def mock_run_impl(*args, **kwargs):
             cmd = args[0]
@@ -192,50 +179,48 @@ class TestPushEnvironment:
             elif cmd[1] == "tag":
                 return mock.Mock(returncode=0)
             return mock.Mock(returncode=0)
-        
+
         mock_run.side_effect = mock_run_impl
-        
+
         # Mock docker push
         mock_process = mock.Mock()
         mock_process.stdout = ["Pushing image...", "Push complete"]
         mock_process.wait.return_value = None
         mock_process.returncode = 0
         mock_popen.return_value = mock_process
-        
+
         # Mock registry upload
         mock_post.return_value = mock.Mock(status_code=201)
-        
+
         # Run push
         push_environment(str(tmp_path), yes=True)
-        
+
         # Verify docker commands
         assert mock_run.call_count >= 2
         mock_popen.assert_called_once()
-        
+
         # Verify registry upload
         mock_post.assert_called_once()
         call_args = mock_post.call_args
-        assert "testuser/image:0.1.0" in call_args[0][0]
+        assert "testuser/image%3A0.1.0" in call_args[0][0]
 
     @mock.patch("subprocess.run")
     @mock.patch("hud.cli.push.settings")
     @mock.patch("hud.cli.push.HUDDesign")
-    def test_push_explicit_image(
-        self, mock_design_class, mock_settings, mock_run, tmp_path
-    ):
+    def test_push_explicit_image(self, mock_design_class, mock_settings, mock_run, tmp_path):
         """Test pushing with explicit image name."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
         mock_settings.api_key = "test-key"
-        
+
         # Create lock file
         lock_data = {"image": "local:latest"}
         lock_file = tmp_path / "hud.lock.yaml"
         lock_file.write_text(yaml.dump(lock_data))
-        
+
         # Mock docker inspect for non-existent local image
         mock_run.side_effect = subprocess.CalledProcessError(1, "docker")
-        
+
         with pytest.raises(typer.Exit):
             push_environment(str(tmp_path), image="myrepo/myimage:v2")
 
@@ -243,19 +228,17 @@ class TestPushEnvironment:
     @mock.patch("subprocess.run")
     @mock.patch("hud.cli.push.settings")
     @mock.patch("hud.cli.push.HUDDesign")
-    def test_push_with_tag(
-        self, mock_design_class, mock_settings, mock_run, mock_popen, tmp_path
-    ):
+    def test_push_with_tag(self, mock_design_class, mock_settings, mock_run, mock_popen, tmp_path):
         """Test pushing with explicit tag."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
         mock_settings.api_key = "test-key"
-        
+
         # Create lock file
         lock_data = {"image": "test:latest"}
         lock_file = tmp_path / "hud.lock.yaml"
         lock_file.write_text(yaml.dump(lock_data))
-        
+
         # Mock docker commands
         def mock_run_impl(*args, **kwargs):
             cmd = args[0]
@@ -267,19 +250,19 @@ class TestPushEnvironment:
             elif cmd[1] == "tag":
                 return mock.Mock(returncode=0)
             return mock.Mock(returncode=0)
-        
+
         mock_run.side_effect = mock_run_impl
-        
+
         # Mock docker push
         mock_process = mock.Mock()
         mock_process.stdout = []
         mock_process.wait.return_value = None
         mock_process.returncode = 0
         mock_popen.return_value = mock_process
-        
+
         # Run push
         push_environment(str(tmp_path), image="user/test", tag="v2.0", yes=True)
-        
+
         # Verify tag was used
         tag_call = [c for c in mock_run.call_args_list if c[0][0][1] == "tag"]
         assert len(tag_call) > 0
@@ -291,19 +274,21 @@ class TestPushEnvironment:
         """Test handling Docker push failure."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         # Mock docker push failure
         mock_process = mock.Mock()
         mock_process.stdout = ["Error: access denied"]
         mock_process.wait.return_value = None
         mock_process.returncode = 1
         mock_popen.return_value = mock_process
-        
+
         with mock.patch("hud.cli.push.settings") as mock_settings:
             mock_settings.api_key = "test-key"
-            with mock.patch("subprocess.run"):
-                with pytest.raises(typer.Exit):
-                    push_environment(".", image="test:latest", yes=True)
+            with (
+                mock.patch("subprocess.run"),
+                pytest.raises(typer.Exit),
+            ):
+                push_environment(".", image="test:latest", yes=True)
 
     @mock.patch("hud.cli.push.get_docker_image_labels")
     @mock.patch("subprocess.run")
@@ -316,18 +301,18 @@ class TestPushEnvironment:
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
         mock_settings.api_key = "test-key"
-        
+
         # Create lock file
         lock_data = {"image": "test:latest"}
         lock_file = tmp_path / "hud.lock.yaml"
         lock_file.write_text(yaml.dump(lock_data))
-        
+
         # Mock labels
         mock_get_labels.return_value = {
             "org.hud.manifest.head": "abc123def456",
-            "org.hud.version": "1.2.3"
+            "org.hud.version": "1.2.3",
         }
-        
+
         # Mock docker commands - first inspect succeeds to get to label check
         # Provide explicit image to bypass username check
         def mock_run_impl(*args, **kwargs):
@@ -339,13 +324,13 @@ class TestPushEnvironment:
                 # Fail on tag to exit after labels are checked
                 raise subprocess.CalledProcessError(1, cmd)
             return mock.Mock(returncode=0)
-        
+
         mock_run.side_effect = mock_run_impl
-        
+
         # Provide explicit image to ensure we reach label check
         with pytest.raises(subprocess.CalledProcessError):
             push_environment(str(tmp_path), image="test:v2", verbose=True)
-        
+
         # Verify labels were checked
         mock_get_labels.assert_called_once_with("test:latest")
 
@@ -357,10 +342,8 @@ class TestPushCommand:
         """Test basic push command."""
         with mock.patch("hud.cli.push.push_environment") as mock_push:
             push_command()
-            
-            mock_push.assert_called_once_with(
-                ".", None, None, False, False, False
-            )
+
+            mock_push.assert_called_once_with(".", None, None, False, False, False)
 
     def test_push_command_with_options(self):
         """Test push command with all options."""
@@ -371,9 +354,7 @@ class TestPushCommand:
                 tag="v1.0",
                 sign=True,
                 yes=True,
-                verbose=True
-            )
-            
-            mock_push.assert_called_once_with(
-                "./myenv", "myrepo/myimage", "v1.0", True, True, True
+                verbose=True,
             )
+
+            mock_push.assert_called_once_with("./myenv", "myrepo/myimage", "v1.0", True, True, True)

hud/cli/tests/test_registry.py

@@ -5,10 +5,9 @@ from __future__ import annotations
 from pathlib import Path
 from unittest import mock
 
-import pytest
 import yaml
 
-from hud.cli.registry import (
+from hud.cli.utils.registry import (
     extract_digest_from_image,
     extract_name_and_tag,
     get_registry_dir,
@@ -25,7 +24,7 @@ class TestGetRegistryDir:
         """Test default registry directory."""
         with mock.patch("pathlib.Path.home") as mock_home:
             mock_home.return_value = Path("/home/user")
-            
+
             registry_dir = get_registry_dir()
             assert registry_dir == Path("/home/user/.hud/envs")
 
@@ -119,65 +118,64 @@ class TestExtractNameAndTag:
 class TestSaveToRegistry:
     """Test saving to local registry."""
 
-    @mock.patch("hud.cli.registry.HUDDesign")
+    @mock.patch("hud.cli.utils.registry.HUDDesign")
     def test_save_success(self, mock_design_class, tmp_path):
         """Test successful save to registry."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         # Mock home directory
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
-            lock_data = {
-                "image": "test:latest@sha256:abc123",
-                "tools": ["tool1", "tool2"]
-            }
-            
+            lock_data = {"image": "test:latest@sha256:abc123", "tools": ["tool1", "tool2"]}
+
             result = save_to_registry(lock_data, "test:latest@sha256:abc123def456789")
-            
+
             assert result is not None
             assert result.exists()
             assert result.name == "hud.lock.yaml"
-            
+
             # Verify content
             with open(result) as f:
                 saved_data = yaml.safe_load(f)
             assert saved_data == lock_data
-            
+
             # Verify directory structure
             assert result.parent.name == "abc123def456"
-            
+
             mock_design.success.assert_called_once()
 
-    @mock.patch("hud.cli.registry.HUDDesign")
+    @mock.patch("hud.cli.utils.registry.HUDDesign")
     def test_save_verbose(self, mock_design_class, tmp_path):
         """Test save with verbose output."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             lock_data = {"image": "test:v1"}
-            
+
             result = save_to_registry(lock_data, "test:v1", verbose=True)
-            
+
             assert result is not None
             # Should show verbose info
             assert mock_design.info.call_count >= 1
 
-    @mock.patch("hud.cli.registry.HUDDesign")
+    @mock.patch("hud.cli.utils.registry.HUDDesign")
     def test_save_failure(self, mock_design_class):
         """Test handling save failure."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         # Mock file operations to fail
-        with mock.patch("builtins.open", side_effect=IOError("Permission denied")):
-            with mock.patch("pathlib.Path.home", return_value=Path("/tmp")):
-                lock_data = {"image": "test:latest"}
-                
-                result = save_to_registry(lock_data, "test:latest", verbose=True)
-                
-                assert result is None
-                mock_design.warning.assert_called_once()
+        with (
+            mock.patch("builtins.open", side_effect=OSError("Permission denied")),
+            mock.patch("pathlib.Path.home", return_value=Path("/tmp")),
+        ):
+            lock_data = {"image": "test:latest"}
+
+            result = save_to_registry(lock_data, "test:latest", verbose=True)
+
+            assert result is None
+            mock_design.warning.assert_called_once()
 
 
 class TestLoadFromRegistry:
@@ -190,11 +188,11 @@ class TestLoadFromRegistry:
             registry_dir = get_registry_dir()
             digest_dir = registry_dir / "abc123"
             digest_dir.mkdir(parents=True)
-            
+
             lock_data = {"image": "test:latest", "version": "1.0"}
             lock_file = digest_dir / "hud.lock.yaml"
             lock_file.write_text(yaml.dump(lock_data))
-            
+
             # Load it back
             loaded = load_from_registry("abc123")
             assert loaded == lock_data
@@ -211,10 +209,10 @@ class TestLoadFromRegistry:
             registry_dir = get_registry_dir()
             digest_dir = registry_dir / "bad"
             digest_dir.mkdir(parents=True)
-            
+
             lock_file = digest_dir / "hud.lock.yaml"
             lock_file.write_text("invalid: yaml: content:")
-            
+
             loaded = load_from_registry("bad")
             assert loaded is None
 
@@ -232,26 +230,26 @@ class TestListRegistryEntries:
         """Test listing multiple entries."""
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             registry_dir = get_registry_dir()
-            
+
             # Create several entries
             for digest in ["abc123", "def456", "ghi789"]:
                 digest_dir = registry_dir / digest
                 digest_dir.mkdir(parents=True)
                 lock_file = digest_dir / "hud.lock.yaml"
                 lock_file.write_text(f"image: test:{digest}")
-            
+
             # Create a directory without lock file (should be ignored)
             (registry_dir / "nolockfile").mkdir(parents=True)
-            
+
             # Create a file in registry dir (should be ignored)
             (registry_dir / "README.txt").write_text("info")
-            
+
             entries = list_registry_entries()
-            
+
             assert len(entries) == 3
             digests = [entry[0] for entry in entries]
             assert set(digests) == {"abc123", "def456", "ghi789"}
-            
+
             # Verify all paths are lock files
             for _, lock_path in entries:
                 assert lock_path.name == "hud.lock.yaml"

hud/cli/tests/test_utils.py

@@ -7,7 +7,7 @@ from unittest.mock import patch
 
 import pytest
 
-from hud.cli.utils import HINT_REGISTRY, CaptureLogger, Colors, analyze_error_for_hints
+from hud.cli.utils.logging import HINT_REGISTRY, CaptureLogger, Colors, analyze_error_for_hints
 
 
 class TestColors:

hud/cli/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility modules for HUD CLI."""

hud/cli/{docker_utils.py → utils/docker.py}

@@ -81,3 +81,39 @@ def image_exists(image_name: str) -> bool:
         stderr=subprocess.DEVNULL,
     )
     return result.returncode == 0
+
+
+def remove_container(container_name: str) -> bool:
+    """Remove a Docker container by name.
+
+    Args:
+        container_name: Name of the container to remove
+
+    Returns:
+        True if successful or container doesn't exist, False on error
+    """
+    try:
+        subprocess.run(  # noqa: S603
+            ["docker", "rm", "-f", container_name],  # noqa: S607
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,  # Don't raise error if container doesn't exist
+        )
+        return True
+    except Exception:
+        return False
+
+
+def generate_container_name(identifier: str, prefix: str = "hud") -> str:
+    """Generate a safe container name from an identifier.
+
+    Args:
+        identifier: Image name or other identifier
+        prefix: Prefix for the container name
+
+    Returns:
+        Safe container name with special characters replaced
+    """
+    # Replace special characters with hyphens
+    safe_name = identifier.replace(":", "-").replace("/", "-").replace("\\", "-")
+    return f"{prefix}-{safe_name}"

hud/cli/{env_utils.py → utils/environment.py}

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import subprocess
 from pathlib import Path
-from typing import Any
 
 import toml
 
@@ -32,7 +31,7 @@ def get_image_name(directory: str | Path, image_override: str | None = None) ->
             if config.get("tool", {}).get("hud", {}).get("image"):
                 return config["tool"]["hud"]["image"], "cache"
         except Exception:
-            pass  # Silent failure, will use auto-generated name
+            design.error("Error loading pyproject.toml")
 
     # Auto-generate with :dev tag
     dir_path = Path(directory).resolve()  # Get absolute path first
@@ -74,7 +73,7 @@ def update_pyproject_toml(directory: str | Path, image_name: str, silent: bool =
 
 def build_environment(directory: str | Path, image_name: str, no_cache: bool = False) -> bool:
     """Build Docker image for an environment.
-    
+
     Returns:
         True if build succeeded, False otherwise
     """
@@ -112,7 +111,7 @@ def image_exists(image_name: str) -> bool:
 
 def is_environment_directory(path: str | Path) -> bool:
     """Check if a path looks like an environment directory.
-    
+
     An environment directory should have:
     - A Dockerfile
     - A pyproject.toml file
@@ -121,13 +120,14 @@ def is_environment_directory(path: str | Path) -> bool:
     dir_path = Path(path)
     if not dir_path.is_dir():
         return False
-    
+
     # Must have Dockerfile
     if not (dir_path / "Dockerfile").exists():
         return False
-        
+
     # Must have pyproject.toml
     if not (dir_path / "pyproject.toml").exists():
+        design.error("pyproject.toml not found")
         return False
-        
+
     return True