py-wlcli 0.8.0__py3-none-any.whl

wl_cli/utils/config/defaults.py

@@ -0,0 +1,142 @@
+"""Default configuration constants and helper functions."""
+
+import os
+from typing import Any
+
+from wl_cli import __version__
+
+# Inlined from .core constants to avoid circular import (core -> defaults -> core)
+ENVIRONMENT_DEVELOPMENT = "development"
+LOG_DIRECTORY = "log"
+LOG_FILE_NAME = "wl_action.log"
+# This is the **single** definition of the ``.wl`` directory name (#119). A second
+# copy used to live in ``core``; the deploy-root path now derives its ``.wl`` from
+# ``Root.wl_dir()`` instead, and ``config_loader`` imports this name for the
+# user-level ``~/.wl/config.json``. It has to stay here rather than in ``core``:
+# this module is the leaf of the ``core -> defaults`` dependency, so only it can
+# be imported by both.
+WL_DIRECTORY = ".wl"
+
+DEFAULT_LOG_LEVEL = "INFO"
+
+DEFAULT_LOG_FILE = os.path.join(WL_DIRECTORY, LOG_DIRECTORY, LOG_FILE_NAME)
+
+DEFAULT_LOG_CONSOLE = False
+
+DEFAULT_LOG_CONSOLE_FORMAT = "colored"
+
+DEFAULT_LOG_FILE_FORMAT = "human"
+
+DEFAULT_LOG_MAX_SIZE = 10 * 1024 * 1024
+
+DEFAULT_LOG_MAX_BACKUPS = 5
+
+DEFAULT_LOG_ROTATE_DAYS = 7
+
+DEFAULT_LANGUAGE = "auto"
+
+DEFAULT_ALIASES: dict[str, str] = {}
+
+DEFAULT_VERSION = __version__
+
+DEFAULT_ENVIRONMENT = ENVIRONMENT_DEVELOPMENT
+
+DEFAULT_COVERAGE_FAIL_UNDER = 70.0
+DEFAULT_COVERAGE_CACHE_ENABLED = True
+DEFAULT_COVERAGE_PARALLEL_WORKERS = None
+
+# Environment-specific defaults
+ENVIRONMENT_DEFAULTS = {
+    "development": {
+        "log_level": "DEBUG",
+        "log_console": True,
+        "log_console_format": "colored",
+        "log_file_format": "human",
+    },
+    "production": {
+        "log_level": "INFO",
+        "log_console": False,
+        "log_console_format": "compact",
+        "log_file_format": "json",
+    },
+    "testing": {
+        "log_level": "WARNING",
+        "log_console": False,
+        "log_file_format": "human",
+    },
+}
+
+
+#: Config keys whose value is *derived from the running environment* at load
+#: time (see ``ConfigLoader.get_environment``) rather than owned by the project.
+#:
+#: ``environment`` looked like a harmless default, but ``load_all`` gives the
+#: file's value precedence over detection -- so writing the derived value into a
+#: brand-new ``config.json`` silently turns a derivation into a permanent
+#: override. A ``wl`` sync that first ran under pytest (``testing``) or in CI
+#: (``production``) froze that value forever, because the version stamp then
+#: certified the file as current and nothing ever re-derived it (#208).
+RUNTIME_DERIVED_KEYS = frozenset({"environment"})
+
+
+def get_default_config() -> dict[str, Any]:
+    """Get default configuration dictionary.
+
+    This is the shape of the *merged* runtime configuration, so it still names
+    ``environment``: readers need a value even when no file exists. Use
+    :func:`get_creation_defaults` when writing a new file -- a derived value
+    must not be persisted as if it were a project setting (#208).
+    """
+    return {
+        "environment": DEFAULT_ENVIRONMENT,
+        "log_level": DEFAULT_LOG_LEVEL,
+        "log_file": DEFAULT_LOG_FILE,
+        "log_console": DEFAULT_LOG_CONSOLE,
+        "log_console_format": DEFAULT_LOG_CONSOLE_FORMAT,
+        "log_file_format": DEFAULT_LOG_FILE_FORMAT,
+        "log_max_size": DEFAULT_LOG_MAX_SIZE,
+        "log_max_backups": DEFAULT_LOG_MAX_BACKUPS,
+        "log_rotate_days": DEFAULT_LOG_ROTATE_DAYS,
+        "language": DEFAULT_LANGUAGE,
+        "aliases": DEFAULT_ALIASES,
+        "version": DEFAULT_VERSION,
+        "test_speed": {
+            "enabled": True,
+            "threshold": 5.0,
+            "fail_on_timeout": True,
+        },
+        "coverage": {
+            "fail_under": DEFAULT_COVERAGE_FAIL_UNDER,
+            "cache_enabled": DEFAULT_COVERAGE_CACHE_ENABLED,
+            "parallel_workers": DEFAULT_COVERAGE_PARALLEL_WORKERS,
+        },
+    }
+
+
+def get_environment_defaults(environment: str) -> dict[str, Any]:
+    """Get default configuration for specific environment."""
+    return ENVIRONMENT_DEFAULTS.get(environment, {})
+
+
+def get_creation_defaults() -> dict[str, Any]:
+    """Payload written when a brand-new ``.wl/config.json`` is created (#208).
+
+    The distinction this draws is between a *creation default* -- a value the
+    project owns from the moment the file appears -- and a *runtime-derived*
+    value, which belongs to the process that is running, not to the checkout.
+    Persisting the latter is what made the force-write of #202 a trap: the file
+    was created under pytest with ``environment=testing`` and every later run
+    read that back as an explicit setting.
+
+    Log-related keys are deliberately *kept*: they are static defaults, and
+    ``ConfigLoader.load_all`` re-applies the environment's ``log_*`` defaults on
+    every load anyway, so they can never pin a run mode.
+
+    Returns:
+        A fresh dict of the JSON payload for a new config file.
+    """
+    return {
+        key: value
+        for key, value in get_default_config().items()
+        if key not in RUNTIME_DERIVED_KEYS
+    }

wl_cli/utils/config/env_exporter.py

@@ -0,0 +1,86 @@
+"""Environment variable exporter for WL Commands."""
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from .defaults import DEFAULT_LANGUAGE, DEFAULT_LOG_FILE, get_environment_defaults
+
+if TYPE_CHECKING:
+    from .config_loader import ConfigLoader
+
+
+class EnvExporter:
+    """Export configuration as environment variables.
+
+    EnvExporter handles converting configuration dictionary to properly formatted
+    environment variables and generates environment templates for different
+    environments.
+    """
+
+    def __init__(self, config_loader: "ConfigLoader") -> None:
+        """Initialize environment exporter.
+
+        Args:
+            config_loader: Config loader instance to get environment from.
+        """
+        self._loader = config_loader
+
+    def export_environment_variables(
+        self, config: dict[str, Any], environment: str | None = None
+    ) -> dict[str, str]:
+        """Export current configuration as environment variables.
+
+        Args:
+            config: Configuration dictionary to export.
+            environment: Target environment. If None, gets from ConfigLoader.
+
+        Returns:
+            Dictionary of environment variables with WL_ prefix.
+        """
+        if environment is None:
+            environment = self._loader.get_environment()
+
+        env_vars = {}
+
+        # Convert config to environment variables
+        for key, value in config.items():
+            if key == "environment":
+                continue
+
+            env_key = f"WL_{key.upper()}"
+            # Convert value to string
+            if isinstance(value, bool):
+                env_vars[env_key] = str(value).lower()
+            elif isinstance(value, list | dict):
+                env_vars[env_key] = json.dumps(value)
+            else:
+                env_vars[env_key] = str(value)
+
+        # Add environment variable
+        env_vars["WL_ENVIRONMENT"] = environment
+
+        return env_vars
+
+    def get_environment_template(self, environment: str) -> dict[str, str]:
+        """Get environment variable template for specific environment.
+
+        Args:
+            environment: Target environment for template.
+
+        Returns:
+            Dictionary of template environment variables with default values.
+        """
+        env_defaults = get_environment_defaults(environment)
+        template = {}
+
+        # Add environment-specific defaults
+        for key, value in env_defaults.items():
+            env_key = f"WL_{key.upper()}"
+            template[env_key] = str(value)
+
+        # Add common variables
+        template["WL_ENVIRONMENT"] = environment
+        template["WL_LOG_FILE"] = DEFAULT_LOG_FILE
+        template["WL_LANGUAGE"] = DEFAULT_LANGUAGE
+
+        return template

wl_cli/utils/config/env_parser.py

@@ -0,0 +1,108 @@
+"""Environment variable parsing utilities for configuration."""
+
+import json
+import os
+from typing import Any
+
+
+class EnvConfigParser:
+    """Parse environment variables into configuration values."""
+
+    ENV_PREFIX = "WL_"
+
+    def parse_env_value(self, value: str) -> Any:
+        """Parse environment variable value to appropriate Python type.
+
+        Handles: bool, int, float, JSON lists, JSON dicts, falls back to string.
+
+        Args:
+            value: Raw string value from environment variable
+
+        Returns:
+            Parsed value with appropriate type
+        """
+        # Handle boolean values
+        lower = value.lower()
+        if lower in ("true", "1", "yes", "y", "on"):
+            return True
+        if lower in ("false", "0", "no", "n", "off"):
+            return False
+
+        # Handle numeric values
+        if value.isdigit():
+            return int(value)
+        if value.replace(".", "", 1).isdigit():
+            try:
+                return float(value)
+            except ValueError:
+                pass
+
+        # Handle lists
+        if value.startswith("[") and value.endswith("]"):
+            try:
+                return json.loads(value)
+            except json.JSONDecodeError:
+                # Fallback to simple comma-separated parsing
+                items = value[1:-1].split(",")
+                return [item.strip() for item in items if item.strip()]
+
+        # Handle dictionaries
+        if value.startswith("{") and value.endswith("}"):
+            try:
+                return json.loads(value)
+            except json.JSONDecodeError:
+                pass
+
+        # Return as string if no other type matches
+        return value
+
+    def group_env_variables(self, env_config: dict[str, Any]) -> dict[str, Any]:
+        """Group environment variables by prefix for nested configuration.
+
+        Converts WL_LOG_MAX_SIZE → log.max_size. Only groups when there are
+        more than two parts separated by underscore. Keeps original keys for
+        backward compatibility.
+
+        Args:
+            env_config: Dictionary with environment parsed configuration
+
+        Returns:
+            Grouped configuration with nested dictionaries
+        """
+        grouped = env_config.copy()
+
+        # Group variables with underscore separators (only for nested groups)
+        # Keep original keys for backward compatibility
+        for key, value in env_config.items():
+            if "_" in key:
+                parts = key.split("_")
+                if len(parts) > 1:
+                    # Only group if we have more than 2 parts (e.g., log_max_size -> log.max_size)
+                    if len(parts) > 2:
+                        group = parts[0]
+                        subgroup_key = "_".join(parts[1:])
+
+                        if group not in grouped:
+                            grouped[group] = {}
+                        grouped[group][subgroup_key] = value
+
+        return grouped
+
+    def load_from_env(self) -> dict[str, Any]:
+        """Load configuration from environment variables with WL_ prefix.
+
+        Environment variables starting with WL_ are converted:
+        WL_LOG_LEVEL → log_level → log.level after grouping.
+
+        Returns:
+            Configuration dictionary loaded from environment
+        """
+        env_config: dict[str, Any] = {}
+
+        for key, value in os.environ.items():
+            if key.startswith(self.ENV_PREFIX):
+                config_key = key[len(self.ENV_PREFIX) :].lower()
+                parsed_value = self.parse_env_value(value)
+                env_config[config_key] = parsed_value
+
+        return self.group_env_variables(env_config)

wl_cli/utils/config/validation.py

@@ -0,0 +1,280 @@
+"""Configuration validation utilities."""
+
+from typing import Any
+
+VALID_LOG_LEVELS = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
+VALID_CONSOLE_FORMATS = ["colored", "json"]
+
+VALID_FILE_FORMATS = ["json", "human"]
+
+VALID_CACHE_BACKENDS = ["memory", "disk"]
+
+VALID_CONFIG_FORMATS = ["json", "toml", "yaml"]
+
+
+def validate_log_level(log_level: Any) -> str:
+    """Validate log level value."""
+    if not isinstance(log_level, str):
+        return "INFO"
+    return log_level.upper() if log_level.upper() in VALID_LOG_LEVELS else "INFO"
+
+
+def validate_log_max_size(size: Any) -> int:
+    """Validate log max size value."""
+    return size if isinstance(size, int) and size > 0 else 10 * 1024 * 1024
+
+
+def validate_log_max_backups(count: Any) -> int:
+    """Validate log max backups value."""
+    return count if isinstance(count, int) and count >= 0 else 5
+
+
+def validate_log_rotate_days(days: Any) -> int:
+    """Validate log rotate days value."""
+    return days if isinstance(days, int) and days > 0 else 7
+
+
+def validate_log_console(value: Any) -> bool:
+    """Validate log console value."""
+    return validate_boolean(value)
+
+
+def validate_log_console_format(fmt: Any) -> str:
+    """Validate log console format value."""
+    if not isinstance(fmt, str):
+        return "colored"
+    return fmt.lower() if fmt.lower() in VALID_CONSOLE_FORMATS else "colored"
+
+
+def validate_log_file_format(fmt: Any) -> str:
+    """Validate log file format value."""
+    if not isinstance(fmt, str):
+        return "human"
+    return fmt.lower() if fmt.lower() in VALID_FILE_FORMATS else "human"
+
+
+def validate_cache_backend(backend: Any) -> str:
+    """Validate cache backend value."""
+    if not isinstance(backend, str):
+        return "memory"
+    return backend.lower() if backend.lower() in VALID_CACHE_BACKENDS else "memory"
+
+
+def validate_cache_ttl(ttl: Any) -> int:
+    """Validate cache TTL value."""
+    return ttl if isinstance(ttl, int) and ttl > 0 else 3600
+
+
+def validate_config_format(fmt: Any) -> str:
+    """Validate config format value."""
+    if not isinstance(fmt, str):
+        return "json"
+    return fmt.lower() if fmt.lower() in VALID_CONFIG_FORMATS else "json"
+
+
+def validate_boolean(value: Any) -> bool:
+    """Validate boolean value."""
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        normalized_value = value.lower().strip()
+        return normalized_value in ["true", "1", "yes", "y", "on"]
+    if isinstance(value, int):
+        return value > 0
+    return False
+
+
+def validate_integer(value: Any, min_value: int | None = None) -> int:
+    """Validate integer value."""
+    if isinstance(value, int):
+        if min_value is not None and value < min_value:
+            return min_value
+        return value
+    try:
+        int_value = int(value)
+        if min_value is not None and int_value < min_value:
+            return min_value
+        return int_value
+    except (ValueError, TypeError):
+        return min_value if min_value is not None else 0
+
+
+def validate_string(value: Any, default: str = "") -> str:
+    """Validate string value."""
+    return str(value) if value is not None else default
+
+
+def _validate_top_level_logging(config: dict[str, Any]) -> dict[str, Any]:
+    """Validate top-level logging configuration values."""
+    validated = config.copy()
+
+    if "log_level" in validated:
+        validated["log_level"] = validate_log_level(validated["log_level"])
+    if "log_max_size" in validated:
+        validated["log_max_size"] = validate_log_max_size(validated["log_max_size"])
+    if "log_max_backups" in validated:
+        validated["log_max_backups"] = validate_log_max_backups(
+            validated["log_max_backups"]
+        )
+    if "log_rotate_days" in validated:
+        validated["log_rotate_days"] = validate_log_rotate_days(
+            validated["log_rotate_days"]
+        )
+    if "log_console" in validated:
+        validated["log_console"] = validate_log_console(validated["log_console"])
+    if "log_console_format" in validated:
+        validated["log_console_format"] = validate_log_console_format(
+            validated["log_console_format"]
+        )
+    if "log_file_format" in validated:
+        validated["log_file_format"] = validate_log_file_format(
+            validated["log_file_format"]
+        )
+
+    return validated
+
+
+def _validate_top_level_cache(config: dict[str, Any]) -> dict[str, Any]:
+    """Validate top-level cache configuration values."""
+    validated = config.copy()
+
+    if "cache_backend" in validated:
+        validated["cache_backend"] = validate_cache_backend(validated["cache_backend"])
+    if "cache_ttl" in validated:
+        validated["cache_ttl"] = validate_cache_ttl(validated["cache_ttl"])
+
+    return validated
+
+
+def _validate_top_level_general(config: dict[str, Any]) -> dict[str, Any]:
+    """Validate top-level general configuration values."""
+    validated = config.copy()
+
+    if "config_format" in validated:
+        validated["config_format"] = validate_config_format(validated["config_format"])
+
+    return validated
+
+
+def validate_config(config: dict[str, Any]) -> dict[str, Any]:
+    """Validate and normalize configuration values."""
+    validated = config.copy()
+
+    # Validate top-level configurations
+    validated = _validate_top_level_logging(validated)
+    validated = _validate_top_level_cache(validated)
+    validated = _validate_top_level_general(validated)
+
+    # Validate nested configurations
+    if "logging" in validated and isinstance(validated["logging"], dict):
+        validated["logging"] = validate_logging_config(validated["logging"])
+    if "cache" in validated and isinstance(validated["cache"], dict):
+        validated["cache"] = validate_cache_config(validated["cache"])
+    if "test_speed" in validated and isinstance(validated["test_speed"], dict):
+        validated["test_speed"] = validate_test_speed_config(validated["test_speed"])
+
+    return validated
+
+
+def validate_logging_config(logging_config: dict[str, Any]) -> dict[str, Any]:
+    """Validate logging configuration."""
+    validated = logging_config.copy()
+
+    if "level" in validated:
+        validated["level"] = validate_log_level(validated["level"])
+    if "console" in validated:
+        validated["console"] = validate_boolean(validated["console"])
+    if "console_format" in validated:
+        validated["console_format"] = validate_log_console_format(
+            validated["console_format"]
+        )
+    if "file_format" in validated:
+        validated["file_format"] = validate_log_file_format(validated["file_format"])
+    if "max_size" in validated:
+        validated["max_size"] = validate_log_max_size(validated["max_size"])
+    if "max_backups" in validated:
+        validated["max_backups"] = validate_log_max_backups(validated["max_backups"])
+    if "rotate_days" in validated:
+        validated["rotate_days"] = validate_log_rotate_days(validated["rotate_days"])
+
+    return validated
+
+
+def validate_cache_config(cache_config: dict[str, Any]) -> dict[str, Any]:
+    """Validate cache configuration."""
+    validated = cache_config.copy()
+
+    if "backend" in validated:
+        validated["backend"] = validate_cache_backend(validated["backend"])
+    if "ttl" in validated:
+        validated["ttl"] = validate_cache_ttl(validated["ttl"])
+    if "enabled" in validated:
+        validated["enabled"] = validate_boolean(validated["enabled"])
+
+    return validated
+
+
+def validate_test_speed_config(test_speed_config: dict[str, Any]) -> dict[str, Any]:
+    """Validate test speed configuration."""
+    validated = test_speed_config.copy()
+
+    if "enabled" in validated:
+        validated["enabled"] = validate_boolean(validated["enabled"])
+    else:
+        validated["enabled"] = True
+
+    if "threshold" in validated:
+        if (
+            isinstance(validated["threshold"], int | float)
+            and validated["threshold"] > 0
+        ):
+            validated["threshold"] = float(validated["threshold"])
+        else:
+            validated["threshold"] = 5.0
+    else:
+        validated["threshold"] = 5.0
+
+    if "fail_on_timeout" in validated:
+        validated["fail_on_timeout"] = validate_boolean(validated["fail_on_timeout"])
+    else:
+        validated["fail_on_timeout"] = True
+
+    return validated
+
+
+def validate_config_schema(
+    config: dict[str, Any], schema: dict[str, Any]
+) -> dict[str, Any]:
+    """Validate configuration against a schema."""
+    validated = config.copy()
+
+    for key, schema_info in schema.items():
+        if key in validated:
+            value = validated[key]
+            validator = schema_info.get("validator")
+            if validator:
+                validated[key] = validator(value)
+        else:
+            # Set default value if not present
+            validated[key] = schema_info.get("default")
+
+    return validated
+
+
+# Default configuration schema
+DEFAULT_CONFIG_SCHEMA = {
+    "log_level": {"validator": validate_log_level, "default": "INFO"},
+    "log_console": {"validator": validate_boolean, "default": True},
+    "log_console_format": {
+        "validator": validate_log_console_format,
+        "default": "colored",
+    },
+    "log_file_format": {"validator": validate_log_file_format, "default": "human"},
+    "log_max_size": {"validator": validate_log_max_size, "default": 10 * 1024 * 1024},
+    "log_max_backups": {"validator": validate_log_max_backups, "default": 5},
+    "log_rotate_days": {"validator": validate_log_rotate_days, "default": 7},
+    "cache_backend": {"validator": validate_cache_backend, "default": "memory"},
+    "cache_ttl": {"validator": validate_cache_ttl, "default": 3600},
+    "config_format": {"validator": validate_config_format, "default": "json"},
+}