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

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)

provide/foundation/tools/resolver.py

@@ -6,7 +6,6 @@ semver ranges, wildcards, and pre-release handling.
 """
 
 import re
-from typing import Any
 
 from provide.foundation.errors import FoundationError
 from provide.foundation.logger import get_logger
@@ -16,14 +15,14 @@ log = get_logger(__name__)
 
 class ResolutionError(FoundationError):
     """Raised when version resolution fails."""
-    
+
     pass
 
 
 class VersionResolver:
     """
     Resolve version specifications to concrete versions.
-    
+
     Supports:
     - "latest": Most recent stable version
     - "latest-beta": Most recent pre-release
@@ -32,23 +31,23 @@ class VersionResolver:
     - "1.2.*": Wildcard matching
     - Exact versions
     """
-    
+
     def resolve(self, spec: str, available: list[str]) -> str | None:
         """
         Resolve a version specification to a concrete version.
-        
+
         Args:
             spec: Version specification.
             available: List of available versions.
-            
+
         Returns:
             Resolved version string, or None if not found.
         """
         if not available:
             return None
-        
+
         spec = spec.strip()
-        
+
         # Handle special keywords
         if spec == "latest":
             return self.get_latest_stable(available)
@@ -56,77 +55,77 @@ class VersionResolver:
             return self.get_latest_prerelease(available)
         elif spec == "latest-any":
             return self.get_latest_any(available)
-        
+
         # Handle ranges
         elif spec.startswith("~"):
             return self.resolve_tilde(spec[1:], available)
         elif spec.startswith("^"):
             return self.resolve_caret(spec[1:], available)
-        
+
         # Handle wildcards
         elif "*" in spec:
             return self.resolve_wildcard(spec, available)
-        
+
         # Exact match
         elif spec in available:
             return spec
-        
+
         return None
-    
+
     def get_latest_stable(self, versions: list[str]) -> str | None:
         """
         Get latest stable version (no pre-release).
-        
+
         Args:
             versions: List of available versions.
-            
+
         Returns:
             Latest stable version, or None if no stable versions.
         """
         stable = [v for v in versions if not self.is_prerelease(v)]
         if not stable:
             return None
-        
+
         return self.sort_versions(stable)[-1]
-    
+
     def get_latest_prerelease(self, versions: list[str]) -> str | None:
         """
         Get latest pre-release version.
-        
+
         Args:
             versions: List of available versions.
-            
+
         Returns:
             Latest pre-release version, or None if no pre-releases.
         """
         prerelease = [v for v in versions if self.is_prerelease(v)]
         if not prerelease:
             return None
-        
+
         return self.sort_versions(prerelease)[-1]
-    
+
     def get_latest_any(self, versions: list[str]) -> str | None:
         """
         Get latest version (including pre-releases).
-        
+
         Args:
             versions: List of available versions.
-            
+
         Returns:
             Latest version, or None if list is empty.
         """
         if not versions:
             return None
-        
+
         return self.sort_versions(versions)[-1]
-    
+
     def is_prerelease(self, version: str) -> bool:
         """
         Check if version is a pre-release.
-        
+
         Args:
             version: Version string.
-            
+
         Returns:
             True if version appears to be pre-release.
         """
@@ -144,22 +143,22 @@ class VersionResolver:
             r"b\d+$",  # 1.0b2
             r"rc\d+$",  # 1.0rc3
         ]
-        
+
         version_lower = version.lower()
         for pattern in prerelease_patterns:
             if re.search(pattern, version_lower):
                 return True
-        
+
         return False
-    
+
     def resolve_tilde(self, base: str, available: list[str]) -> str | None:
         """
         Resolve tilde range (~1.2.3 means >=1.2.3 <1.3.0).
-        
+
         Args:
             base: Base version without tilde.
             available: List of available versions.
-            
+
         Returns:
             Best matching version, or None if no match.
         """
@@ -167,9 +166,9 @@ class VersionResolver:
             parts = self.parse_version(base)
             if len(parts) < 2:
                 return None
-            
+
             major, minor = parts[0], parts[1]
-            
+
             # Filter versions that match the constraint
             matches = []
             for v in available:
@@ -182,22 +181,22 @@ class VersionResolver:
                                 matches.append(v)
                         else:
                             matches.append(v)
-            
+
             if matches:
                 return self.sort_versions(matches)[-1]
         except Exception as e:
             log.debug(f"Failed to resolve tilde range {base}: {e}")
-        
+
         return None
-    
+
     def resolve_caret(self, base: str, available: list[str]) -> str | None:
         """
         Resolve caret range (^1.2.3 means >=1.2.3 <2.0.0).
-        
+
         Args:
             base: Base version without caret.
             available: List of available versions.
-            
+
         Returns:
             Best matching version, or None if no match.
         """
@@ -205,9 +204,9 @@ class VersionResolver:
             parts = self.parse_version(base)
             if not parts:
                 return None
-            
+
             major = parts[0]
-            
+
             # Filter versions that match the constraint
             matches = []
             for v in available:
@@ -216,22 +215,22 @@ class VersionResolver:
                     # Must be >= base version
                     if self.compare_versions(v, base) >= 0:
                         matches.append(v)
-            
+
             if matches:
                 return self.sort_versions(matches)[-1]
         except Exception as e:
             log.debug(f"Failed to resolve caret range {base}: {e}")
-        
+
         return None
-    
+
     def resolve_wildcard(self, pattern: str, available: list[str]) -> str | None:
         """
         Resolve wildcard pattern (1.2.* matches any 1.2.x).
-        
+
         Args:
             pattern: Version pattern with wildcards.
             available: List of available versions.
-            
+
         Returns:
             Best matching version, or None if no match.
         """
@@ -239,26 +238,26 @@ class VersionResolver:
         regex_pattern = pattern.replace(".", r"\.")
         regex_pattern = regex_pattern.replace("*", r".*")
         regex_pattern = f"^{regex_pattern}$"
-        
+
         try:
             regex = re.compile(regex_pattern)
             matches = [v for v in available if regex.match(v)]
-            
+
             if matches:
                 # Return latest matching version
                 return self.sort_versions(matches)[-1]
         except Exception as e:
             log.debug(f"Failed to resolve wildcard {pattern}: {e}")
-        
+
         return None
-    
+
     def parse_version(self, version: str) -> list[int]:
         """
         Parse version string into numeric components.
-        
+
         Args:
             version: Version string.
-            
+
         Returns:
             List of numeric version components.
         """
@@ -266,56 +265,59 @@ class VersionResolver:
         match = re.match(r"^v?(\d+(?:\.\d+)*)", version)
         if not match:
             return []
-        
+
         version_str = match.group(1)
         parts = []
-        
+
         for part in version_str.split("."):
             try:
                 parts.append(int(part))
             except ValueError:
                 break
-        
+
         return parts
-    
+
     def compare_versions(self, v1: str, v2: str) -> int:
         """
         Compare two versions.
-        
+
         Args:
             v1: First version.
             v2: Second version.
-            
+
         Returns:
             -1 if v1 < v2, 0 if equal, 1 if v1 > v2.
         """
         parts1 = self.parse_version(v1)
         parts2 = self.parse_version(v2)
-        
+
         # Pad with zeros
         max_len = max(len(parts1), len(parts2))
         parts1.extend([0] * (max_len - len(parts1)))
         parts2.extend([0] * (max_len - len(parts2)))
-        
+
         for p1, p2 in zip(parts1, parts2):
             if p1 < p2:
                 return -1
             elif p1 > p2:
                 return 1
-        
+
         return 0
-    
+
     def sort_versions(self, versions: list[str]) -> list[str]:
         """
         Sort versions in ascending order.
-        
+
         Args:
             versions: List of version strings.
-            
+
         Returns:
             Sorted list of versions.
         """
-        return sorted(versions, key=lambda v: (
-            self.parse_version(v),
-            v  # Secondary sort by string for pre-releases
-        ))
+        return sorted(
+            versions,
+            key=lambda v: (
+                self.parse_version(v),
+                v,  # Secondary sort by string for pre-releases
+            ),
+        )