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

provide/foundation/tools/resolver.py

@@ -0,0 +1,321 @@
+"""
+Version resolution for tool management.
+
+Provides sophisticated version resolution including latest,
+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
+
+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
+    - "~1.2.3": Patch version range
+    - "^1.2.3": Minor version range
+    - "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)
+        elif spec == "latest-beta" or spec == "latest-prerelease":
+            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.
+        """
+        # Common pre-release indicators
+        prerelease_patterns = [
+            r"-alpha",
+            r"-beta",
+            r"-rc",
+            r"-dev",
+            r"-preview",
+            r"-pre",
+            r"-snapshot",
+            r"\.dev\d+",
+            r"a\d+$",  # 1.0a1
+            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.
+        """
+        try:
+            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:
+                v_parts = self.parse_version(v)
+                if len(v_parts) >= 2:
+                    if v_parts[0] == major and v_parts[1] == minor:
+                        if len(parts) >= 3:
+                            # If patch specified, must be >= base patch
+                            if len(v_parts) >= 3 and v_parts[2] >= parts[2]:
+                                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.
+        """
+        try:
+            parts = self.parse_version(base)
+            if not parts:
+                return None
+            
+            major = parts[0]
+            
+            # Filter versions that match the constraint
+            matches = []
+            for v in available:
+                v_parts = self.parse_version(v)
+                if v_parts and v_parts[0] == major:
+                    # 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.
+        """
+        # Convert wildcard to regex
+        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.
+        """
+        # Extract just the numeric version part
+        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
+        ))

provide/foundation/tools/verifier.py

@@ -0,0 +1,186 @@
+"""
+Tool verification system for checksums and signatures.
+
+Provides capabilities for verifying downloaded tools using various
+checksum algorithms and GPG/PGP signatures.
+"""
+
+import hashlib
+import re
+from pathlib import Path
+from typing import Literal
+
+from provide.foundation.errors import FoundationError
+from provide.foundation.logger import get_logger
+
+log = get_logger(__name__)
+
+
+class VerificationError(FoundationError):
+    """Raised when verification fails."""
+    
+    pass
+
+
+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"
+    ) -> 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:
+        """
+        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
+    ) -> 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")
+            return True  # Skip if crypto not available
+        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

provide/foundation/tracer/otel.py

@@ -1,9 +1,9 @@
 """OpenTelemetry integration for Foundation tracer."""
 
-from provide.foundation.logger import get_logger
 from provide.foundation.logger.config.telemetry import TelemetryConfig
+from provide.foundation.logger.setup import get_vanilla_logger
 
-log = get_logger(__name__)
+slog = get_vanilla_logger(__name__)
 
 # Feature detection
 try:
@@ -49,16 +49,12 @@ def setup_opentelemetry_tracing(config: TelemetryConfig) -> None:
     """
     # Check if tracing is disabled first, before checking dependencies
     if not config.tracing_enabled or config.globally_disabled:
-        log.debug("🔍 OpenTelemetry tracing disabled")
         return
 
     # Check if OpenTelemetry is available
     if not _HAS_OTEL:
-        log.debug("🔍 OpenTelemetry tracing not available (dependencies not installed)")
         return
 
-    log.debug("🔍🚀 Setting up OpenTelemetry tracing")
-
     # Create resource with service information
     resource_attrs = {}
     if config.service_name:
@@ -77,7 +73,7 @@ def setup_opentelemetry_tracing(config: TelemetryConfig) -> None:
         endpoint = config.otlp_traces_endpoint or config.otlp_endpoint
         headers = config.get_otlp_headers_dict()
 
-        log.debug(f"🔍📤 Configuring OTLP exporter: {endpoint}")
+        # Configuring OTLP exporter
 
         # Choose exporter based on protocol
         if config.otlp_protocol == "grpc":
@@ -95,12 +91,12 @@ def setup_opentelemetry_tracing(config: TelemetryConfig) -> None:
         processor = BatchSpanProcessor(exporter)
         tracer_provider.add_span_processor(processor)
 
-        log.debug(f"✅ OTLP span exporter configured: {config.otlp_protocol}")
+        slog.debug(f"✅ OTLP span exporter configured: {config.otlp_protocol}")
 
     # Set the global tracer provider
     otel_trace.set_tracer_provider(tracer_provider)
 
-    log.info("🔍✅ OpenTelemetry tracing setup complete")
+    slog.info("🔍✅ OpenTelemetry tracing setup complete")
 
 
 def get_otel_tracer(name: str) -> "otel_trace.Tracer | None":
@@ -130,6 +126,6 @@ def shutdown_opentelemetry() -> None:
         tracer_provider = otel_trace.get_tracer_provider()
         if hasattr(tracer_provider, "shutdown"):
             tracer_provider.shutdown()
-            log.debug("🔍🛑 OpenTelemetry tracer provider shutdown")
+            slog.debug("🔍🛑 OpenTelemetry tracer provider shutdown")
     except Exception as e:
-        log.warning(f"⚠️ Error shutting down OpenTelemetry: {e}")
+        slog.warning(f"⚠️ Error shutting down OpenTelemetry: {e}")

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,7 +47,7 @@ class Span:
     error: str | None = None
 
     # Internal OpenTelemetry span (when available)
-    _otel_span: Optional["otel_trace.Span"] = field(
+    _otel_span: "otel_trace.Span | None" = field(
         default=None, init=False, repr=False
     )
     _active: bool = field(default=True, init=False, repr=False)