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

provide/foundation/tools/base.py

@@ -7,7 +7,6 @@ the base manager class and metadata structures.
 
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any
 
 from attrs import define, field
 
@@ -20,25 +19,25 @@ log = get_logger(__name__)
 
 class ToolError(FoundationError):
     """Base exception for tool-related errors."""
-    
+
     pass
 
 
 class ToolNotFoundError(ToolError):
     """Raised when a tool or version cannot be found."""
-    
+
     pass
 
 
 class ToolInstallError(ToolError):
     """Raised when tool installation fails."""
-    
+
     pass
 
 
 class ToolVerificationError(ToolError):
     """Raised when tool verification fails."""
-    
+
     pass
 
 
@@ -46,7 +45,7 @@ class ToolVerificationError(ToolError):
 class ToolMetadata:
     """
     Metadata about a tool version.
-    
+
     Attributes:
         name: Tool name (e.g., "terraform").
         version: Version string (e.g., "1.5.0").
@@ -61,7 +60,7 @@ class ToolMetadata:
         dependencies: Other tools this depends on.
         executable_name: Name of the executable file.
     """
-    
+
     name: str
     version: str
     platform: str
@@ -79,26 +78,26 @@ class ToolMetadata:
 class BaseToolManager(ABC):
     """
     Abstract base class for tool managers.
-    
+
     Provides common functionality for downloading, verifying, and installing
     development tools. Subclasses must implement platform-specific logic.
-    
+
     Attributes:
         config: Configuration object.
         tool_name: Name of the tool being managed.
         executable_name: Name of the executable file.
         supported_platforms: List of supported platforms.
     """
-    
+
     # Class attributes to be overridden by subclasses
     tool_name: str = ""
     executable_name: str = ""
     supported_platforms: list[str] = ["linux", "darwin", "windows"]
-    
+
     def __init__(self, config: BaseConfig):
         """
         Initialize the tool manager.
-        
+
         Args:
             config: Configuration object containing settings.
         """
@@ -106,149 +105,150 @@ class BaseToolManager(ABC):
             raise ToolError("Subclass must define tool_name")
         if not self.executable_name:
             raise ToolError("Subclass must define executable_name")
-            
+
         self.config = config
-        
+
         # Lazy-load components to avoid circular imports
         self._cache = None
         self._downloader = None
         self._verifier = None
         self._installer = None
         self._resolver = None
-        
+
         log.debug(f"Initialized {self.tool_name} manager")
-    
+
     @property
     def cache(self):
         """Get or create cache instance."""
         if self._cache is None:
             from provide.foundation.tools.cache import ToolCache
+
             self._cache = ToolCache()
         return self._cache
-    
+
     @property
     def downloader(self):
         """Get or create downloader instance."""
         if self._downloader is None:
             from provide.foundation.tools.downloader import ToolDownloader
             from provide.foundation.transport import UniversalClient
+
             self._downloader = ToolDownloader(UniversalClient())
         return self._downloader
-    
+
     @property
     def verifier(self):
         """Get or create verifier instance."""
         if self._verifier is None:
             from provide.foundation.tools.verifier import ToolVerifier
+
             self._verifier = ToolVerifier()
         return self._verifier
-    
+
     @property
     def installer(self):
         """Get or create installer instance."""
         if self._installer is None:
             from provide.foundation.tools.installer import ToolInstaller
+
             self._installer = ToolInstaller()
         return self._installer
-    
+
     @property
     def resolver(self):
         """Get or create version resolver instance."""
         if self._resolver is None:
             from provide.foundation.tools.resolver import VersionResolver
+
             self._resolver = VersionResolver()
         return self._resolver
-    
+
     @abstractmethod
     def get_metadata(self, version: str) -> ToolMetadata:
         """
         Get metadata for a specific version.
-        
+
         Args:
             version: Version string to get metadata for.
-            
+
         Returns:
             ToolMetadata object with download URLs and checksums.
         """
         pass
-    
+
     @abstractmethod
     def get_available_versions(self) -> list[str]:
         """
         Get list of available versions from upstream.
-        
+
         Returns:
             List of version strings available for download.
         """
         pass
-    
+
     def resolve_version(self, spec: str) -> str:
         """
         Resolve a version specification to a concrete version.
-        
+
         Args:
             spec: Version specification (e.g., "latest", "~1.5.0").
-            
+
         Returns:
             Concrete version string.
-            
+
         Raises:
             ToolNotFoundError: If version cannot be resolved.
         """
         available = self.get_available_versions()
         if not available:
             raise ToolNotFoundError(f"No versions available for {self.tool_name}")
-        
+
         resolved = self.resolver.resolve(spec, available)
         if not resolved:
             raise ToolNotFoundError(
                 f"Cannot resolve version '{spec}' for {self.tool_name}"
             )
-        
+
         log.debug(f"Resolved {self.tool_name} version {spec} to {resolved}")
         return resolved
-    
+
     def install(self, version: str = "latest", force: bool = False) -> Path:
         """
         Install a specific version of the tool.
-        
+
         Args:
             version: Version to install (default: "latest").
             force: Force reinstall even if cached.
-            
+
         Returns:
             Path to the installed tool.
-            
+
         Raises:
             ToolInstallError: If installation fails.
         """
         # Resolve version
         if version in ["latest", "stable", "dev"] or version.startswith(("~", "^")):
             version = self.resolve_version(version)
-        
+
         # Check cache unless forced
         if not force:
             if cached_path := self.cache.get(self.tool_name, version):
                 log.info(f"Using cached {self.tool_name} {version}")
                 return cached_path
-        
+
         log.info(f"Installing {self.tool_name} {version}")
-        
+
         # Get metadata
         metadata = self.get_metadata(version)
         if not metadata.download_url:
-            raise ToolInstallError(
-                f"No download URL for {self.tool_name} {version}"
-            )
-        
+            raise ToolInstallError(f"No download URL for {self.tool_name} {version}")
+
         # Download
         download_path = Path("/tmp") / f"{self.tool_name}-{version}"
         artifact_path = self.downloader.download_with_progress(
-            metadata.download_url,
-            download_path,
-            metadata.checksum
+            metadata.download_url, download_path, metadata.checksum
         )
-        
+
         # Verify if checksum provided
         if metadata.checksum:
             if not self.verifier.verify_checksum(artifact_path, metadata.checksum):
@@ -256,79 +256,80 @@ class BaseToolManager(ABC):
                 raise ToolVerificationError(
                     f"Checksum verification failed for {self.tool_name} {version}"
                 )
-        
+
         # Install
         install_path = self.installer.install(artifact_path, metadata)
-        
+
         # Cache the installation
         self.cache.store(self.tool_name, version, install_path)
-        
+
         # Clean up download
         if artifact_path.exists():
             artifact_path.unlink()
-        
+
         log.info(f"Successfully installed {self.tool_name} {version} to {install_path}")
         return install_path
-    
+
     def uninstall(self, version: str) -> bool:
         """
         Uninstall a specific version.
-        
+
         Args:
             version: Version to uninstall.
-            
+
         Returns:
             True if uninstalled, False if not found.
         """
         # Invalidate cache
         self.cache.invalidate(self.tool_name, version)
-        
+
         # Remove from filesystem
         install_path = self.get_install_path(version)
         if install_path.exists():
             import shutil
+
             shutil.rmtree(install_path)
             log.info(f"Uninstalled {self.tool_name} {version}")
             return True
-        
+
         return False
-    
+
     def get_install_path(self, version: str) -> Path:
         """
         Get the installation path for a version.
-        
+
         Args:
             version: Version string.
-            
+
         Returns:
             Path where the version is/will be installed.
         """
         base_path = Path.home() / ".wrknv" / "tools" / self.tool_name / version
         return base_path
-    
+
     def is_installed(self, version: str) -> bool:
         """
         Check if a version is installed.
-        
+
         Args:
             version: Version to check.
-            
+
         Returns:
             True if installed, False otherwise.
         """
         install_path = self.get_install_path(version)
         executable = install_path / "bin" / self.executable_name
         return executable.exists()
-    
+
     def get_platform_info(self) -> dict[str, str]:
         """
         Get current platform information.
-        
+
         Returns:
             Dictionary with platform and arch keys.
         """
         import platform
-        
+
         system = platform.system().lower()
         if system == "darwin":
             system = "darwin"
@@ -336,7 +337,7 @@ class BaseToolManager(ABC):
             system = "linux"
         elif system == "windows":
             system = "windows"
-        
+
         machine = platform.machine().lower()
         if machine in ["x86_64", "amd64"]:
             arch = "amd64"
@@ -344,5 +345,5 @@ class BaseToolManager(ABC):
             arch = "arm64"
         else:
             arch = machine
-        
-        return {"platform": system, "arch": arch}
+
+        return {"platform": system, "arch": arch}