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

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

@@ -47,9 +47,7 @@ class Span:
     error: str | None = None
 
     # Internal OpenTelemetry span (when available)
-    _otel_span: "otel_trace.Span | None" = 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()

provide/foundation/transport/__init__.py

@@ -14,28 +14,28 @@ Key Features:
 
 Example Usage:
     >>> from provide.foundation.transport import get, post
-    >>> 
+    >>>
     >>> # Simple requests
     >>> response = await get("https://api.example.com/users")
     >>> data = response.json()
-    >>> 
+    >>>
     >>> # POST with JSON body
     >>> response = await post(
     ...     "https://api.example.com/users",
     ...     body={"name": "John", "email": "john@example.com"}
     ... )
-    >>> 
+    >>>
     >>> # Using client for multiple requests
     >>> from provide.foundation.transport import UniversalClient
-    >>> 
+    >>>
     >>> async with UniversalClient() as client:
     ...     users = await client.get("https://api.example.com/users")
     ...     posts = await client.get("https://api.example.com/posts")
-    >>> 
+    >>>
     >>> # Custom transport registration
     >>> from provide.foundation.transport import register_transport
     >>> from provide.foundation.transport.types import TransportType
-    >>> 
+    >>>
     >>> register_transport(TransportType("custom"), MyCustomTransport)
 
 Environment Configuration:
@@ -43,7 +43,7 @@ Environment Configuration:
     TRANSPORT_MAX_RETRIES=3
     TRANSPORT_RETRY_BACKOFF_FACTOR=0.5
     TRANSPORT_VERIFY_SSL=true
-    
+
     HTTP_POOL_CONNECTIONS=10
     HTTP_POOL_MAXSIZE=100
     HTTP_FOLLOW_REDIRECTS=true
@@ -54,9 +54,23 @@ Environment Configuration:
 # Core transport abstractions
 from provide.foundation.transport.base import Request, Response
 
+# High-level client API
+from provide.foundation.transport.client import (
+    UniversalClient,
+    delete,
+    get,
+    get_default_client,
+    head,
+    options,
+    patch,
+    post,
+    put,
+    request,
+    stream,
+)
+
 # Transport types and configuration
 from provide.foundation.transport.config import HTTPConfig, TransportConfig
-from provide.foundation.transport.types import HTTPMethod, TransportType
 
 # Error types
 from provide.foundation.transport.errors import (
@@ -87,45 +101,26 @@ from provide.foundation.transport.registry import (
     list_registered_transports,
     register_transport,
 )
-
-# High-level client API
-from provide.foundation.transport.client import (
-    UniversalClient,
-    delete,
-    get,
-    get_default_client,
-    head,
-    options,
-    patch,
-    post,
-    put,
-    request,
-    stream,
-)
+from provide.foundation.transport.types import HTTPMethod, TransportType
 
 __all__ = [
     # Core abstractions
     "Request",
     "Response",
-    
     # Configuration
     "TransportConfig",
     "HTTPConfig",
-    
     # Types
     "TransportType",
     "HTTPMethod",
-    
     # Errors
     "TransportError",
     "TransportConnectionError",
-    "TransportTimeoutError", 
+    "TransportTimeoutError",
     "HTTPResponseError",
     "TransportNotFoundError",
-    
     # Transport implementations
     "HTTPTransport",
-    
     # Middleware
     "Middleware",
     "MiddlewarePipeline",
@@ -133,13 +128,11 @@ __all__ = [
     "RetryMiddleware",
     "MetricsMiddleware",
     "create_default_pipeline",
-    
     # Registry
     "register_transport",
     "get_transport",
     "get_transport_info",
     "list_registered_transports",
-    
     # Client API
     "UniversalClient",
     "get_default_client",
@@ -147,9 +140,9 @@ __all__ = [
     "get",
     "post",
     "put",
-    "patch", 
+    "patch",
     "delete",
     "head",
     "options",
     "stream",
-]
+]

provide/foundation/transport/base.py

@@ -2,7 +2,6 @@
 Core transport abstractions.
 """
 
-import time
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator
 from typing import Any, Protocol, runtime_checkable
@@ -18,7 +17,7 @@ log = get_logger(__name__)
 @define
 class Request:
     """Protocol-agnostic request."""
-    
+
     uri: str
     method: str = "GET"
     headers: Headers = field(factory=dict)
@@ -26,7 +25,7 @@ class Request:
     body: Data = None
     timeout: float | None = None
     metadata: dict[str, Any] = field(factory=dict)
-    
+
     @property
     def transport_type(self) -> TransportType:
         """Infer transport type from URI scheme."""
@@ -36,7 +35,7 @@ class Request:
         except ValueError:
             log.trace(f"Unknown scheme '{scheme}', defaulting to HTTP")
             return TransportType.HTTP
-    
+
     @property
     def base_url(self) -> str:
         """Extract base URL from URI."""
@@ -49,43 +48,44 @@ class Request:
 @define
 class Response:
     """Protocol-agnostic response."""
-    
+
     status: int
     headers: Headers = field(factory=dict)
     body: bytes | str | None = None
     metadata: dict[str, Any] = field(factory=dict)
     elapsed_ms: float = 0
     request: Request | None = None
-    
+
     def is_success(self) -> bool:
         """Check if response indicates success."""
         return 200 <= self.status < 300
-    
+
     def json(self) -> Any:
         """Parse response body as JSON."""
         import json
-        
+
         if isinstance(self.body, bytes):
-            return json.loads(self.body.decode('utf-8'))
+            return json.loads(self.body.decode("utf-8"))
         elif isinstance(self.body, str):
             return json.loads(self.body)
         else:
             raise ValueError("Response body is not JSON-parseable")
-    
+
     @property
     def text(self) -> str:
         """Get response body as text."""
         if isinstance(self.body, bytes):
-            return self.body.decode('utf-8')
+            return self.body.decode("utf-8")
         elif isinstance(self.body, str):
             return self.body
         else:
             return str(self.body or "")
-    
+
     def raise_for_status(self) -> None:
         """Raise error if response status indicates failure."""
         if not self.is_success():
             from provide.foundation.transport.errors import HTTPResponseError
+
             raise HTTPResponseError(
                 f"Request failed with status {self.status}",
                 status_code=self.status,
@@ -96,32 +96,32 @@ class Response:
 @runtime_checkable
 class Transport(Protocol):
     """Abstract transport protocol."""
-    
+
     async def execute(self, request: Request) -> Response:
         """Execute a request and return response."""
         ...
-    
+
     async def stream(self, request: Request) -> AsyncIterator[bytes]:
         """Stream response data."""
         ...
-    
+
     async def connect(self) -> None:
         """Establish connection if needed."""
         ...
-    
+
     async def disconnect(self) -> None:
         """Close connection if needed."""
         ...
-    
+
     def supports(self, transport_type: TransportType) -> bool:
         """Check if this transport handles the given type."""
         ...
-    
+
     async def __aenter__(self) -> "Transport":
         """Context manager entry."""
         await self.connect()
         return self
-    
+
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
         """Context manager exit."""
         await self.disconnect()
@@ -129,43 +129,45 @@ class Transport(Protocol):
 
 class TransportBase(ABC):
     """Base class for transport implementations."""
-    
+
     def __init__(self):
         self._logger = get_logger(self.__class__.__name__)
-    
+
     @abstractmethod
     async def execute(self, request: Request) -> Response:
         """Execute a request and return response."""
         pass
-    
+
     @abstractmethod
     def supports(self, transport_type: TransportType) -> bool:
         """Check if this transport handles the given type."""
         pass
-    
+
     async def connect(self) -> None:
         """Default connect implementation."""
         self._logger.trace("Transport connecting")
-    
+
     async def disconnect(self) -> None:
         """Default disconnect implementation."""
         self._logger.trace("Transport disconnecting")
-    
+
     async def stream(self, request: Request) -> AsyncIterator[bytes]:
         """Default streaming implementation (not supported)."""
-        raise NotImplementedError(f"{self.__class__.__name__} does not support streaming")
-    
+        raise NotImplementedError(
+            f"{self.__class__.__name__} does not support streaming"
+        )
+
     async def __aenter__(self) -> "TransportBase":
         await self.connect()
         return self
-    
+
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
         await self.disconnect()
 
 
 __all__ = [
     "Request",
-    "Response", 
+    "Response",
     "Transport",
     "TransportBase",
-]
+]