Configuration & Settings¶

import os
from wappa.core.config.settings import Settings as WappaSettings

class CustomSettings(WappaSettings):
    """Extended settings with your custom environment variables."""

    def __init__(self):
        # Initialize parent settings first
        super().__init__()

        # Add your custom variables
        self.stripe_api_key: str | None = os.getenv("STRIPE_API_KEY")
        self.max_cart_items: int = int(os.getenv("MAX_CART_ITEMS", "10"))
        self.notification_webhook: str | None = os.getenv("NOTIFICATION_WEBHOOK")
        self.smtp_server: str = os.getenv("SMTP_SERVER", "localhost")
        self.database_url: str | None = os.getenv("DATABASE_URL")

        # Validate your custom settings
        self._validate_custom_settings()

    def _validate_custom_settings(self):
        """Validate your custom environment variables."""
        if self.is_production and not self.stripe_api_key:
            raise ValueError("STRIPE_API_KEY required in production")

        if self.max_cart_items < 1 or self.max_cart_items > 50:
            raise ValueError("MAX_CART_ITEMS must be between 1 and 50")

# Create your custom settings instance
settings = CustomSettings()

from wappa import Wappa
from .config.custom_settings import settings  # Your extended settings

app = Wappa()

# Access both Wappa and custom settings
print(f"WhatsApp Phone: {settings.wp_phone_id}")      # From Wappa
print(f"Max Cart Items: {settings.max_cart_items}")   # Your custom setting
print(f"Stripe Key Set: {bool(settings.stripe_api_key)}")  # Your custom setting

from wappa import WappaEventHandler
from .config.custom_settings import settings

class MyApp(WappaEventHandler):
    async def process_message(self, webhook):
        user_id = webhook.user.user_id
        message = webhook.get_message_text()

        # Use your custom settings
        if "cart" in message and len(user_cart) >= settings.max_cart_items:
            await self.messenger.send_text(
                f"Cart full! Maximum {settings.max_cart_items} items allowed.",
                user_id
            )

        # Access Wappa settings too
        self.logger.info(f"App version: {settings.version}")

class AdvancedSettings(WappaSettings):
    def __init__(self):
        super().__init__()

        # Environment-specific settings
        self.debug_mode: bool = os.getenv("DEBUG", "false").lower() == "true"
        self.enable_analytics: bool = os.getenv("ENABLE_ANALYTICS", "true").lower() == "true"

        # Computed properties
        self.database_pool_size: int = (
            int(os.getenv("DB_POOL_SIZE", "20")) if self.is_production 
            else int(os.getenv("DB_POOL_SIZE", "5"))
        )

        # Feature flags
        self.enable_ai_responses: bool = bool(self.openai_api_key)
        self.enable_payments: bool = bool(os.getenv("STRIPE_API_KEY"))

    @property
    def is_debug_enabled(self) -> bool:
        """Check if debug mode is enabled (only in development)."""
        return self.is_development and self.debug_mode

    def get_database_config(self) -> dict:
        """Get database configuration based on environment."""
        if not self.database_url:
            return {"type": "none"}

        return {
            "url": self.database_url,
            "pool_size": self.database_pool_size,
            "ssl_required": self.is_production
        }

from wappa.core.config import settings

# Environment checks
if settings.is_development:
    print("🛠️ Development mode - detailed logging enabled")

if settings.is_production:
    print("🚀 Production mode - optimized for performance")

# Feature availability
if settings.has_redis:
    print("📊 Redis cache available")
else:
    print("💾 Using memory cache")

# Version info
print(f"Wappa version: {settings.version}")

settings.wp_access_token    # Your WhatsApp access token
settings.wp_phone_id        # Your WhatsApp phone number ID  
settings.wp_bid             # Your WhatsApp business account ID
settings.whatsapp_webhook_verify_token  # Webhook security token

settings.port               # Server port (default: 8000)
settings.log_level          # Logging level (INFO, WARNING, ERROR)
settings.environment        # DEV or PROD
settings.time_zone          # Timezone (default: UTC)

settings.openai_api_key     # OpenAI API key (for AI features)
settings.redis_url          # Redis connection URL
settings.redis_max_connections  # Redis connection pool size

settings.is_development     # True if ENVIRONMENT=DEV
settings.is_production      # True if ENVIRONMENT=PROD  
settings.has_redis          # True if REDIS_URL is set
settings.owner_id           # Same as wp_phone_id
settings.version            # Wappa framework version

import os
from wappa.core.config.settings import Settings as WappaSettings

class DynamicSettings(WappaSettings):
    def __init__(self):
        super().__init__()

        # Database configuration changes by environment
        if self.is_production:
            self.database_url = os.getenv("DATABASE_URL")  # Required in prod
            self.cache_ttl = 3600  # 1 hour cache
            self.rate_limit = 100  # Higher limits
        else:
            self.database_url = os.getenv("DATABASE_URL", "sqlite:///dev.db")  # SQLite for dev
            self.cache_ttl = 300   # 5 minute cache
            self.rate_limit = 10   # Lower limits for testing

        # Feature flags
        self.enable_webhook_logging = os.getenv("WEBHOOK_LOGGING", "true").lower() == "true"
        self.enable_message_encryption = self.is_production  # Only in production

    def get_webhook_config(self) -> dict:
        """Get webhook-specific configuration."""
        return {
            "verify_token": self.whatsapp_webhook_verify_token,
            "logging_enabled": self.enable_webhook_logging,
            "rate_limit": self.rate_limit
        }

from wappa.core.config.settings import Settings as WappaSettings

class ValidatedSettings(WappaSettings):
    def __init__(self):
        super().__init__()

        # Your custom variables with validation
        self.max_file_size = self._get_file_size("MAX_FILE_SIZE", "10MB")
        self.allowed_domains = self._get_list("ALLOWED_DOMAINS", ["localhost", "myapp.com"])
        self.admin_users = self._get_list("ADMIN_USERS", [])

    def _get_file_size(self, env_var: str, default: str) -> int:
        """Parse file size from environment variable."""
        size_str = os.getenv(env_var, default)
        if size_str.endswith("MB"):
            return int(size_str[:-2]) * 1024 * 1024
        elif size_str.endswith("KB"):
            return int(size_str[:-2]) * 1024
        return int(size_str)

    def _get_list(self, env_var: str, default: list) -> list:
        """Parse comma-separated list from environment variable."""
        value = os.getenv(env_var)
        if not value:
            return default
        return [item.strip() for item in value.split(",")]

# ✅ Good defaults
self.cache_ttl = int(os.getenv("CACHE_TTL", "3600"))      # 1 hour default
self.max_retries = int(os.getenv("MAX_RETRIES", "3"))     # Reasonable default
self.debug = os.getenv("DEBUG", "false").lower() == "true"  # Safe default

# ❌ No defaults for secrets
self.api_key = os.getenv("API_KEY")  # None if not set - good!

from wappa.core.config import settings

# Print all settings (safe for development)
if settings.is_development:
    print("📋 Current Configuration:")
    print(f"  Environment: {settings.environment}")
    print(f"  Port: {settings.port}")
    print(f"  Redis: {'✅' if settings.has_redis else '❌'}")
    print(f"  OpenAI: {'✅' if settings.openai_api_key else '❌'}")

# Add to your app startup
def validate_configuration():
    """Validate your app's configuration on startup."""
    errors = []

    # Check required custom settings
    if settings.is_production and not getattr(settings, 'database_url', None):
        errors.append("DATABASE_URL required in production")

    if getattr(settings, 'max_cart_items', 0) > 100:
        errors.append("MAX_CART_ITEMS too high (max: 100)")

    if errors:
        raise ValueError(f"Configuration errors: {', '.join(errors)}")

    print("✅ Configuration validation passed")

# Call during app startup
validate_configuration()