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

provide/foundation/console/output.py

@@ -6,6 +6,7 @@ for JSON mode, colors, and proper stream separation.
 """
 
 import json
+import os
 import sys
 from typing import Any
 
@@ -17,34 +18,48 @@ except ImportError:
     click = None
     _HAS_CLICK = False
 
-from provide.foundation.context import Context
+from provide.foundation.context import CLIContext
+from provide.foundation.errors.decorators import with_error_handling
 from provide.foundation.logger import get_logger
 
 log = get_logger(__name__)
 
 
-def _get_context() -> Context | None:
+def _get_context() -> CLIContext | None:
     """Get current context from Click or environment."""
     if not _HAS_CLICK:
         return None
     ctx = click.get_current_context(silent=True)
-    if ctx and hasattr(ctx, "obj") and isinstance(ctx.obj, Context):
+    if ctx and hasattr(ctx, "obj") and isinstance(ctx.obj, CLIContext):
         return ctx.obj
     return None
 
 
-def _should_use_json(ctx: Context | None = None) -> bool:
+def _should_use_json(ctx: CLIContext | None = None) -> bool:
     """Determine if JSON output should be used."""
     if ctx is None:
         ctx = _get_context()
     return ctx.json_output if ctx else False
 
 
-def _should_use_color(ctx: Context | None = None, stream=None) -> bool:
+def _should_use_color(ctx: CLIContext | None = None, stream=None) -> bool:
     """Determine if color output should be used."""
     if ctx is None:
         ctx = _get_context()
 
+    # Check FORCE_COLOR first (enables color even for non-TTY)
+    force_color = os.environ.get('FORCE_COLOR', '').lower()
+    if force_color in ('1', 'true', 'yes'):
+        return True
+
+    # Check NO_COLOR (disables color even for TTY)
+    if os.environ.get('NO_COLOR'):
+        return False
+
+    # Check context no_color setting
+    if ctx and ctx.no_color:
+        return False
+
     # Check if stream is a TTY
     if stream:
         return getattr(stream, "isatty", lambda: False)()
@@ -52,19 +67,21 @@ def _should_use_color(ctx: Context | None = None, stream=None) -> bool:
     return sys.stdout.isatty() or sys.stderr.isatty()
 
 
+@with_error_handling(fallback=None, suppress=(TypeError, ValueError, AttributeError))
 def _output_json(data: Any, stream=sys.stdout) -> None:
     """Output data as JSON."""
-    try:
-        json_str = json.dumps(data, indent=2, default=str)
+    json_str = json.dumps(data, indent=2, default=str)
+    if _HAS_CLICK:
         click.echo(json_str, file=stream)
-    except (TypeError, ValueError) as e:
-        # Fallback to string representation
-        click.echo(
-            json.dumps({"error": f"JSON encoding failed: {e}", "data": str(data)}),
-            file=stream,
-        )
+    else:
+        print(json_str, file=stream)
 
 
+@with_error_handling(
+    fallback=None,
+    suppress=(OSError, IOError, UnicodeEncodeError),
+    context_provider=lambda: {"function": "pout"}
+)
 def pout(message: Any, **kwargs: Any) -> None:
     """
     Output message to stdout.
@@ -122,6 +139,11 @@ def pout(message: Any, **kwargs: Any) -> None:
                 print(output, file=sys.stdout, end="")
 
 
+@with_error_handling(
+    fallback=None,
+    suppress=(OSError, IOError, UnicodeEncodeError),
+    context_provider=lambda: {"function": "perr"}
+)
 def perr(message: Any, **kwargs: Any) -> None:
     """
     Output message to stderr.

provide/foundation/context/__init__.py

@@ -1,12 +1,16 @@
 """
 Core context management for provide-foundation.
 
-Provides unified application context that bridges configuration, runtime state,
-and presentation concerns across the foundation library.
+Provides CLI runtime context for managing command execution state,
+output formatting, and CLI-specific settings.
 """
 
-from provide.foundation.context.core import Context
+from provide.foundation.context.core import CLIContext
+
+# Backward compatibility
+Context = CLIContext
 
 __all__ = [
-    "Context",
+    "CLIContext",
+    "Context",  # Backward compatibility
 ]

provide/foundation/context/core.py

@@ -8,9 +8,11 @@ from typing import Any
 
 from attrs import define, field, fields, validators
 
+from provide.foundation.config.env import RuntimeConfig
+from provide.foundation.config.base import field as config_field, ConfigSource
+from provide.foundation.config.converters import parse_bool_strict
 from provide.foundation.logger import get_logger
 from provide.foundation.logger.config import TelemetryConfig
-from provide.foundation.utils.parsing import parse_bool
 
 try:
     import tomli as tomllib
@@ -29,36 +31,68 @@ except ImportError:
 VALID_LOG_LEVELS = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
 
 
-@define(slots=True, frozen=False)
-class Context:
+@define(slots=True, repr=False)
+class CLIContext(RuntimeConfig):
     """
-    Unified context for configuration and CLI state.
+    Runtime context for CLI execution and state management.
 
-    Combines configuration management with runtime state for CLI tools
-    and services. Supports loading from files, environment variables,
-    and programmatic updates.
+    Manages CLI-specific settings, output formatting, and runtime state
+    during command execution. Supports loading from files, environment variables,
+    and programmatic updates during CLI command execution.
     """
 
-    log_level: str = field(
-        default="INFO", validator=validators.in_(VALID_LOG_LEVELS), converter=str.upper
+    log_level: str = config_field(
+        default="INFO",
+        env_var="PROVIDE_LOG_LEVEL",
+        converter=str.upper,
+        validator=validators.in_(VALID_LOG_LEVELS),
+        description="Logging level for CLI output"
     )
-    profile: str = field(default="default")
-    debug: bool = field(default=False, converter=lambda x: parse_bool(x, strict=True))
-    json_output: bool = field(
-        default=False, converter=lambda x: parse_bool(x, strict=True)
+    profile: str = config_field(
+        default="default",
+        env_var="PROVIDE_PROFILE",
+        description="Configuration profile to use"
     )
-    config_file: Path | None = field(
-        default=None, converter=lambda x: Path(x) if x else None
+    debug: bool = config_field(
+        default=False,
+        env_var="PROVIDE_DEBUG",
+        converter=parse_bool_strict,
+        description="Enable debug mode"
     )
-    log_file: Path | None = field(
-        default=None, converter=lambda x: Path(x) if x else None
+    json_output: bool = config_field(
+        default=False,
+        env_var="PROVIDE_JSON_OUTPUT",
+        converter=parse_bool_strict,
+        description="Output in JSON format"
     )
-    log_format: str = field(default="key_value")
-    no_color: bool = field(
-        default=False, converter=lambda x: parse_bool(x, strict=True)
+    config_file: Path | None = config_field(
+        default=None,
+        env_var="PROVIDE_CONFIG_FILE",
+        converter=lambda x: Path(x) if x else None,
+        description="Path to configuration file"
     )
-    no_emoji: bool = field(
-        default=False, converter=lambda x: parse_bool(x, strict=True)
+    log_file: Path | None = config_field(
+        default=None,
+        env_var="PROVIDE_LOG_FILE",
+        converter=lambda x: Path(x) if x else None,
+        description="Path to log file"
+    )
+    log_format: str = config_field(
+        default="key_value",
+        env_var="PROVIDE_LOG_FORMAT",
+        description="Log output format (key_value or json)"
+    )
+    no_color: bool = config_field(
+        default=False,
+        env_var="NO_COLOR",
+        converter=parse_bool_strict,
+        description="Disable colored output"
+    )
+    no_emoji: bool = config_field(
+        default=False,
+        env_var="PROVIDE_NO_EMOJI",
+        converter=parse_bool_strict,
+        description="Disable emoji in output"
     )
 
     # Private fields - using Factory for mutable defaults
@@ -69,62 +103,9 @@ class Context:
         """Post-initialization hook."""
         pass  # Validation is handled by attrs validators
 
-    def _validate(self) -> None:
-        """Validate context values. For attrs compatibility."""
-        # Validation is handled by attrs validators automatically
-        pass
-
-    @classmethod
-    def from_env(cls, prefix: str = "PROVIDE") -> "Context":
-        """
-        Create context from environment variables using TelemetryConfig system.
-
-        Args:
-            prefix: Environment variable prefix (default: PROVIDE)
-
-        Returns:
-            New Context instance with values from environment
-        """
-        # Use the main TelemetryConfig system for parsing
-        telemetry_config = TelemetryConfig.from_env(strict=False)
-
-        kwargs = {}
-
-        # Map telemetry config values to CLI context
-        kwargs["log_level"] = telemetry_config.logging.default_level
-        if telemetry_config.logging.console_formatter:
-            kwargs["log_format"] = telemetry_config.logging.console_formatter
-        if telemetry_config.logging.log_file:
-            kwargs["log_file"] = telemetry_config.logging.log_file
-
-        # CLI-specific environment variables that don't exist in TelemetryConfig
-        if profile := os.environ.get(f"{prefix}_PROFILE"):
-            kwargs["profile"] = profile
-
-        if debug := os.environ.get(f"{prefix}_DEBUG"):
-            kwargs["debug"] = debug.lower() in ("true", "1", "yes", "on")
-
-        if json_output := os.environ.get(f"{prefix}_JSON_OUTPUT"):
-            kwargs["json_output"] = json_output.lower() in ("true", "1", "yes", "on")
-
-        if config_file := os.environ.get(f"{prefix}_CONFIG_FILE"):
-            kwargs["config_file"] = Path(config_file)
-
-        # Map emoji settings to no_emoji (inverted)
-        kwargs["no_emoji"] = not (
-            telemetry_config.logging.logger_name_emoji_prefix_enabled
-            and telemetry_config.logging.das_emoji_prefix_enabled
-        )
-
-        # Check for explicit NO_COLOR override
-        if no_color := os.environ.get(f"{prefix}_NO_COLOR"):
-            kwargs["no_color"] = no_color.lower() in ("true", "1", "yes", "on")
-
-        return cls(**kwargs)
-
     def update_from_env(self, prefix: str = "PROVIDE") -> None:
         """
-        Update context from environment variables using TelemetryConfig system.
+        Update context from environment variables.
 
         Args:
             prefix: Environment variable prefix (default: PROVIDE)
@@ -132,28 +113,19 @@ class Context:
         if self._frozen:
             raise RuntimeError("Context is frozen and cannot be modified")
 
-        env_ctx = self.from_env(prefix)
-
-        # Update values from TelemetryConfig (these are always updated since they're the primary source)
-        self.log_level = env_ctx.log_level
-        self.log_format = env_ctx.log_format
-        if env_ctx.log_file:
-            self.log_file = env_ctx.log_file
-        self.no_emoji = env_ctx.no_emoji
-
-        # Update CLI-specific values only if explicitly set in environment
-        if os.environ.get(f"{prefix}_PROFILE"):
-            self.profile = env_ctx.profile
-        if os.environ.get(f"{prefix}_DEBUG"):
-            self.debug = env_ctx.debug
-        if os.environ.get(f"{prefix}_JSON_OUTPUT"):
-            self.json_output = env_ctx.json_output
-        if os.environ.get(f"{prefix}_CONFIG_FILE"):
-            self.config_file = env_ctx.config_file
-        if os.environ.get(f"{prefix}_NO_COLOR"):
-            self.no_color = env_ctx.no_color
-
-        self._validate()
+        # Create default instance and environment instance
+        default_ctx = self.__class__()  # All defaults
+        env_ctx = self.from_env(prefix=prefix)  # Environment + defaults
+        
+        # Only update fields where environment differs from default
+        for attr in fields(self.__class__):
+            if not attr.name.startswith("_"):  # Skip private fields
+                default_value = getattr(default_ctx, attr.name)
+                env_value = getattr(env_ctx, attr.name)
+                
+                # If environment value differs from default, it came from env
+                if env_value != default_value:
+                    setattr(self, attr.name, env_value)
 
     def to_dict(self) -> dict[str, Any]:
         """Convert context to dictionary."""
@@ -170,15 +142,16 @@ class Context:
         }
 
     @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "Context":
+    def from_dict(cls, data: dict[str, Any], source: ConfigSource = ConfigSource.RUNTIME) -> "CLIContext":
         """
         Create context from dictionary.
 
         Args:
             data: Dictionary with context values
+            source: Source of the configuration data
 
         Returns:
-            New Context instance
+            New CLIContext instance
         """
         kwargs = {}
 
@@ -212,9 +185,7 @@ class Context:
         Args:
             path: Path to configuration file
         """
-        if self._frozen:
-            raise RuntimeError("Context is frozen and cannot be modified")
-
+        # CLIContext is not frozen, so we can modify it
         path = Path(path)
         if not path.exists():
             raise FileNotFoundError(f"Config file not found: {path}")
@@ -294,16 +265,16 @@ class Context:
 
         path.write_text(content)
 
-    def merge(self, other: "Context", override_defaults: bool = False) -> "Context":
+    def merge(self, other: "CLIContext", override_defaults: bool = False) -> "CLIContext":
         """
         Merge with another context, with other taking precedence.
 
         Args:
-            other: Context to merge with
+            other: CLIContext to merge with
             override_defaults: If False, only override if other's value differs from its class default
 
         Returns:
-            New merged Context instance
+            New merged CLIContext instance
         """
         merged_data = self.to_dict()
         other_data = other.to_dict()
@@ -318,7 +289,7 @@ class Context:
             from attrs import Factory
 
             defaults = {}
-            for f in fields(Context):
+            for f in fields(CLIContext):
                 if not f.name.startswith("_"):  # Skip private fields
                     if isinstance(f.default, Factory):
                         defaults[f.name] = f.default.factory()
@@ -333,7 +304,7 @@ class Context:
                         continue
                     merged_data[key] = value
 
-        return Context.from_dict(merged_data)
+        return CLIContext.from_dict(merged_data)
 
     def freeze(self) -> None:
         """Freeze context to prevent further modifications."""
@@ -341,7 +312,7 @@ class Context:
         # This is kept for API compatibility but does nothing
         self._frozen = True
 
-    def copy(self) -> "Context":
+    def copy(self) -> "CLIContext":
         """Create a deep copy of the context."""
         return copy.deepcopy(self)
 
@@ -354,3 +325,8 @@ class Context:
                 profile=self.profile,
             )
         return self._logger
+
+    def _validate(self) -> None:
+        """Validate context values. For attrs compatibility."""
+        # Validation is handled by attrs validators automatically
+        pass

provide/foundation/core.py

@@ -5,7 +5,7 @@
 Foundation Telemetry Core Setup Functions.
 """
 
-from provide.foundation.logger.setup.emoji_resolver import ResolvedEmojiConfig
+# Emoji resolver removed - using event sets now
 from provide.foundation.setup import (
     reset_foundation_setup_for_testing,
     setup_telemetry,
@@ -13,7 +13,6 @@ from provide.foundation.setup import (
 )
 
 __all__ = [
-    "ResolvedEmojiConfig",
     "reset_foundation_setup_for_testing",
     "setup_telemetry",
     "shutdown_foundation_telemetry",

provide/foundation/crypto/__init__.py

@@ -179,4 +179,6 @@ __all__ = [
     "CurveType",
     # Legacy compatibility
     "generate_key_pair",
+    # Internal flags (for tests)
+    "_HAS_CRYPTO",
 ]

provide/foundation/crypto/certificates/__init__.py

@@ -0,0 +1,34 @@
+"""X.509 certificate generation and management."""
+
+# Import from submodules using absolute imports
+from provide.foundation.crypto.certificates.base import (
+    CertificateBase,
+    CertificateConfig,
+    CertificateError,
+    CurveType,
+    KeyPair,
+    KeyType,
+    PublicKey,
+    _HAS_CRYPTO,
+    _require_crypto,
+)
+from provide.foundation.crypto.certificates.certificate import Certificate
+from provide.foundation.crypto.certificates.factory import create_ca, create_self_signed
+from provide.foundation.crypto.certificates.operations import (
+    create_x509_certificate,
+    validate_signature,
+)
+
+# Re-export public types - maintaining exact same API
+__all__ = [
+    "Certificate",
+    "CertificateBase",
+    "CertificateConfig",
+    "CertificateError",
+    "CurveType",
+    "KeyType",
+    "create_self_signed",
+    "create_ca",
+    "_HAS_CRYPTO",  # For testing
+    "_require_crypto",  # For testing
+]

provide/foundation/crypto/certificates/base.py

@@ -0,0 +1,173 @@
+"""Certificate base classes, types, and utilities."""
+
+from datetime import UTC, datetime
+from enum import StrEnum, auto
+import traceback
+from typing import NotRequired, Self, TypeAlias, TypedDict
+
+from attrs import define, field
+
+try:
+    from cryptography import x509
+    from cryptography.hazmat.backends import default_backend
+    from cryptography.hazmat.primitives import hashes, serialization
+    from cryptography.hazmat.primitives.asymmetric import ec, rsa
+    from cryptography.hazmat.primitives.serialization import load_pem_private_key
+    from cryptography.x509 import Certificate as X509Certificate
+    from cryptography.x509.oid import ExtendedKeyUsageOID, NameOID
+
+    _HAS_CRYPTO = True
+except ImportError:
+    # Stub out cryptography types for type hints
+    x509 = None
+    default_backend = None
+    hashes = None
+    serialization = None
+    ec = None
+    rsa = None
+    load_pem_private_key = None
+    X509Certificate = None
+    ExtendedKeyUsageOID = None
+    NameOID = None
+    _HAS_CRYPTO = False
+
+from provide.foundation import logger
+from provide.foundation.crypto.constants import (
+    DEFAULT_RSA_KEY_SIZE,
+)
+from provide.foundation.errors.config import ValidationError
+
+
+def _require_crypto():
+    """Ensure cryptography is available for crypto operations."""
+    if not _HAS_CRYPTO:
+        raise ImportError(
+            "Cryptography features require optional dependencies. Install with: "
+            "pip install 'provide-foundation[crypto]'"
+        )
+
+
+class CertificateError(ValidationError):
+    """Certificate-related errors."""
+
+    def __init__(self, message: str, hint: str | None = None) -> None:
+        super().__init__(
+            message=message,
+            field="certificate",
+            value=None,
+            rule=hint or "Certificate operation failed",
+        )
+
+
+class KeyType(StrEnum):
+    RSA = auto()
+    ECDSA = auto()
+
+
+class CurveType(StrEnum):
+    SECP256R1 = auto()
+    SECP384R1 = auto()
+    SECP521R1 = auto()
+
+
+class CertificateConfig(TypedDict):
+    common_name: str
+    organization: str
+    alt_names: list[str]
+    key_type: KeyType
+    not_valid_before: datetime
+    not_valid_after: datetime
+    # Optional key generation parameters
+    key_size: NotRequired[int]
+    curve: NotRequired[CurveType]
+
+
+if _HAS_CRYPTO:
+    KeyPair: TypeAlias = rsa.RSAPrivateKey | ec.EllipticCurvePrivateKey
+    PublicKey: TypeAlias = rsa.RSAPublicKey | ec.EllipticCurvePublicKey
+else:
+    KeyPair: TypeAlias = None
+    PublicKey: TypeAlias = None
+
+
+@define(slots=True, frozen=True)
+class CertificateBase:
+    """Immutable base certificate data."""
+
+    subject: "x509.Name"
+    issuer: "x509.Name"
+    public_key: "PublicKey"
+    not_valid_before: datetime
+    not_valid_after: datetime
+    serial_number: int
+
+    @classmethod
+    def create(cls, config: CertificateConfig) -> tuple[Self, "KeyPair"]:
+        """Create a new certificate base and private key."""
+        _require_crypto()
+        try:
+            logger.debug("📜📝🚀 CertificateBase.create: Starting base creation")
+            not_valid_before = config["not_valid_before"]
+            not_valid_after = config["not_valid_after"]
+
+            if not_valid_before.tzinfo is None:
+                not_valid_before = not_valid_before.replace(tzinfo=UTC)
+            if not_valid_after.tzinfo is None:
+                not_valid_after = not_valid_after.replace(tzinfo=UTC)
+
+            logger.debug(
+                f"📜⏳✅ CertificateBase.create: Using validity: "
+                f"{not_valid_before} to {not_valid_after}"
+            )
+
+            private_key: KeyPair
+            match config["key_type"]:
+                case KeyType.RSA:
+                    key_size = config.get("key_size", DEFAULT_RSA_KEY_SIZE)
+                    logger.debug(f"📜🔑🚀 Generating RSA key (size: {key_size})")
+                    private_key = rsa.generate_private_key(
+                        public_exponent=65537, key_size=key_size
+                    )
+                case KeyType.ECDSA:
+                    curve_choice = config.get("curve", CurveType.SECP384R1)
+                    logger.debug(f"📜🔑🚀 Generating ECDSA key (curve: {curve_choice})")
+                    curve = getattr(ec, curve_choice.name)()
+                    private_key = ec.generate_private_key(curve)
+                case _:
+                    raise ValueError(
+                        f"Internal Error: Unsupported key type: {config['key_type']}"
+                    )
+
+            subject = cls._create_name(config["common_name"], config["organization"])
+            issuer = cls._create_name(config["common_name"], config["organization"])
+
+            serial_number = x509.random_serial_number()
+            logger.debug(f"📜🔑✅ Generated serial number: {serial_number}")
+
+            base = cls(
+                subject=subject,
+                issuer=issuer,
+                public_key=private_key.public_key(),
+                not_valid_before=not_valid_before,
+                not_valid_after=not_valid_after,
+                serial_number=serial_number,
+            )
+            logger.debug("📜📝✅ CertificateBase.create: Base creation complete")
+            return base, private_key
+
+        except Exception as e:
+            logger.error(
+                f"📜❌ CertificateBase.create: Failed: {e}",
+                extra={"error": str(e), "trace": traceback.format_exc()},
+            )
+            raise CertificateError(f"Failed to generate certificate base: {e}") from e
+
+    @staticmethod
+    def _create_name(common_name: str, org: str) -> "x509.Name":
+        """Helper method to construct an X.509 name."""
+        return x509.Name(
+            [
+                x509.NameAttribute(NameOID.COMMON_NAME, common_name),
+                x509.NameAttribute(NameOID.ORGANIZATION_NAME, org),
+            ]
+        )