config.py

"""
Configuration module for the Stock Analyzer application.

This module handles loading and validating environment variables for secure configuration
management. It provides type-safe access to configuration values and ensures all required
settings are present before the application starts.
"""
import logging
import os
from pathlib import Path
from typing import Dict, Union, cast

from dotenv import load_dotenv

# Configure logging
logger = logging.getLogger(__name__)

ConfigDict = Dict[str, Union[str, int, float, bool]]


def load_config() -> ConfigDict:
    """
    Load and validate application configuration from environment variables.

    This function:
    1. Loads environment variables from .env file if present
    2. Validates all required configuration values
    3. Converts and validates numeric values
    4. Provides default values for optional settings

    Returns:
        Dict[str, Union[str, int, float, bool]]: Configuration dictionary containing:
            - SECRET_KEY (str): Flask secret key for session management
            - FLASK_ENV (str): Flask environment (development/production)
            - FLASK_HOST (str): Host address to bind to
            - FLASK_PORT (int): Port number to listen on
            - CACHE_TIMEOUT (int): Cache timeout in seconds

    Raises:
        ValueError: If any required configuration values are missing or invalid.
        TypeError: If numeric values cannot be converted properly.
    """
    # Load environment variables from .env file
    env_path = Path(".env")
    if env_path.exists():
        load_dotenv(env_path)

    # Required configuration keys and their descriptions
    required_configs: Dict[str, str] = {
        "SECRET_KEY": "Flask secret key for session management",
        "FLASK_ENV": "Flask environment (development/production)",
    }

    # Optional configuration keys with default values
    default_configs: Dict[str, Union[str, int]] = {
        "FLASK_HOST": "0.0.0.0",
        "FLASK_PORT": 8000,
        # Cache timeout in seconds
        "CACHE_TIMEOUT": 60,
    }

    config: ConfigDict = {}
    missing_keys: list[str] = []

    # Check required configurations
    for key, description in required_configs.items():
        value = os.getenv(key)
        if not value:
            missing_keys.append(f"{key} ({description})")
        config[key] = value if value else ""

    # Load optional configurations with defaults
    for key, default in default_configs.items():
        value = os.getenv(key)
        config[key] = value if value is not None else default

    # Convert numeric values
    try:
        config["FLASK_PORT"] = int(cast(Union[str, int], config["FLASK_PORT"]))
        config["CACHE_TIMEOUT"] = int(cast(Union[str, int], config["CACHE_TIMEOUT"]))
    except ValueError as e:
        logger.error(f"Invalid numeric configuration value: {str(e)}")
        raise ValueError(f"Invalid numeric configuration value: {str(e)}")

    # Validate FLASK_ENV value
    if config["FLASK_ENV"] not in ["development", "production"]:
        raise ValueError("FLASK_ENV must be either 'development' or 'production'")

    # If any required configurations are missing, raise an error
    if missing_keys:
        error_msg = "Missing required configuration values:\n" + "\n".join(missing_keys)
        logger.error(error_msg)
        raise ValueError(error_msg)

    return config