Update utils/config.py

utils/config.py

@@ -1,152 +1,99 @@
+"""
+Configuration settings for the application
+"""
 import os
-from typing import Dict, Any, Optional
-from dataclasses import dataclass, asdict
-import streamlit as st
+from pathlib import Path
 
-from utils.logging import get_logger
-from utils.error_handling import ConfigError
+# Base directories
+BASE_DIR = Path(__file__).parent
+DATA_DIR = BASE_DIR / "data"
+CACHE_DIR = BASE_DIR / "cache"
+LOGS_DIR = BASE_DIR / "logs"
 
-logger = get_logger(__name__)
+# Create directories if they don't exist
+DATA_DIR.mkdir(exist_ok=True)
+CACHE_DIR.mkdir(exist_ok=True)
+LOGS_DIR.mkdir(exist_ok=True)
 
-@dataclass
-class AppConfig:
-    """Application configuration data class"""
-    app_name: str = "MONA Dashboard"
-    version: str = "1.0.0"
-    debug_mode: bool = False
-    max_data_points: int = 1000
-    refresh_interval: int = 30
-    default_chart_type: str = "line"
-    theme: str = "light"
-    
-    # UI Configuration
-    sidebar_width: int = 300
-    chart_height: int = 400
-    table_page_size: int = 50
-    
-    # Data Configuration
-    data_cache_timeout: int = 300
-    max_file_size_mb: int = 10
-    supported_file_types: list = None
-    
-    def __post_init__(self):
-        if self.supported_file_types is None:
-            self.supported_file_types = ['.csv', '.xlsx', '.json', '.parquet']
+# Application settings
+APP_NAME = "Dashboard App"
+APP_VERSION = "1.0.0"
+DEBUG = os.getenv("DEBUG", "False").lower() == "true"
 
-# Global configuration instance
-_config = None
+# Streamlit configuration
+STREAMLIT_CONFIG = {
+    "page_title": APP_NAME,
+    "page_icon": "📊",
+    "layout": "wide",
+    "initial_sidebar_state": "expanded"
+}
 
-def load_config() -> AppConfig:
-    """Load application configuration"""
-    global _config
-    
-    if _config is None:
-        try:
-            # Create default config
-            _config = AppConfig()
-            
-            # Override with environment variables if available
-            _config.debug_mode = os.getenv('DEBUG', 'False').lower() == 'true'
-            _config.max_data_points = int(os.getenv('MAX_DATA_POINTS', '1000'))
-            _config.refresh_interval = int(os.getenv('REFRESH_INTERVAL', '30'))
-            _config.theme = os.getenv('THEME', 'light')
-            
-            # Override with Streamlit session state if available
-            if 'app_config' in st.session_state:
-                session_config = st.session_state.app_config
-                for key, value in session_config.items():
-                    if hasattr(_config, key):
-                        setattr(_config, key, value)
-            
-            logger.info("Configuration loaded successfully")
-            
-        except Exception as e:
-            logger.error(f"Failed to load configuration: {str(e)}")
-            raise ConfigError(f"Configuration loading failed: {str(e)}")
-    
-    return _config
+# Logging configuration
+LOGGING_CONFIG = {
+    "level": "DEBUG" if DEBUG else "INFO",
+    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    "file_path": LOGS_DIR / "app.log"
+}
 
-def save_config(config: AppConfig) -> bool:
-    """Save configuration to session state"""
-    try:
-        st.session_state.app_config = asdict(config)
-        global _config
-        _config = config
-        logger.info("Configuration saved successfully")
-        return True
-    except Exception as e:
-        logger.error(f"Failed to save configuration: {str(e)}")
-        return False
+# Dashboard settings
+DASHBOARD_CONFIG = {
+    "default_chart_type": "Line Chart",
+    "refresh_interval": 300,  # 5 minutes
+    "max_data_points": 10000,
+    "enable_caching": True
+}
 
-def get_config_value(key: str, default_value: Any = None) -> Any:
-    """Get a specific configuration value"""
-    try:
-        config = load_config()
-        return getattr(config, key, default_value)
-    except Exception as e:
-        logger.error(f"Failed to get config value for key {key}: {str(e)}")
-        return default_value
+# File upload settings
+UPLOAD_CONFIG = {
+    "max_file_size": 200,  # MB
+    "allowed_extensions": [".csv", ".xlsx", ".json", ".pkl"],
+    "upload_dir": DATA_DIR / "uploads"
+}
 
-def update_config_value(key: str, value: Any) -> bool:
-    """Update a specific configuration value"""
-    try:
-        config = load_config()
-        if hasattr(config, key):
-            setattr(config, key, value)
-            return save_config(config)
-        else:
-            logger.warning(f"Configuration key '{key}' does not exist")
-            return False
-    except Exception as e:
-        logger.error(f"Failed to update config value for key {key}: {str(e)}")
-        return False
+# API settings (if needed)
+API_CONFIG = {
+    "timeout": 30,
+    "max_retries": 3,
+    "base_url": os.getenv("API_BASE_URL", "")
+}
 
-def reset_config() -> AppConfig:
-    """Reset configuration to defaults"""
-    global _config
-    _config = AppConfig()
-    save_config(_config)
-    logger.info("Configuration reset to defaults")
-    return _config
+# Database settings (if needed)
+DATABASE_CONFIG = {
+    "url": os.getenv("DATABASE_URL", ""),
+    "pool_size": 5,
+    "max_overflow": 10
+}
 
-def get_config_dict() -> Dict[str, Any]:
-    """Get configuration as dictionary"""
-    try:
-        config = load_config()
-        return asdict(config)
-    except Exception as e:
-        logger.error(f"Failed to get configuration dictionary: {str(e)}")
-        return {}
+# Security settings
+SECURITY_CONFIG = {
+    "secret_key": os.getenv("SECRET_KEY", "your-secret-key-here"),
+    "session_timeout": 3600,  # 1 hour
+    "max_login_attempts": 5
+}
 
-def validate_config(config: AppConfig) -> bool:
-    """Validate configuration values"""
-    try:
-        # Validate numeric values
-        if config.max_data_points <= 0:
-            raise ConfigError("max_data_points must be positive")
-        
-        if config.refresh_interval <= 0:
-            raise ConfigError("refresh_interval must be positive")
-        
-        if config.sidebar_width <= 0:
-            raise ConfigError("sidebar_width must be positive")
-        
-        if config.chart_height <= 0:
-            raise ConfigError("chart_height must be positive")
-        
-        # Validate string values
-        if config.theme not in ['light', 'dark']:
-            raise ConfigError("theme must be 'light' or 'dark'")
-        
-        if config.default_chart_type not in ['line', 'bar', 'scatter', 'area']:
-            raise ConfigError("invalid default_chart_type")
-        
-        logger.info("Configuration validation successful")
-        return True
-        
-    except ConfigError as e:
-        logger.error(f"Configuration validation failed: {str(e)}")
-        raise e
-    except Exception as e:
-        logger.error(f"Unexpected error during configuration validation: {str(e)}")
-        raise ConfigError(f"Configuration validation error: {str(e)}")
+# Feature flags
+FEATURES = {
+    "enable_dashboard": True,
+    "enable_analytics": False,
+    "enable_user_management": False,
+    "enable_api": False
+}
+
+# Export all configurations
+__all__ = [
+    "BASE_DIR",
+    "DATA_DIR", 
+    "CACHE_DIR",
+    "LOGS_DIR",
+    "APP_NAME",
+    "APP_VERSION",
+    "DEBUG",
+    "STREAMLIT_CONFIG",
+    "LOGGING_CONFIG",
+    "DASHBOARD_CONFIG",
+    "UPLOAD_CONFIG",
+    "API_CONFIG",
+    "DATABASE_CONFIG",
+    "SECURITY_CONFIG",
+    "FEATURES"
+]