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

provide/foundation/crypto/certificates/operations.py

@@ -24,13 +24,12 @@ except ImportError:
     _HAS_CRYPTO = False
 
 from provide.foundation import logger
-from provide.foundation.crypto.constants import (
-    DEFAULT_CERTIFICATE_CURVE,
-    DEFAULT_CERTIFICATE_KEY_TYPE,
-    DEFAULT_CERTIFICATE_VALIDITY_DAYS,
-    DEFAULT_RSA_KEY_SIZE,
+from provide.foundation.crypto.certificates.base import (
+    CertificateBase,
+    CertificateError,
+    KeyPair,
+    PublicKey,
 )
-from provide.foundation.crypto.certificates.base import CertificateBase, CertificateError, KeyPair, PublicKey
 
 
 def create_x509_certificate(
@@ -46,8 +45,12 @@ def create_x509_certificate(
     try:
         logger.debug("📜📝🚀 create_x509_certificate: Building certificate")
 
-        actual_issuer_name = issuer_name_override if issuer_name_override else base.issuer
-        actual_signing_key = signing_key_override if signing_key_override else private_key
+        actual_issuer_name = (
+            issuer_name_override if issuer_name_override else base.issuer
+        )
+        actual_signing_key = (
+            signing_key_override if signing_key_override else private_key
+        )
 
         if not actual_signing_key:
             raise CertificateError(
@@ -147,7 +150,11 @@ def create_x509_certificate(
         raise CertificateError("Failed to create X.509 certificate object") from e
 
 
-def validate_signature(signed_cert_obj: "X509Certificate", signing_cert_obj: "X509Certificate", signing_public_key: "PublicKey") -> bool:
+def validate_signature(
+    signed_cert_obj: "X509Certificate",
+    signing_cert_obj: "X509Certificate",
+    signing_public_key: "PublicKey",
+) -> bool:
     """Internal helper: Validates signature and issuer/subject match."""
     if signed_cert_obj.issuer != signing_cert_obj.subject:
         logger.debug(
@@ -195,4 +202,4 @@ def validate_signature(signed_cert_obj: "X509Certificate", signing_cert_obj: "X5
 
     except Exception as e:
         logger.debug(f"📜🔍❌ Signature validation failed: {type(e).__name__}: {e}")
-        return False
+        return False

provide/foundation/crypto/certificates/trust.py

@@ -1,9 +1,14 @@
 """Certificate trust chain and verification utilities."""
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from provide.foundation.crypto.certificates.certificate import Certificate
+
 try:
     from cryptography import x509
     from cryptography.hazmat.primitives.asymmetric import ec, rsa
-    
+
     _HAS_CRYPTO = True
 except ImportError:
     x509 = None
@@ -23,45 +28,41 @@ def verify_trust(
 ) -> bool:
     """
     Verifies if the other_cert is trusted based on this certificate's trust chain.
-    
+
     Args:
         cert: The certificate doing the verification
         other_cert: The certificate to verify
         trust_chain: List of trusted certificates
-        
+
     Returns:
         True if the certificate is trusted, False otherwise
     """
     if other_cert is None:
         raise CertificateError("Cannot verify trust: other_cert is None")
-    
+
     logger.debug(
         f"📜🔍🚀 Verifying trust for cert S/N {other_cert.serial_number} "
         f"against chain of S/N {cert.serial_number}"
     )
-    
+
     if not other_cert.is_valid:
-        logger.debug(
-            "📜🔍⚠️ Trust verification failed: Other certificate is not valid"
-        )
+        logger.debug("📜🔍⚠️ Trust verification failed: Other certificate is not valid")
         return False
     if not other_cert.public_key:
         raise CertificateError(
             "Cannot verify trust: Other certificate has no public key"
         )
-    
+
     if cert == other_cert:
         logger.debug(
             "📜🔍✅ Trust verified: Certificates are identical (based on subject/serial)"
         )
         return True
-    
+
     if other_cert in trust_chain:
-        logger.debug(
-            "📜🔍✅ Trust verified: Other certificate found in trust chain"
-        )
+        logger.debug("📜🔍✅ Trust verified: Other certificate found in trust chain")
         return True
-    
+
     for trusted_cert in trust_chain:
         logger.debug(
             f"📜🔍🔁 Checking signature against trusted cert S/N {trusted_cert.serial_number}"
@@ -74,7 +75,7 @@ def verify_trust(
                 f"{trusted_cert.serial_number}"
             )
             return True
-    
+
     logger.debug(
         "📜🔍❌ Trust verification failed: Other certificate not identical, "
         "not in chain, and not signed by any cert in chain"
@@ -83,16 +84,15 @@ def verify_trust(
 
 
 def validate_signature_wrapper(
-    signed_cert: "Certificate", 
-    signing_cert: "Certificate"
+    signed_cert: "Certificate", signing_cert: "Certificate"
 ) -> bool:
     """
     Internal helper: Validates signature and issuer/subject match.
-    
+
     Args:
         signed_cert: The certificate that was signed
         signing_cert: The certificate that did the signing
-        
+
     Returns:
         True if signature is valid, False otherwise
     """
@@ -101,7 +101,7 @@ def validate_signature_wrapper(
             "📜🔍❌ Cannot validate signature: Certificate object(s) not initialized"
         )
         return False
-    
+
     return validate_signature(
         signed_cert._cert, signing_cert._cert, signing_cert.public_key
-    )
+    )

provide/foundation/env/__init__.py

@@ -0,0 +1,28 @@
+"""
+Environment variable access utilities for Foundation.
+
+Provides consistent environment variable handling with validation,
+testing support, and integration with Foundation's configuration system.
+"""
+
+from provide.foundation.env.core import (
+    get_env,
+    get_env_bool,
+    get_env_float,
+    get_env_int,
+    get_env_list,
+    has_env,
+    set_env,
+    unset_env,
+)
+
+__all__ = [
+    "get_env",
+    "get_env_bool",
+    "get_env_float",
+    "get_env_int",
+    "get_env_list",
+    "has_env",
+    "set_env",
+    "unset_env",
+]

provide/foundation/env/core.py

@@ -0,0 +1,218 @@
+"""Core environment variable utilities for Foundation."""
+
+import os
+
+from provide.foundation.errors import ValidationError
+
+
+def get_env(key: str, default: str | None = None) -> str | None:
+    """
+    Get environment variable with Foundation tracking.
+
+    Args:
+        key: Environment variable name
+        default: Default value if variable not found
+
+    Returns:
+        Environment variable value or default
+
+    Example:
+        >>> get_env("HOME")  # doctest: +SKIP
+        '/Users/username'
+        >>> get_env("NONEXISTENT", "fallback")
+        'fallback'
+    """
+    return os.environ.get(key, default)
+
+
+def set_env(key: str, value: str) -> None:
+    """
+    Set environment variable with validation.
+
+    Args:
+        key: Environment variable name
+        value: Value to set
+
+    Raises:
+        ValidationError: If key or value is invalid
+
+    Example:
+        >>> set_env("TEST_VAR", "test_value")
+        >>> get_env("TEST_VAR")
+        'test_value'
+    """
+    if not isinstance(key, str) or not key:
+        raise ValidationError("Environment variable key must be a non-empty string")
+    if not isinstance(value, str):
+        raise ValidationError("Environment variable value must be a string")
+
+    os.environ[key] = value
+
+
+def unset_env(key: str) -> None:
+    """
+    Remove environment variable if it exists.
+
+    Args:
+        key: Environment variable name to remove
+
+    Example:
+        >>> set_env("TEMP_VAR", "value")
+        >>> unset_env("TEMP_VAR")
+        >>> has_env("TEMP_VAR")
+        False
+    """
+    os.environ.pop(key, None)
+
+
+def has_env(key: str) -> bool:
+    """
+    Check if environment variable exists.
+
+    Args:
+        key: Environment variable name
+
+    Returns:
+        True if variable exists, False otherwise
+
+    Example:
+        >>> has_env("PATH")
+        True
+        >>> has_env("DEFINITELY_NOT_SET")
+        False
+    """
+    return key in os.environ
+
+
+def get_env_int(key: str, default: int | None = None) -> int | None:
+    """
+    Get environment variable as integer.
+
+    Args:
+        key: Environment variable name
+        default: Default value if variable not found or invalid
+
+    Returns:
+        Integer value or default
+
+    Raises:
+        ValidationError: If value exists but cannot be converted to int
+
+    Example:
+        >>> set_env("PORT", "8080")
+        >>> get_env_int("PORT")
+        8080
+        >>> get_env_int("MISSING_PORT", 3000)
+        3000
+    """
+    value = os.environ.get(key)
+    if value is None:
+        return default
+
+    try:
+        return int(value)
+    except ValueError as e:
+        raise ValidationError(
+            f"Environment variable {key}='{value}' cannot be converted to int"
+        ) from e
+
+
+def get_env_bool(key: str, default: bool | None = None) -> bool | None:
+    """
+    Get environment variable as boolean.
+
+    Recognizes: true/false, yes/no, 1/0, on/off (case insensitive)
+
+    Args:
+        key: Environment variable name
+        default: Default value if variable not found
+
+    Returns:
+        Boolean value or default
+
+    Raises:
+        ValidationError: If value exists but cannot be converted to bool
+
+    Example:
+        >>> set_env("DEBUG", "true")
+        >>> get_env_bool("DEBUG")
+        True
+        >>> set_env("VERBOSE", "no")
+        >>> get_env_bool("VERBOSE")
+        False
+    """
+    value = os.environ.get(key)
+    if value is None:
+        return default
+
+    value_lower = value.lower().strip()
+    if value_lower in ("true", "yes", "1", "on"):
+        return True
+    elif value_lower in ("false", "no", "0", "off"):
+        return False
+    else:
+        raise ValidationError(
+            f"Environment variable {key}='{value}' cannot be converted to bool"
+        )
+
+
+def get_env_float(key: str, default: float | None = None) -> float | None:
+    """
+    Get environment variable as float.
+
+    Args:
+        key: Environment variable name
+        default: Default value if variable not found or invalid
+
+    Returns:
+        Float value or default
+
+    Raises:
+        ValidationError: If value exists but cannot be converted to float
+
+    Example:
+        >>> set_env("TIMEOUT", "30.5")
+        >>> get_env_float("TIMEOUT")
+        30.5
+    """
+    value = os.environ.get(key)
+    if value is None:
+        return default
+
+    try:
+        return float(value)
+    except ValueError as e:
+        raise ValidationError(
+            f"Environment variable {key}='{value}' cannot be converted to float"
+        ) from e
+
+
+def get_env_list(
+    key: str, separator: str = ",", default: list[str] | None = None
+) -> list[str] | None:
+    """
+    Get environment variable as list of strings.
+
+    Args:
+        key: Environment variable name
+        separator: Character to split on (default: comma)
+        default: Default value if variable not found
+
+    Returns:
+        List of strings or default
+
+    Example:
+        >>> set_env("ALLOWED_HOSTS", "localhost,127.0.0.1,example.com")
+        >>> get_env_list("ALLOWED_HOSTS")
+        ['localhost', '127.0.0.1', 'example.com']
+        >>> get_env_list("MISSING", default=["fallback"])
+        ['fallback']
+    """
+    value = os.environ.get(key)
+    if value is None:
+        return default
+
+    if not value.strip():
+        return []
+
+    return [item.strip() for item in value.split(separator) if item.strip()]

provide/foundation/errors/__init__.py

@@ -6,8 +6,6 @@ and utilities for robust error handling throughout the application.
 """
 
 from provide.foundation.errors.auth import AuthenticationError, AuthorizationError
-# Re-export from resilience module for compatibility
-from provide.foundation.resilience.decorators import retry as retry_on_error
 from provide.foundation.errors.base import FoundationError
 from provide.foundation.errors.config import (
     ConfigurationError,
@@ -53,6 +51,9 @@ from provide.foundation.errors.types import (
     ErrorMetadata,
 )
 
+# Re-export from resilience module for compatibility
+from provide.foundation.resilience.decorators import retry as retry_on_error
+
 __all__ = [
     "AlreadyExistsError",
     "AuthenticationError",

provide/foundation/errors/decorators.py

@@ -144,7 +144,6 @@ def with_error_handling(
         return decorator(func)
 
 
-
 def suppress_and_log(
     *exceptions: type[Exception],
     fallback: Any = None,
@@ -249,5 +248,3 @@ def fallback_on_error(
         return wrapper  # type: ignore
 
     return decorator
-
-

provide/foundation/errors/types.py

@@ -118,7 +118,6 @@ class ErrorMetadata:
         return result
 
 
-
 @define(kw_only=True, slots=True)
 class ErrorResponse:
     """Structured error response for APIs and external interfaces.

provide/foundation/eventsets/display.py

@@ -2,10 +2,9 @@
 Event set display utilities for Foundation.
 """
 
-from provide.foundation.logger import get_logger
-
-from provide.foundation.eventsets.registry import get_registry, discover_event_sets
+from provide.foundation.eventsets.registry import discover_event_sets, get_registry
 from provide.foundation.eventsets.resolver import get_resolver
+from provide.foundation.logger import get_logger
 
 logger = get_logger(__name__)
 
@@ -17,16 +16,16 @@ def show_event_matrix() -> None:
     """
     # Ensure event sets are discovered
     discover_event_sets()
-    
+
     registry = get_registry()
     resolver = get_resolver()
-    
+
     # Force resolution to ensure everything is loaded
     resolver.resolve()
-    
+
     lines: list[str] = ["Foundation Event Sets: Active Configuration"]
     lines.append("=" * 70)
-    
+
     # Show registered event sets
     event_sets = registry.list_event_sets()
     if event_sets:
@@ -35,7 +34,7 @@ def show_event_matrix() -> None:
             lines.append(f"\n  {config.name} (priority: {config.priority})")
             if config.description:
                 lines.append(f"    {config.description}")
-            
+
             # Show field mappings
             if config.field_mappings:
                 lines.append(f"    Field Mappings ({len(config.field_mappings)}):")
@@ -43,7 +42,7 @@ def show_event_matrix() -> None:
                     lines.append(f"      - {mapping.log_key}")
                 if len(config.field_mappings) > 5:
                     lines.append(f"      ... and {len(config.field_mappings) - 5} more")
-            
+
             # Show event sets
             if config.event_sets:
                 lines.append(f"    Event Sets ({len(config.event_sets)}):")
@@ -59,15 +58,15 @@ def show_event_matrix() -> None:
                     )
     else:
         lines.append("\n  (No event sets registered)")
-    
+
     lines.append("\n" + "=" * 70)
-    
+
     # Show resolved state
     if resolver._resolved:
         lines.append("\nResolver State:")
         lines.append(f"  Total Field Mappings: {len(resolver._field_mappings)}")
         lines.append(f"  Total Event Sets: {len(resolver._event_sets)}")
-        
+
         # Show sample visual markers
         if resolver._event_sets:
             lines.append("\n  Sample Visual Markers:")
@@ -79,6 +78,6 @@ def show_event_matrix() -> None:
                         lines.append(f"      {marker} -> {key}")
     else:
         lines.append("\n  (Resolver not yet initialized)")
-    
+
     # Log the complete display
-    logger.info("\n".join(lines))
+    logger.info("\n".join(lines))