Update config/settings.py

config/settings.py

@@ -1,376 +1,311 @@
 """
-Configuration management for ARF Demo
-Updated with REAL ARF installation detection - FIXED VERSION
+ARF Settings Configuration with Pydantic 2.x Compatibility
+Fixed for both OSS and Enterprise deployments
 """
-from typing import Optional, Dict, Any, List
-from enum import Enum
 import os
-import logging
 import sys
+from enum import Enum
+from typing import Optional, Dict, Any, List, Union
+from datetime import datetime
 
-logger = logging.getLogger(__name__)
-
-# Try to import from pydantic-settings, fallback to pydantic
+# Try to import pydantic with version detection
 try:
-    from pydantic_settings import BaseSettings
-    from pydantic import Field, validator
+    from pydantic import Field, validator, model_validator
+    from pydantic_settings import BaseSettings, SettingsConfigDict
     PYDANTIC_V2 = True
-    logger.info("Using pydantic-settings for BaseSettings")
 except ImportError:
-    try:
-        from pydantic import BaseSettings, Field, validator
-        PYDANTIC_V2 = False
-        logger.info("Using pydantic.BaseSettings (older version)")
-    except ImportError as e:
-        logger.error(f"Failed to import pydantic: {e}")
-        # Create minimal fallback
-        class BaseSettings:
-            def __init__(self, **kwargs):
-                for k, v in kwargs.items():
-                    setattr(self, k, v)
-        
-        class Field:
-            @staticmethod
-            def default(value):
-                return value
-        
-        def validator(*args, **kwargs):
-            def decorator(func):
-                return func
-            return decorator
-        
-        PYDANTIC_V2 = False
+    # Fallback for pydantic v1
+    from pydantic import Field, validator
+    from pydantic_settings import BaseSettings
+    PYDANTIC_V2 = False
 
+import logging
+logger = logging.getLogger(__name__)
 
+# Enums for ARF modes
 class ARFMode(str, Enum):
-    """ARF operation modes"""
+    """ARF Operational Modes"""
     DEMO = "demo"
     OSS = "oss"
     ENTERPRISE = "enterprise"
-
+    HYBRID = "hybrid"
+    SIMULATION = "simulation"
 
 class SafetyMode(str, Enum):
-    """Safety modes for execution"""
-    ADVISORY = "advisory"
-    APPROVAL = "approval"
-    AUTONOMOUS = "autonomous"
-
+    """Safety and Compliance Modes"""
+    STANDARD = "standard"
+    STRICT = "strict"
+    PERMISSIVE = "permissive"
+    ENTERPRISE = "enterprise"
+    COMPLIANCE = "compliance"
 
 class InstallationStatus(str, Enum):
-    """ARF package installation status"""
+    """Package Installation Status"""
     NOT_INSTALLED = "not_installed"
     OSS_ONLY = "oss_only"
-    ENTERPRISE = "enterprise"
-    BOTH = "both"
-
+    ENTERPRISE_ONLY = "enterprise_only"
+    FULL_INSTALL = "full_install"
+    DEMO_MODE = "demo_mode"
 
-class Settings(BaseSettings):
-    """
-    Application settings with environment variable support
-    """
-    
-    # ===== System Mode =====
-    arf_mode: ARFMode = Field(
-        default=ARFMode.DEMO,
-        description="ARF operation mode"
-    )
-    
-    use_true_arf: bool = Field(
-        default=True,
-        description="Use true ARF integration when available"
-    )
-    
-    # ===== Installation Status (Auto-detected) =====
-    arf_oss_installed: bool = Field(
-        default=False,
-        description="ARF OSS package installed"
-    )
-    
-    arf_enterprise_installed: bool = Field(
-        default=False,
-        description="ARF Enterprise package installed"
-    )
-    
-    arf_oss_version: Optional[str] = Field(
-        default=None,
-        description="ARF OSS version if installed"
-    )
-    
-    arf_enterprise_version: Optional[str] = Field(
-        default=None,
-        description="ARF Enterprise version if installed"
-    )
-    
-    # ===== ARF Configuration =====
-    arf_api_key: Optional[str] = Field(
-        default=None,
-        description="ARF API key for real integration"
-    )
-    
-    arf_base_url: str = Field(
-        default="https://api.arf.dev",
-        description="ARF API base URL"
-    )
-    
-    # ===== Business Configuration =====
-    engineer_hourly_rate: float = Field(
-        default=150.0,
-        description="Engineer hourly rate in USD"
-    )
-    
-    engineer_annual_cost: float = Field(
-        default=125000.0,
-        description="Engineer annual cost in USD"
-    )
-    
-    default_savings_rate: float = Field(
-        default=0.82,
-        description="Default savings rate with ARF"
-    )
-    
-    # ===== UI Configuration =====
-    auto_refresh_seconds: int = Field(
-        default=30,
-        description="Auto-refresh interval in seconds"
-    )
-    
-    max_history_items: int = Field(
-        default=100,
-        description="Maximum history items to display"
-    )
-    
-    # ===== Demo Configuration =====
-    default_scenario: str = Field(
-        default="Cache Miss Storm",
-        description="Default incident scenario"
-    )
-    
-    scenario_config_path: str = Field(
-        default="config/scenarios",
-        description="Path to scenario configuration files"
-    )
-    
-    # ===== Safety Configuration =====
-    default_safety_mode: SafetyMode = Field(
-        default=SafetyMode.ADVISORY,
-        description="Default safety mode"
-    )
-    
-    require_approval: bool = Field(
-        default=True,
-        description="Require human approval for execution"
-    )
-    
-    # ===== Validation =====
-    @validator("arf_mode", "default_safety_mode", pre=True)
-    def validate_enums(cls, v):
-        """Convert strings to enum values if needed"""
-        if isinstance(v, str):
-            # Try to match enum values
-            if hasattr(cls, '__fields__'):
-                field_name = None
-                for field in cls.__fields__.values():
-                    if field.name == 'arf_mode' and isinstance(v, str):
-                        try:
-                            return ARFMode(v.lower())
-                        except ValueError:
-                            return ARFMode.DEMO
-                    elif field.name == 'default_safety_mode' and isinstance(v, str):
-                        try:
-                            return SafetyMode(v.lower())
-                        except ValueError:
-                            return SafetyMode.ADVISORY
-        return v
-    
-    @validator("arf_api_key")
-    def validate_api_key(cls, v: Optional[str], values: Dict[str, Any]) -> Optional[str]:
-        if values.get("arf_mode") == ARFMode.ENTERPRISE and not v:
-            raise ValueError("ARF API key required for Enterprise mode")
-        return v
-    
-    @validator("use_true_arf")
-    def validate_true_arf(cls, v: bool, values: Dict[str, Any]) -> bool:
-        if v and not values.get("arf_oss_installed"):
-            logger.warning("True ARF requested but OSS package not installed. Using mock mode.")
-            return False
-        return v
-    
-    # ===== Installation Detection =====
-    @classmethod
-    def detect_installation(cls):
-        """Detect ARF package installation"""
-        results = {
-            "oss_installed": False,
-            "enterprise_installed": False,
-            "oss_version": None,
-            "enterprise_version": None
-        }
+# Pydantic 2.x compatible Settings class
+if PYDANTIC_V2:
+    class Settings(BaseSettings):
+        """ARF Settings with Pydantic 2.x compatibility"""
+        model_config = SettingsConfigDict(
+            env_file=".env",
+            env_file_encoding="utf-8",
+            env_prefix="ARF_",
+            case_sensitive=False,
+            extra="ignore"
+        )
         
-        # Check OSS package
-        try:
-            import agentic_reliability_framework as arf_oss
-            results["oss_installed"] = True
-            results["oss_version"] = getattr(arf_oss, '__version__', '3.3.7')
-            logger.info(f"✅ ARF OSS v{results['oss_version']} detected")
-        except ImportError:
-            logger.info("⚠️ ARF OSS not installed - will use mock mode")
+        # Core Settings
+        arf_mode: ARFMode = Field(default=ARFMode.DEMO, description="ARF operational mode")
+        safety_mode: SafetyMode = Field(default=SafetyMode.STANDARD, description="Safety compliance mode")
+        debug: bool = Field(default=False, description="Enable debug logging")
+        log_level: str = Field(default="INFO", description="Logging level")
         
-        # Check Enterprise package
-        try:
-            import arf_enterprise
-            results["enterprise_installed"] = True
-            results["enterprise_version"] = getattr(arf_enterprise, '__version__', '1.0.2')
-            logger.info(f"✅ ARF Enterprise v{results['enterprise_version']} detected")
-        except ImportError:
-            logger.info("⚠️ ARF Enterprise not installed - will use simulation")
+        # Version Info
+        arf_version: str = Field(default="3.3.7", description="ARF version")
+        demo_version: str = Field(default="3.8.0", description="Demo app version")
         
-        return results
-    
-    def get_installation_status(self) -> InstallationStatus:
-        """Get current installation status"""
-        if self.arf_oss_installed and self.arf_enterprise_installed:
-            return InstallationStatus.BOTH
-        elif self.arf_enterprise_installed:
-            return InstallationStatus.ENTERPRISE
-        elif self.arf_oss_installed:
-            return InstallationStatus.OSS_ONLY
-        else:
-            return InstallationStatus.NOT_INSTALLED
-    
-    def get_installation_badges(self) -> Dict[str, Any]:
-        """Get badge information for UI display"""
-        if self.arf_oss_installed:
-            oss_badge = {
-                "text": f"✅ ARF OSS v{self.arf_oss_version}",
-                "color": "#10b981",
-                "icon": "✅"
-            }
-        else:
-            oss_badge = {
-                "text": "⚠️ Mock ARF",
-                "color": "#f59e0b", 
-                "icon": "⚠️"
-            }
+        # Installation Status
+        oss_installed: bool = Field(default=False, description="ARF OSS package installed")
+        enterprise_installed: bool = Field(default=False, description="Enterprise package installed")
+        installation_status: InstallationStatus = Field(
+            default=InstallationStatus.DEMO_MODE,
+            description="Overall installation status"
+        )
         
-        if self.arf_enterprise_installed:
-            enterprise_badge = {
-                "text": f"🚀 Enterprise v{self.arf_enterprise_version}",
-                "color": "#8b5cf6",
-                "icon": "🚀"
-            }
-        else:
-            enterprise_badge = {
-                "text": "🔒 Enterprise Required",
-                "color": "#64748b",
-                "icon": "🔒"
-            }
+        # Feature Flags
+        enable_telemetry: bool = Field(default=True, description="Enable telemetry collection")
+        enable_anomaly_detection: bool = Field(default=True, description="Enable anomaly detection")
+        enable_business_metrics: bool = Field(default=True, description="Enable business metrics")
+        enable_audit_trail: bool = Field(default=True, description="Enable audit trail")
         
-        return {
-            "oss": oss_badge,
-            "enterprise": enterprise_badge
-        }
-    
-    def get_installation_recommendations(self) -> List[str]:
-        """Get installation recommendations"""
-        recommendations = []
+        # Paths
+        data_dir: str = Field(default="./data", description="Data directory")
+        log_dir: str = Field(default="./logs", description="Log directory")
+        cache_dir: str = Field(default="./cache", description="Cache directory")
         
-        if not self.arf_oss_installed:
-            recommendations.append(
-                "Install real ARF OSS: `pip install agentic-reliability-framework==3.3.7`"
-            )
+        # API Settings
+        api_timeout: int = Field(default=30, description="API timeout in seconds")
+        max_retries: int = Field(default=3, description="Maximum API retries")
+        rate_limit: int = Field(default=100, description="API rate limit per minute")
         
-        if not self.arf_enterprise_installed:
-            recommendations.append(
-                "Install ARF Enterprise: `pip install agentic-reliability-enterprise` (requires license)"
-            )
+        # UI Settings
+        ui_theme: str = Field(default="dark", description="UI theme")
+        refresh_interval: int = Field(default=5, description="UI refresh interval in seconds")
         
-        return recommendations
-    
-    class Config:
-        env_file = ".env"
-        env_file_encoding = "utf-8"
-        case_sensitive = False
-        use_enum_values = True
-
+        # Business Settings
+        default_currency: str = Field(default="USD", description="Default currency")
+        cost_per_incident: float = Field(default=10000.0, description="Default cost per incident")
+        engineer_hourly_rate: float = Field(default=150.0, description="Engineer hourly rate")
+        
+        @model_validator(mode='before')
+        @classmethod
+        def validate_enums(cls, data: Any) -> Any:
+            """Validate and convert enum fields from strings"""
+            if isinstance(data, dict):
+                # Convert string values to enums if needed
+                if 'arf_mode' in data and isinstance(data['arf_mode'], str):
+                    try:
+                        data['arf_mode'] = ARFMode(data['arf_mode'].lower())
+                    except ValueError:
+                        data['arf_mode'] = ARFMode.DEMO
+                
+                if 'safety_mode' in data and isinstance(data['safety_mode'], str):
+                    try:
+                        data['safety_mode'] = SafetyMode(data['safety_mode'].lower())
+                    except ValueError:
+                        data['safety_mode'] = SafetyMode.STANDARD
+                
+                if 'installation_status' in data and isinstance(data['installation_status'], str):
+                    try:
+                        data['installation_status'] = InstallationStatus(data['installation_status'].lower())
+                    except ValueError:
+                        data['installation_status'] = InstallationStatus.DEMO_MODE
+            return data
+        
+        @model_validator(mode='after')
+        def check_installation_status(self):
+            """Update installation status based on detected packages"""
+            # Check if OSS is installed
+            try:
+                import agentic_reliability_framework
+                self.oss_installed = True
+            except ImportError:
+                self.oss_installed = False
+            
+            # Check if Enterprise is installed
+            try:
+                import agentic_reliability_enterprise
+                self.enterprise_installed = True
+            except ImportError:
+                self.enterprise_installed = False
+            
+            # Update installation status
+            if self.oss_installed and self.enterprise_installed:
+                self.installation_status = InstallationStatus.FULL_INSTALL
+            elif self.oss_installed:
+                self.installation_status = InstallationStatus.OSS_ONLY
+            elif self.enterprise_installed:
+                self.installation_status = InstallationStatus.ENTERPRISE_ONLY
+            else:
+                self.installation_status = InstallationStatus.DEMO_MODE
+            
+            return self
 
-def print_installation_status():
-    """Print installation status to console - SAFE VERSION"""
-    try:
-        # Create settings instance first to avoid circular imports
-        installation_info = Settings.detect_installation()
+else:
+    # Pydantic v1 compatible Settings class
+    class Settings(BaseSettings):
+        """ARF Settings with Pydantic v1 compatibility"""
+        class Config:
+            env_file = ".env"
+            env_file_encoding = "utf-8"
+            env_prefix = "ARF_"
+            case_sensitive = False
         
-        # Create settings with installation info
-        s = Settings(
-            arf_oss_installed=installation_info["oss_installed"],
-            arf_enterprise_installed=installation_info["enterprise_installed"],
-            arf_oss_version=installation_info["oss_version"],
-            arf_enterprise_version=installation_info["enterprise_version"],
+        # Core Settings
+        arf_mode: ARFMode = Field(default=ARFMode.DEMO, description="ARF operational mode")
+        safety_mode: SafetyMode = Field(default=SafetyMode.STANDARD, description="Safety compliance mode")
+        debug: bool = Field(default=False, description="Enable debug logging")
+        log_level: str = Field(default="INFO", description="Logging level")
+        
+        # Version Info
+        arf_version: str = Field(default="3.3.7", description="ARF version")
+        demo_version: str = Field(default="3.8.0", description="Demo app version")
+        
+        # Installation Status
+        oss_installed: bool = Field(default=False, description="ARF OSS package installed")
+        enterprise_installed: bool = Field(default=False, description="Enterprise package installed")
+        installation_status: InstallationStatus = Field(
+            default=InstallationStatus.DEMO_MODE,
+            description="Overall installation status"
         )
         
-        print("=" * 70)
-        print("🚀 ARF Ultimate Investor Demo - Installation Status")
-        print("=" * 70)
+        # Feature Flags
+        enable_telemetry: bool = Field(default=True, description="Enable telemetry collection")
+        enable_anomaly_detection: bool = Field(default=True, description="Enable anomaly detection")
+        enable_business_metrics: bool = Field(default=True, description="Enable business metrics")
+        enable_audit_trail: bool = Field(default=True, description="Enable audit trail")
         
-        print(f"📦 ARF OSS: {'✅ v' + s.arf_oss_version if s.arf_oss_installed else '⚠️ Not installed'}")
-        print(f"🏢 Enterprise: {'✅ v' + s.arf_enterprise_version if s.arf_enterprise_installed else '⚠️ Not installed'}")
+        # Paths
+        data_dir: str = Field(default="./data", description="Data directory")
+        log_dir: str = Field(default="./logs", description="Log directory")
+        cache_dir: str = Field(default="./cache", description="Cache directory")
         
-        # Safe enum access - convert to string first
-        mode_str = str(s.arf_mode) if hasattr(s.arf_mode, 'value') else str(s.arf_mode)
-        print(f"🎯 Mode: {mode_str.upper()}")
-        print(f"🤖 Using True ARF: {'✅ Yes' if s.use_true_arf else '⚠️ Mock mode'}")
+        # API Settings
+        api_timeout: int = Field(default=30, description="API timeout in seconds")
+        max_retries: int = Field(default=3, description="Maximum API retries")
+        rate_limit: int = Field(default=100, description="API rate limit per minute")
         
-        recommendations = s.get_installation_recommendations()
-        if recommendations:
-            print("\n💡 Recommendations:")
-            for rec in recommendations:
-                print(f"  • {rec}")
+        # UI Settings
+        ui_theme: str = Field(default="dark", description="UI theme")
+        refresh_interval: int = Field(default=5, description="UI refresh interval in seconds")
         
-        print("=" * 70)
+        # Business Settings
+        default_currency: str = Field(default="USD", description="Default currency")
+        cost_per_incident: float = Field(default=10000.0, description="Default cost per incident")
+        engineer_hourly_rate: float = Field(default=150.0, description="Engineer hourly rate")
         
-    except Exception as e:
-        print(f"⚠️ Could not print installation status: {e}")
-
+        @validator('arf_mode', 'safety_mode', 'installation_status', pre=True)
+        def validate_enum_strings(cls, v, field):
+            """Convert string values to enums"""
+            if isinstance(v, str):
+                try:
+                    if field.name == 'arf_mode':
+                        return ARFMode(v.lower())
+                    elif field.name == 'safety_mode':
+                        return SafetyMode(v.lower())
+                    elif field.name == 'installation_status':
+                        return InstallationStatus(v.lower())
+                except ValueError:
+                    # Return default value
+                    if field.name == 'arf_mode':
+                        return ARFMode.DEMO
+                    elif field.name == 'safety_mode':
+                        return SafetyMode.STANDARD
+                    elif field.name == 'installation_status':
+                        return InstallationStatus.DEMO_MODE
+            return v
+        
+        @validator('installation_status', always=True)
+        def update_installation_status(cls, v, values):
+            """Update installation status based on detected packages"""
+            # Check if OSS is installed
+            try:
+                import agentic_reliability_framework
+                values['oss_installed'] = True
+            except ImportError:
+                values['oss_installed'] = False
+            
+            # Check if Enterprise is installed
+            try:
+                import agentic_reliability_enterprise
+                values['enterprise_installed'] = True
+            except ImportError:
+                values['enterprise_installed'] = False
+            
+            # Determine installation status
+            if values.get('oss_installed') and values.get('enterprise_installed'):
+                return InstallationStatus.FULL_INSTALL
+            elif values.get('oss_installed'):
+                return InstallationStatus.OSS_ONLY
+            elif values.get('enterprise_installed'):
+                return InstallationStatus.ENTERPRISE_ONLY
+            else:
+                return InstallationStatus.DEMO_MODE
 
-# Global settings instance with installation detection
+# Singleton settings instance
 try:
-    # First detect installation
-    installation_info = Settings.detect_installation()
-    
-    # Create settings with installation info
-    settings = Settings(
-        arf_oss_installed=installation_info["oss_installed"],
-        arf_enterprise_installed=installation_info["enterprise_installed"],
-        arf_oss_version=installation_info["oss_version"],
-        arf_enterprise_version=installation_info["enterprise_version"],
-    )
-    
-    # Log installation status
-    status = settings.get_installation_status()
-    logger.info(f"ARF Installation Status: {status.value}")
-    
-    if status == InstallationStatus.NOT_INSTALLED:
-        logger.warning("No ARF packages installed. Demo will use mock mode.")
-        logger.warning("For real ARF experience, install: pip install agentic-reliability-framework==3.3.7")
-    
+    settings = Settings()
+    logger.info("✅ Settings initialized successfully")
+    logger.info(f"📊 ARF Mode: {settings.arf_mode}")
+    logger.info(f"🛡️ Safety Mode: {settings.safety_mode}")
+    logger.info(f"📦 Installation Status: {settings.installation_status}")
 except Exception as e:
-    logger.warning(f"Failed to load settings: {e}, using defaults")
-    settings = Settings(
-        arf_mode=ARFMode.DEMO,
-        use_true_arf=False,
-        arf_oss_installed=False,
-        arf_enterprise_installed=False,
-        engineer_hourly_rate=150.0,
-        engineer_annual_cost=125000.0,
-        default_savings_rate=0.82,
-        auto_refresh_seconds=30,
-        max_history_items=100,
-        default_scenario="Cache Miss Storm",
-        scenario_config_path="config/scenarios",
-        default_safety_mode=SafetyMode.ADVISORY,
-        require_approval=True
-    )
-
+    logger.error(f"❌ Failed to initialize settings: {e}")
+    # Create fallback settings
+    class FallbackSettings:
+        arf_mode = ARFMode.DEMO
+        safety_mode = SafetyMode.STANDARD
+        debug = False
+        log_level = "INFO"
+        arf_version = "3.3.7"
+        demo_version = "3.8.0"
+        oss_installed = False
+        enterprise_installed = False
+        installation_status = InstallationStatus.DEMO_MODE
+        enable_telemetry = True
+        enable_anomaly_detection = True
+        enable_business_metrics = True
+        enable_audit_trail = True
+        data_dir = "./data"
+        log_dir = "./logs"
+        cache_dir = "./cache"
+        api_timeout = 30
+        max_retries = 3
+        rate_limit = 100
+        ui_theme = "dark"
+        refresh_interval = 5
+        default_currency = "USD"
+        cost_per_incident = 10000.0
+        engineer_hourly_rate = 150.0
+    
+    settings = FallbackSettings()
+    logger.warning("⚠️ Using fallback settings due to initialization error")
 
 def get_settings() -> Settings:
-    """Get settings instance (singleton pattern)"""
-    return settings
+    """Get the settings singleton instance"""
+    return settings
+
+# Export everything
+__all__ = [
+    "Settings",
+    "get_settings",
+    "ARFMode",
+    "SafetyMode",
+    "InstallationStatus",
+    "settings"
+]