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

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
+            ),
+        )

provide/foundation/tools/verifier.py

@@ -6,7 +6,6 @@ checksum algorithms and GPG/PGP signatures.
 """
 
 import hashlib
-import re
 from pathlib import Path
 from typing import Literal
 
@@ -18,7 +17,7 @@ log = get_logger(__name__)
 
 class VerificationError(FoundationError):
     """Raised when verification fails."""
-    
+
     pass
 
 
@@ -28,125 +27,115 @@ HashAlgo = Literal["sha256", "sha512", "md5", "blake2b"]
 class ToolVerifier:
     """
     Verify tool artifacts using checksums and signatures.
-    
+
     Supports multiple checksum algorithms and GPG/PGP signatures
     for ensuring artifact integrity and authenticity.
     """
-    
+
     SUPPORTED_ALGORITHMS = ["sha256", "sha512", "md5", "blake2b"]
     CHUNK_SIZE = 8192  # Read files in 8KB chunks
-    
+
     def verify_checksum(
-        self,
-        file_path: Path,
-        expected: str,
-        algo: HashAlgo = "sha256"
+        self, file_path: Path, expected: str, algo: HashAlgo = "sha256"
     ) -> bool:
         """
         Verify file checksum.
-        
+
         Args:
             file_path: Path to file to verify.
             expected: Expected checksum (hex string).
             algo: Hash algorithm to use.
-            
+
         Returns:
             True if checksum matches, False otherwise.
-            
+
         Raises:
             ValueError: If algorithm is not supported.
             FileNotFoundError: If file doesn't exist.
         """
         if algo not in self.SUPPORTED_ALGORITHMS:
             raise ValueError(f"Unsupported hash algorithm: {algo}")
-        
+
         if not file_path.exists():
             raise FileNotFoundError(f"File not found: {file_path}")
-        
+
         log.debug(f"Verifying {algo} checksum for {file_path}")
-        
+
         # Create hasher
         hasher = hashlib.new(algo)
-        
+
         # Read file in chunks
         with file_path.open("rb") as f:
             while chunk := f.read(self.CHUNK_SIZE):
                 hasher.update(chunk)
-        
+
         actual = hasher.hexdigest()
         matches = actual == expected
-        
+
         if not matches:
             log.warning(
                 f"Checksum mismatch for {file_path.name}: "
                 f"expected {expected}, got {actual}"
             )
-        
+
         return matches
-    
-    def verify_shasums_file(
-        self,
-        shasums_file: Path,
-        target_file: Path
-    ) -> bool:
+
+    def verify_shasums_file(self, shasums_file: Path, target_file: Path) -> bool:
         """
         Verify using a shasums file (common for Go/Terraform).
-        
+
         Args:
             shasums_file: Path to shasums file.
             target_file: Path to file to verify.
-            
+
         Returns:
             True if file is listed and checksum matches, False otherwise.
         """
         log.debug(f"Verifying {target_file.name} using {shasums_file}")
-        
+
         with shasums_file.open() as f:
             for line in f:
                 line = line.strip()
                 if not line:
                     continue
-                
+
                 # Parse line: "checksum  filename" or "checksum *filename"
                 parts = line.split(None, 1)
                 if len(parts) != 2:
                     continue
-                
+
                 checksum, filename = parts
                 # Remove asterisk prefix if present (binary mode indicator)
                 filename = filename.lstrip("*")
-                
+
                 # Check if this is our file
                 if filename == target_file.name:
                     return self.verify_checksum(target_file, checksum)
-        
+
         # File not found in shasums
         log.warning(f"{target_file.name} not found in {shasums_file}")
         return False
-    
+
     def verify_signature(
-        self,
-        file_path: Path,
-        signature: str,
-        public_key: str | None = None
+        self, file_path: Path, signature: str, public_key: str | None = None
     ) -> bool:
         """
         Verify GPG/PGP signature.
-        
+
         Args:
             file_path: Path to file to verify.
             signature: Signature data.
             public_key: Optional public key for verification.
-            
+
         Returns:
             True if signature is valid, False otherwise.
         """
         log.debug(f"Verifying signature for {file_path}")
-        
+
         try:
             # Use foundation's crypto module
             from provide.foundation.crypto import verify_signature
-            
+
             return verify_signature(file_path, signature, public_key)
         except ImportError:
             log.warning("Crypto module not available, skipping signature verification")
@@ -154,33 +143,33 @@ class ToolVerifier:
         except Exception as e:
             log.error(f"Signature verification failed: {e}")
             return False
-    
+
     def extract_checksum(self, checksum_string: str) -> str:
         """
         Extract checksum from various string formats.
-        
+
         Handles formats like:
         - "abc123"
         - "abc123  filename.tar.gz"
         - "sha256:abc123"
         - "SHA256:def456"
-        
+
         Args:
             checksum_string: String containing checksum.
-            
+
         Returns:
             Extracted checksum hex string.
         """
         checksum_string = checksum_string.strip()
-        
+
         # Remove algorithm prefix if present
         if ":" in checksum_string:
             checksum_string = checksum_string.split(":", 1)[1]
-        
+
         # Take first word (checksum is before any whitespace)
         checksum = checksum_string.split()[0]
-        
+
         # Remove any asterisk prefix (binary mode indicator)
         checksum = checksum.lstrip("*")
-        
-        return checksum
+
+        return checksum

provide/foundation/tracer/spans.py

@@ -8,7 +8,7 @@ Provides OpenTelemetry integration when available, falls back to simple tracing.
 
 from dataclasses import dataclass, field
 import time
-from typing import Any, Optional
+from typing import Any
 import uuid
 
 from provide.foundation.logger import get_logger
@@ -47,9 +47,7 @@ class Span:
     error: str | None = None
 
     # Internal OpenTelemetry span (when available)
-    _otel_span: Optional["otel_trace.Span"] = field(
-        default=None, init=False, repr=False
-    )
+    _otel_span: "otel_trace.Span | None" = field(default=None, init=False, repr=False)
     _active: bool = field(default=True, init=False, repr=False)
 
     def __post_init__(self) -> None:
@@ -162,13 +160,3 @@ class Span:
             "status": self.status,
             "error": self.error,
         }
-
-    def __enter__(self):
-        """Context manager entry."""
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit."""
-        if exc_type is not None:
-            self.set_error(f"{exc_type.__name__}: {exc_val}")
-        self.finish()