provide-foundation 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

provide/foundation/tools/installer.py

@@ -5,11 +5,10 @@ Handles extraction and installation of tools from different
 archive formats (zip, tar, gz, etc.) and binary files.
 """
 
+from pathlib import Path
 import shutil
 import tarfile
-import tempfile
 import zipfile
-from pathlib import Path
 
 from provide.foundation.errors import FoundationError
 from provide.foundation.logger import get_logger
@@ -20,43 +19,43 @@ log = get_logger(__name__)
 
 class InstallError(FoundationError):
     """Raised when installation fails."""
-    
+
     pass
 
 
 class ToolInstaller:
     """
     Handle tool installation from various artifact formats.
-    
+
     Supports:
     - ZIP archives
     - TAR archives (with compression)
     - Single binary files
     - Platform-specific installation patterns
     """
-    
+
     def install(self, artifact: Path, metadata: ToolMetadata) -> Path:
         """
         Install tool from artifact.
-        
+
         Args:
             artifact: Path to downloaded artifact.
             metadata: Tool metadata with installation info.
-            
+
         Returns:
             Path to installed tool directory.
-            
+
         Raises:
             InstallError: If installation fails.
         """
         if not artifact.exists():
             raise InstallError(f"Artifact not found: {artifact}")
-        
+
         # Determine install directory
         install_dir = self.get_install_dir(metadata)
-        
+
         log.info(f"Installing {metadata.name} {metadata.version} to {install_dir}")
-        
+
         # Extract based on file type
         suffix = artifact.suffix.lower()
         if suffix == ".zip":
@@ -67,65 +66,65 @@ class ToolInstaller:
             self.install_binary(artifact, install_dir, metadata)
         else:
             raise InstallError(f"Unknown artifact type: {suffix}")
-        
+
         # Set permissions
         self.set_permissions(install_dir, metadata)
-        
+
         # Create symlinks if needed
         self.create_symlinks(install_dir, metadata)
-        
+
         log.info(f"Successfully installed {metadata.name} to {install_dir}")
         return install_dir
-    
+
     def get_install_dir(self, metadata: ToolMetadata) -> Path:
         """
         Get installation directory for tool.
-        
+
         Args:
             metadata: Tool metadata.
-            
+
         Returns:
             Installation directory path.
         """
         if metadata.install_path:
             return metadata.install_path
-        
+
         # Default to ~/.wrknv/tools/<name>/<version>
         base = Path.home() / ".wrknv" / "tools"
         return base / metadata.name / metadata.version
-    
+
     def extract_zip(self, archive: Path, dest: Path) -> None:
         """
         Extract ZIP archive.
-        
+
         Args:
             archive: Path to ZIP file.
             dest: Destination directory.
         """
         log.debug(f"Extracting ZIP {archive} to {dest}")
-        
+
         dest.mkdir(parents=True, exist_ok=True)
-        
+
         with zipfile.ZipFile(archive, "r") as zf:
             # Check for unsafe paths
             for member in zf.namelist():
                 if member.startswith("/") or ".." in member:
                     raise InstallError(f"Unsafe path in archive: {member}")
-            
+
             zf.extractall(dest)
-    
+
     def extract_tar(self, archive: Path, dest: Path) -> None:
         """
         Extract tar archive (with optional compression).
-        
+
         Args:
             archive: Path to tar file.
             dest: Destination directory.
         """
         log.debug(f"Extracting tar {archive} to {dest}")
-        
+
         dest.mkdir(parents=True, exist_ok=True)
-        
+
         # Determine mode based on extension
         mode = "r"
         if archive.suffix in [".gz", ".tgz"]:
@@ -134,22 +133,22 @@ class ToolInstaller:
             mode = "r:bz2"
         elif archive.suffix == ".xz":
             mode = "r:xz"
-        
+
         with tarfile.open(archive, mode) as tf:
             # Check for unsafe paths
             for member in tf.getmembers():
                 if member.name.startswith("/") or ".." in member.name:
                     raise InstallError(f"Unsafe path in archive: {member.name}")
-            
+
             tf.extractall(dest)
-    
+
     def is_binary(self, file_path: Path) -> bool:
         """
         Check if file is a binary executable.
-        
+
         Args:
             file_path: Path to check.
-            
+
         Returns:
             True if file appears to be binary.
         """
@@ -170,85 +169,80 @@ class ToolInstaller:
                         return True
             except Exception:
                 pass
-        
+
         return False
-    
-    def install_binary(
-        self,
-        binary: Path,
-        dest: Path,
-        metadata: ToolMetadata
-    ) -> None:
+
+    def install_binary(self, binary: Path, dest: Path, metadata: ToolMetadata) -> None:
         """
         Install single binary file.
-        
+
         Args:
             binary: Path to binary file.
             dest: Destination directory.
             metadata: Tool metadata.
         """
         log.debug(f"Installing binary {binary} to {dest}")
-        
+
         dest.mkdir(parents=True, exist_ok=True)
         bin_dir = dest / "bin"
         bin_dir.mkdir(exist_ok=True)
-        
+
         # Determine target name
         target_name = metadata.executable_name or binary.name
         target = bin_dir / target_name
-        
+
         # Copy binary
         shutil.copy2(binary, target)
-        
+
         # Make executable
         target.chmod(0o755)
-    
+
     def set_permissions(self, install_dir: Path, metadata: ToolMetadata) -> None:
         """
         Set appropriate permissions on installed files.
-        
+
         Args:
             install_dir: Installation directory.
             metadata: Tool metadata.
         """
         import platform
-        
+
         if platform.system() == "Windows":
             return  # Windows handles permissions differently
-        
+
         # Find executables and make them executable
         bin_dir = install_dir / "bin"
         if bin_dir.exists():
             for file in bin_dir.iterdir():
                 if file.is_file():
                     file.chmod(0o755)
-        
+
         # Check for executable name in root
         if metadata.executable_name:
             exe_path = install_dir / metadata.executable_name
             if exe_path.exists():
                 exe_path.chmod(0o755)
-    
+
     def create_symlinks(self, install_dir: Path, metadata: ToolMetadata) -> None:
         """
         Create symlinks for easier access.
-        
+
         Args:
             install_dir: Installation directory.
             metadata: Tool metadata.
         """
         import platform
-        
+
         if platform.system() == "Windows":
             return  # Windows doesn't support symlinks easily
-        
+
         # Create version-less symlink
         if metadata.name and metadata.version:
             parent = install_dir.parent
             latest_link = parent / "latest"
-            
+
             if latest_link.exists() or latest_link.is_symlink():
                 latest_link.unlink()
-            
+
             latest_link.symlink_to(install_dir)
-            log.debug(f"Created symlink {latest_link} -> {install_dir}")
+            log.debug(f"Created symlink {latest_link} -> {install_dir}")

provide/foundation/tools/registry.py

@@ -19,32 +19,32 @@ log = get_logger(__name__)
 class ToolRegistry:
     """
     Wrapper around the hub registry for tool management.
-    
+
     Uses the main hub registry with dimension="tool_manager"
     to avoid namespace pollution while leveraging existing
     registry infrastructure.
     """
-    
+
     DIMENSION = "tool_manager"
-    
+
     def __init__(self):
         """Initialize the tool registry."""
         self.hub = get_hub()
         self._discover_tools()
-    
+
     def _discover_tools(self) -> None:
         """
         Auto-discover tool managers via entry points.
-        
+
         Looks for entry points in the "wrknv.tools" group
         and automatically registers them.
         """
         try:
             # Get entry points for tool managers
-            if hasattr(importlib.metadata, 'entry_points'):
+            if hasattr(importlib.metadata, "entry_points"):
                 # Python 3.10+
                 eps = importlib.metadata.entry_points()
-                if hasattr(eps, 'select'):
+                if hasattr(eps, "select"):
                     # Python 3.10+ with select method
                     group_eps = eps.select(group="wrknv.tools")
                 else:
@@ -54,7 +54,7 @@ class ToolRegistry:
                 # Python 3.8-3.9
                 eps = importlib.metadata.entry_points()
                 group_eps = eps.get("wrknv.tools", [])
-            
+
             for ep in group_eps:
                 try:
                     manager_class = ep.load()
@@ -64,16 +64,16 @@ class ToolRegistry:
                     log.warning(f"Failed to load tool manager {ep.name}: {e}")
         except Exception as e:
             log.debug(f"Entry point discovery not available: {e}")
-    
+
     def register_tool_manager(
         self,
         name: str,
         manager_class: type[BaseToolManager],
-        aliases: list[str] | None = None
+        aliases: list[str] | None = None,
     ) -> None:
         """
         Register a tool manager with the hub.
-        
+
         Args:
             name: Tool name (e.g., "terraform").
             manager_class: Tool manager class.
@@ -85,7 +85,7 @@ class ToolRegistry:
             "executable": manager_class.executable_name,
             "platforms": manager_class.supported_platforms,
         }
-        
+
         # Register with hub
         self.hub.registry.register(
             name=name,
@@ -93,35 +93,33 @@ class ToolRegistry:
             dimension=self.DIMENSION,
             metadata=metadata,
             aliases=aliases,
-            replace=True  # Allow re-registration for updates
+            replace=True,  # Allow re-registration for updates
         )
-        
+
         log.info(f"Registered tool manager: {name}")
-    
+
     def get_tool_manager_class(self, name: str) -> type[BaseToolManager] | None:
         """
         Get a tool manager class by name.
-        
+
         Args:
             name: Tool name or alias.
-            
+
         Returns:
             Tool manager class, or None if not found.
         """
         return self.hub.registry.get(name, dimension=self.DIMENSION)
-    
+
     def create_tool_manager(
-        self,
-        name: str,
-        config: BaseConfig
+        self, name: str, config: BaseConfig
     ) -> BaseToolManager | None:
         """
         Create a tool manager instance.
-        
+
         Args:
             name: Tool name or alias.
             config: Configuration object.
-            
+
         Returns:
             Tool manager instance, or None if not found.
         """
@@ -129,42 +127,42 @@ class ToolRegistry:
         if manager_class:
             return manager_class(config)
         return None
-    
+
     def list_tools(self) -> list[tuple[str, dict[str, Any]]]:
         """
         List all registered tools.
-        
+
         Returns:
             List of (name, metadata) tuples.
         """
         tools = []
         for name, entry in self.hub.registry.list_dimension(self.DIMENSION):
-            metadata = entry.metadata if hasattr(entry, 'metadata') else {}
+            metadata = entry.metadata if hasattr(entry, "metadata") else {}
             tools.append((name, metadata))
         return tools
-    
+
     def get_tool_info(self, name: str) -> dict[str, Any] | None:
         """
         Get information about a specific tool.
-        
+
         Args:
             name: Tool name or alias.
-            
+
         Returns:
             Tool metadata dictionary, or None if not found.
         """
         entry = self.hub.registry.get_entry(name, dimension=self.DIMENSION)
-        if entry and hasattr(entry, 'metadata'):
+        if entry and hasattr(entry, "metadata"):
             return entry.metadata
         return None
-    
+
     def is_tool_registered(self, name: str) -> bool:
         """
         Check if a tool is registered.
-        
+
         Args:
             name: Tool name or alias.
-            
+
         Returns:
             True if registered, False otherwise.
         """
@@ -178,7 +176,7 @@ _tool_registry: ToolRegistry | None = None
 def get_tool_registry() -> ToolRegistry:
     """
     Get the global tool registry instance.
-    
+
     Returns:
         Tool registry instance.
     """
@@ -189,13 +187,11 @@ def get_tool_registry() -> ToolRegistry:
 
 
 def register_tool_manager(
-    name: str,
-    manager_class: type[BaseToolManager],
-    aliases: list[str] | None = None
+    name: str, manager_class: type[BaseToolManager], aliases: list[str] | None = None
 ) -> None:
     """
     Register a tool manager with the global registry.
-    
+
     Args:
         name: Tool name.
         manager_class: Tool manager class.
@@ -205,19 +201,16 @@ def register_tool_manager(
     registry.register_tool_manager(name, manager_class, aliases)
 
 
-def get_tool_manager(
-    name: str,
-    config: BaseConfig
-) -> BaseToolManager | None:
+def get_tool_manager(name: str, config: BaseConfig) -> BaseToolManager | None:
     """
     Get a tool manager instance from the global registry.
-    
+
     Args:
         name: Tool name or alias.
         config: Configuration object.
-        
+
     Returns:
         Tool manager instance, or None if not found.
     """
     registry = get_tool_registry()
-    return registry.create_tool_manager(name, config)
+    return registry.create_tool_manager(name, config)