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

hud/cli/push.py

@@ -21,6 +21,7 @@ def _get_response_text(response: requests.Response) -> str:
     except Exception:
         return response.text
 
+
 def get_docker_username() -> str | None:
     """Get the current Docker username if logged in."""
     try:
@@ -53,10 +54,10 @@ def get_docker_username() -> str | None:
                                 username = decoded.split(":", 1)[0]
                                 if username and username != "token":  # Skip token-based auth
                                     return username
-                            except Exception:
-                                pass  # Silent failure, try other methods
-                except Exception:
-                    pass  # Silent failure, try other methods
+                            except Exception:  # noqa: S110
+                                pass
+                except Exception:  # noqa: S110
+                    pass
 
         # Alternative: Check credsStore/credHelpers
         for config_path in config_paths:
@@ -91,12 +92,12 @@ def get_docker_username() -> str | None:
                                             username = cred_data.get("Username", "")
                                             if username and username != "token":
                                                 return username
-                        except Exception:
-                            pass  # Silent failure, try other methods
-                except Exception:
-                    pass  # Silent failure, try other methods
-    except Exception:
-        pass  # Silent failure, try other methods
+                        except Exception:  # noqa: S110
+                            pass
+                except Exception:  # noqa: S110
+                    pass
+    except Exception:  # noqa: S110
+        pass
     return None
 
 
@@ -155,7 +156,7 @@ def push_environment(
     if not local_image and "build" in lock_data:
         # New format might have image elsewhere
         local_image = lock_data.get("image", "")
-    
+
     # Get internal version from lock file
     internal_version = lock_data.get("build", {}).get("version", None)
 
@@ -206,21 +207,25 @@ def push_environment(
         # Handle tag when image is provided
         # Prefer explicit tag over internal version
         final_tag = tag if tag else internal_version
-        
+
         if ":" in image:
             # Image already has a tag
             existing_tag = image.split(":")[-1]
             if existing_tag != final_tag:
                 if tag:
-                    design.warning(f"Image already has tag '{existing_tag}', overriding with '{final_tag}'")
+                    design.warning(
+                        f"Image already has tag '{existing_tag}', overriding with '{final_tag}'"
+                    )
                 else:
-                    design.info(f"Image has tag '{existing_tag}', but using internal version '{final_tag}'")
+                    design.info(
+                        f"Image has tag '{existing_tag}', but using internal version '{final_tag}'"
+                    )
                 image = image.rsplit(":", 1)[0] + f":{final_tag}"
             # else: tags match, no action needed
         else:
             # Image has no tag, append the appropriate one
             image = f"{image}:{final_tag}"
-            
+
         if tag:
             design.info(f"Using specified tag: {tag}")
         else:
@@ -230,7 +235,7 @@ def push_environment(
     # Verify local image exists
     # Extract the tag part (before @sha256:...) for Docker operations
     local_tag = local_image.split("@")[0] if "@" in local_image else local_image
-    
+
     # Also check for version-tagged image if we have internal version
     version_tag = None
     if internal_version and ":" in local_tag:
@@ -246,7 +251,7 @@ def push_environment(
             design.info(f"Found version-tagged image: {version_tag}")
         except subprocess.CalledProcessError:
             pass
-    
+
     if not image_to_push:
         try:
             subprocess.run(["docker", "inspect", local_tag], capture_output=True, check=True)  # noqa: S603, S607
@@ -319,7 +324,7 @@ def push_environment(
     lock_data["image"] = pushed_digest
 
     # Add push information
-    from datetime import datetime, UTC
+    from datetime import UTC, datetime
 
     lock_data["push"] = {
         "source": local_image,
@@ -340,13 +345,20 @@ def push_environment(
         # e.g., "hudpython/test_init:v1.0" -> "hudpython/test_init:v1.0"
         # Use the original image name for the registry path, not the digest
         # The digest might not contain the tag information
-        registry_image = image  # This is the image we tagged and pushed (e.g., hudpython/hud-text-2048:0.1.2)
-        
+        registry_image = (
+            image  # This is the image we tagged and pushed (e.g., hudpython/hud-text-2048:0.1.2)
+        )
+
         # Remove any registry prefix for the HUD registry path
         registry_parts = registry_image.split("/")
         if len(registry_parts) >= 2:
             # Handle docker.io/org/name or just org/name
-            if registry_parts[0] in ["docker.io", "registry-1.docker.io", "index.docker.io", "ghcr.io"]:
+            if registry_parts[0] in [
+                "docker.io",
+                "registry-1.docker.io",
+                "index.docker.io",
+                "ghcr.io",
+            ]:
                 # Remove registry prefix
                 name_with_tag = "/".join(registry_parts[1:])
             elif "." in registry_parts[0] or ":" in registry_parts[0]:
@@ -359,12 +371,12 @@ def push_environment(
             name_with_tag = registry_image
 
         # The image variable already has the tag, no need to add :latest
-        
+
         # Validate the image format
         if not name_with_tag:
             design.warning("Could not determine image name for registry upload")
             raise typer.Exit(0)
-        
+
         # For HUD registry, we need org/name format
         if "/" not in name_with_tag:
             design.warning("Image name must include organization/namespace for HUD registry")

hud/cli/remove.py

@@ -3,14 +3,12 @@
 from __future__ import annotations
 
 import shutil
-from pathlib import Path
 
 import typer
-import yaml
 
 from hud.utils.design import HUDDesign
 
-from .registry import get_registry_dir, list_registry_entries, load_from_registry
+from .utils.registry import get_registry_dir, list_registry_entries, load_from_registry
 
 
 def remove_environment(
@@ -21,18 +19,18 @@ def remove_environment(
     """Remove an environment from the local registry."""
     design = HUDDesign()
     design.header("HUD Environment Removal")
-    
+
     # Find the environment to remove
     found_entry = None
     found_digest = None
-    
+
     # First check if target is a digest
     for digest, lock_file in list_registry_entries():
         if digest.startswith(target):
             found_entry = lock_file
             found_digest = digest
             break
-    
+
     # If not found by digest, search by name
     if not found_entry:
         for digest, lock_file in list_registry_entries():
@@ -42,28 +40,29 @@ def remove_environment(
                     image = lock_data["image"]
                     # Extract name and tag
                     name = image.split("@")[0] if "@" in image else image
-                    if "/" in name:
-                        # Match by repo/name or just name
-                        if target in name or name.endswith(f"/{target}"):
-                            found_entry = lock_file
-                            found_digest = digest
-                            break
-            except Exception:
+                    if "/" in name and (target in name or name.endswith(f"/{target}")):
+                        found_entry = lock_file
+                        found_digest = digest
+                        break
+            except Exception as e:
+                design.error(f"Error loading lock file: {e}")
                 continue
-    
+
     if not found_entry:
         design.error(f"Environment not found: {target}")
         design.info("Use 'hud list' to see available environments")
         raise typer.Exit(1)
-    
+
     # Load and display environment info
     try:
+        if found_digest is None:
+            raise ValueError("Found digest is None")
         lock_data = load_from_registry(found_digest)
         if lock_data:
             image = lock_data.get("image", "unknown")
             metadata = lock_data.get("metadata", {})
             description = metadata.get("description", "No description")
-            
+
             design.section_title("Environment Details")
             design.status_item("Image", image)
             design.status_item("Digest", found_digest)
@@ -72,20 +71,20 @@ def remove_environment(
     except Exception as e:
         if verbose:
             design.warning(f"Could not read environment details: {e}")
-    
+
     # Confirm deletion
     if not yes:
         design.info("")
         if not typer.confirm(f"Remove environment {found_digest}?"):
             design.info("Aborted")
             raise typer.Exit(0)
-    
+
     # Remove the environment directory
     try:
         env_dir = found_entry.parent
         shutil.rmtree(env_dir)
         design.success(f"Removed environment: {found_digest}")
-        
+
         # Check if the image is still available locally
         if lock_data:
             image = lock_data.get("image", "")
@@ -95,7 +94,7 @@ def remove_environment(
                 design.info(f"To remove it, run: [cyan]docker rmi {image.split('@')[0]}[/cyan]")
     except Exception as e:
         design.error(f"Failed to remove environment: {e}")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from e
 
 
 def remove_all_environments(
@@ -105,23 +104,23 @@ def remove_all_environments(
     """Remove all environments from the local registry."""
     design = HUDDesign()
     design.header("Remove All HUD Environments")
-    
+
     registry_dir = get_registry_dir()
     if not registry_dir.exists():
         design.info("No environments found in local registry.")
         return
-    
+
     # Count environments
     entries = list(list_registry_entries())
     if not entries:
         design.info("No environments found in local registry.")
         return
-    
+
     design.warning(f"This will remove {len(entries)} environment(s) from the local registry!")
-    
+
     # List environments that will be removed
     design.section_title("Environments to Remove")
-    for digest, lock_file in entries:
+    for digest, _ in entries:
         try:
             lock_data = load_from_registry(digest)
             if lock_data:
@@ -129,18 +128,18 @@ def remove_all_environments(
                 design.info(f"  • {digest[:12]} - {image}")
         except Exception:
             design.info(f"  • {digest[:12]}")
-    
+
     # Confirm deletion
     if not yes:
         design.info("")
         if not typer.confirm("Remove ALL environments?", default=False):
             design.info("Aborted")
             raise typer.Exit(0)
-    
+
     # Remove all environments
     removed = 0
     failed = 0
-    
+
     for digest, lock_file in entries:
         try:
             env_dir = lock_file.parent
@@ -152,13 +151,13 @@ def remove_all_environments(
             failed += 1
             if verbose:
                 design.error(f"Failed to remove {digest}: {e}")
-    
+
     design.info("")
     if failed == 0:
         design.success(f"Successfully removed {removed} environment(s)")
     else:
         design.warning(f"Removed {removed} environment(s), failed to remove {failed}")
-    
+
     design.info("")
     design.info("Note: Docker images may still exist locally.")
     design.info("To remove them, use: [cyan]docker image prune[/cyan]")
@@ -166,21 +165,16 @@ def remove_all_environments(
 
 def remove_command(
     target: str | None = typer.Argument(
-        None, 
-        help="Environment to remove (digest, name, or 'all' for all environments)"
-    ),
-    yes: bool = typer.Option(
-        False, "--yes", "-y", help="Skip confirmation prompt"
-    ),
-    verbose: bool = typer.Option(
-        False, "--verbose", "-v", help="Show detailed output"
+        None, help="Environment to remove (digest, name, or 'all' for all environments)"
     ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed output"),
 ) -> None:
     """🗑️ Remove HUD environments from local registry.
-    
+
     Removes environment metadata from ~/.hud/envs/
     Note: This does not remove the Docker images.
-    
+
     Examples:
         hud remove abc123              # Remove by digest
         hud remove text_2048           # Remove by name
@@ -193,7 +187,7 @@ def remove_command(
         design.error("Please specify an environment to remove or 'all'")
         design.info("Use 'hud list' to see available environments")
         raise typer.Exit(1)
-    
+
     if target.lower() == "all":
         remove_all_environments(yes, verbose)
     else:

hud/cli/tests/test_analyze.py

@@ -82,6 +82,7 @@ class TestAnalyzeEnvironment:
         with (
             patch("hud.cli.analyze.MCPClient") as MockClient,
             patch("hud.cli.analyze.console") as mock_console,
+            patch("platform.system", return_value="Windows"),
         ):
             # Setup mock client that will raise exception during initialization
             mock_client = MagicMock()
@@ -100,7 +101,7 @@ class TestAnalyzeEnvironment:
             mock_client.initialize.assert_called_once()
             mock_client.shutdown.assert_called_once()
 
-            # Check console printed error hints
+            # Check console printed Windows-specific error hints
             calls = mock_console.print.call_args_list
             assert any("Docker logs may not show on Windows" in str(call) for call in calls)
 

hud/cli/tests/test_analyze_metadata.py

@@ -3,20 +3,17 @@
 from __future__ import annotations
 
 import json
-import os
-import tempfile
-from pathlib import Path
 from unittest import mock
 
 import pytest
 import yaml
 
-from hud.cli.analyze_metadata import (
+from hud.cli.utils.metadata import (
     analyze_from_metadata,
     check_local_cache,
     fetch_lock_from_registry,
 )
-from hud.cli.registry import save_to_registry
+from hud.cli.utils.registry import save_to_registry
 
 
 @pytest.fixture
@@ -79,9 +76,7 @@ class TestFetchLockFromRegistry:
         """Test successful fetch from registry."""
         mock_response = mock.Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {
-            "lock": yaml.dump({"test": "data"})
-        }
+        mock_response.json.return_value = {"lock": yaml.dump({"test": "data"})}
         mock_get.return_value = mock_response
 
         result = fetch_lock_from_registry("test/env:latest")
@@ -93,9 +88,7 @@ class TestFetchLockFromRegistry:
         """Test fetch when response has lock_data key."""
         mock_response = mock.Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {
-            "lock_data": {"test": "data"}
-        }
+        mock_response.json.return_value = {"lock_data": {"test": "data"}}
         mock_get.return_value = mock_response
 
         result = fetch_lock_from_registry("test/env:latest")
@@ -120,10 +113,10 @@ class TestFetchLockFromRegistry:
         mock_get.return_value = mock_response
 
         fetch_lock_from_registry("test/env")
-        
-        # Check that the URL includes :latest
+
+        # Check that the URL includes :latest (URL-encoded)
         call_args = mock_get.call_args
-        assert "test/env:latest" in call_args[0][0]
+        assert "test/env%3Alatest" in call_args[0][0]
 
     @mock.patch("requests.get")
     def test_fetch_lock_failure(self, mock_get):
@@ -150,11 +143,11 @@ class TestCheckLocalCache:
     def test_check_local_cache_found(self, mock_registry_dir, sample_lock_data, monkeypatch):
         """Test finding lock data in local cache."""
         # Mock registry directory
-        monkeypatch.setattr("hud.cli.registry.get_registry_dir", lambda: mock_registry_dir)
-        
+        monkeypatch.setattr("hud.cli.utils.registry.get_registry_dir", lambda: mock_registry_dir)
+
         # Save sample data to registry
         save_to_registry(sample_lock_data, "test/environment:latest", verbose=False)
-        
+
         # Check cache
         result = check_local_cache("test/environment:latest")
         assert result is not None
@@ -162,21 +155,21 @@ class TestCheckLocalCache:
 
     def test_check_local_cache_not_found(self, mock_registry_dir, monkeypatch):
         """Test when lock data not in local cache."""
-        monkeypatch.setattr("hud.cli.registry.get_registry_dir", lambda: mock_registry_dir)
-        
+        monkeypatch.setattr("hud.cli.utils.registry.get_registry_dir", lambda: mock_registry_dir)
+
         result = check_local_cache("nonexistent/env:latest")
         assert result is None
 
     def test_check_local_cache_invalid_yaml(self, mock_registry_dir, monkeypatch):
         """Test when lock file has invalid YAML."""
-        monkeypatch.setattr("hud.cli.registry.get_registry_dir", lambda: mock_registry_dir)
-        
+        monkeypatch.setattr("hud.cli.utils.registry.get_registry_dir", lambda: mock_registry_dir)
+
         # Create invalid lock file
-        digest = "sha256:invalid"
+        digest = "invalid"
         lock_file = mock_registry_dir / digest / "hud.lock.yaml"
         lock_file.parent.mkdir(parents=True)
         lock_file.write_text("invalid: yaml: content:")
-        
+
         result = check_local_cache("test/invalid:latest")
         assert result is None
 
@@ -189,60 +182,60 @@ class TestCheckLocalCache:
 class TestAnalyzeFromMetadata:
     """Test the main analyze_from_metadata function."""
 
-    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
-    @mock.patch("hud.cli.analyze_metadata.console")
+    @mock.patch("hud.cli.utils.metadata.check_local_cache")
+    @mock.patch("hud.cli.utils.metadata.console")
     async def test_analyze_from_local_cache(self, mock_console, mock_check, sample_lock_data):
         """Test analyzing from local cache."""
         mock_check.return_value = sample_lock_data
-        
+
         await analyze_from_metadata("test/env:latest", "json", verbose=False)
-        
+
         mock_check.assert_called_once_with("test/env:latest")
         # Should output JSON
         mock_console.print_json.assert_called_once()
 
-    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
-    @mock.patch("hud.cli.analyze_metadata.fetch_lock_from_registry")
-    @mock.patch("hud.cli.analyze_metadata.save_to_registry")
-    @mock.patch("hud.cli.analyze_metadata.console")
+    @mock.patch("hud.cli.utils.metadata.check_local_cache")
+    @mock.patch("hud.cli.utils.metadata.fetch_lock_from_registry")
+    @mock.patch("hud.cli.utils.registry.save_to_registry")
+    @mock.patch("hud.cli.utils.metadata.console")
     async def test_analyze_from_registry(
         self, mock_console, mock_save, mock_fetch, mock_check, sample_lock_data
     ):
         """Test analyzing from registry when not in cache."""
         mock_check.return_value = None
         mock_fetch.return_value = sample_lock_data
-        
+
         await analyze_from_metadata("test/env:latest", "json", verbose=False)
-        
+
         mock_check.assert_called_once()
         mock_fetch.assert_called_once()
         mock_save.assert_called_once()  # Should save to cache
         mock_console.print_json.assert_called_once()
 
-    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
-    @mock.patch("hud.cli.analyze_metadata.fetch_lock_from_registry")
-    @mock.patch("hud.cli.analyze_metadata.design")
-    @mock.patch("hud.cli.analyze_metadata.console")
+    @mock.patch("hud.cli.utils.metadata.check_local_cache")
+    @mock.patch("hud.cli.utils.metadata.fetch_lock_from_registry")
+    @mock.patch("hud.cli.utils.metadata.design")
+    @mock.patch("hud.cli.utils.metadata.console")
     async def test_analyze_not_found(self, mock_console, mock_design, mock_fetch, mock_check):
         """Test when environment not found anywhere."""
         mock_check.return_value = None
         mock_fetch.return_value = None
-        
+
         await analyze_from_metadata("test/notfound:latest", "json", verbose=False)
-        
+
         # Should show error
         mock_design.error.assert_called_with("Environment metadata not found")
         # Should print suggestions
         mock_console.print.assert_called()
 
-    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
-    @mock.patch("hud.cli.analyze_metadata.console")
+    @mock.patch("hud.cli.utils.metadata.check_local_cache")
+    @mock.patch("hud.cli.utils.metadata.console")
     async def test_analyze_verbose_mode(self, mock_console, mock_check, sample_lock_data):
         """Test verbose mode includes input schemas."""
         mock_check.return_value = sample_lock_data
-        
+
         await analyze_from_metadata("test/env:latest", "json", verbose=True)
-        
+
         # In verbose mode, the JSON output should include input schemas
         mock_console.print_json.assert_called_once()
         # Get the JSON string that was printed
@@ -250,13 +243,13 @@ class TestAnalyzeFromMetadata:
         output_data = json.loads(call_args)
         assert "inputSchema" in output_data["tools"][0]
 
-    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
-    @mock.patch("hud.cli.analyze_metadata.fetch_lock_from_registry")
+    @mock.patch("hud.cli.utils.metadata.check_local_cache")
+    @mock.patch("hud.cli.utils.metadata.fetch_lock_from_registry")
     async def test_analyze_registry_reference_parsing(self, mock_fetch, mock_check):
         """Test parsing of different registry reference formats."""
         mock_check.return_value = None
         mock_fetch.return_value = {"test": "data"}
-        
+
         # Test different reference formats
         test_cases = [
             ("docker.io/org/name:tag", "org/name:tag"),
@@ -265,13 +258,13 @@ class TestAnalyzeFromMetadata:
             ("org/name", "org/name"),
             ("name:tag", "name:tag"),
         ]
-        
+
         for input_ref, expected_call in test_cases:
             await analyze_from_metadata(input_ref, "json", verbose=False)
-            
+
             # Check what was passed to fetch_lock_from_registry
             calls = mock_fetch.call_args_list
             last_call = calls[-1][0][0]
-            
+
             # The function might add :latest, so check base name
             assert expected_call.split(":")[0] in last_call