Update src/utils/config.py

src/utils/config.py

@@ -1,24 +1,290 @@
+import json
+import os
+from typing import Dict, Any, Optional
+from dataclasses import dataclass, asdict, field
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
 class TradingConfig:
-    def __init__(self):
-        # Environment settings
-        self.initial_balance = 10000
-        self.max_steps = 1000
-        self.transaction_cost = 0.001
-        
-        # AI Agent settings
-        self.learning_rate = 0.001
-        self.gamma = 0.99
-        self.epsilon_start = 1.0
-        self.epsilon_min = 0.1
-        self.epsilon_decay = 0.995
-        self.memory_size = 500
-        self.batch_size = 16
-        
-        # Visualization settings
-        self.chart_width = 800
-        self.chart_height = 600
-        self.update_interval = 100
+    """Comprehensive trading configuration with validation and persistence"""
+    
+    # Environment settings
+    initial_balance: float = 10000.0
+    max_steps: int = 1000
+    transaction_cost: float = 0.001
+    risk_level: str = "Medium"
+    asset_type: str = "Crypto"
+    
+    # AI Agent settings
+    learning_rate: float = 0.001
+    gamma: float = 0.99
+    epsilon_start: float = 1.0
+    epsilon_min: float = 0.01
+    epsilon_decay: float = 0.9995
+    memory_size: int = 10000
+    batch_size: int = 32
+    target_update_freq: int = 100
+    gradient_clip: float = 1.0
+    
+    # Sentiment settings
+    use_sentiment: bool = True
+    sentiment_influence: float = 0.3
+    sentiment_update_freq: int = 5
+    
+    # Visualization settings
+    chart_width: int = 800
+    chart_height: int = 600
+    update_interval: int = 100
+    enable_visualization: bool = True
+    
+    # Training settings
+    max_episodes: int = 1000
+    eval_episodes: int = 10
+    eval_freq: int = 100
+    save_freq: int = 500
+    log_level: str = "INFO"
+    
+    # Paths
+    model_dir: str = "models"
+    log_dir: str = "logs"
+    data_dir: str = "data"
+    
+    # Device settings
+    use_cuda: bool = True
+    device: str = "auto"
+    
+    def __post_init__(self):
+        """Validate and initialize configuration"""
+        self._validate()
+        self._setup_paths()
+        self._setup_device()
+        self._setup_logging()
+    
+    def _validate(self):
+        """Validate configuration parameters"""
+        errors = []
         
+        # Balance validation
+        if self.initial_balance <= 0:
+            errors.append("initial_balance must be positive")
+        
+        # Steps validation
+        if self.max_steps <= 0:
+            errors.append("max_steps must be positive")
+        
+        # Costs validation
+        if not 0.0 <= self.transaction_cost <= 0.1:
+            errors.append("transaction_cost should be between 0 and 0.1")
+        
+        # Learning rate validation
+        if not 0.0001 <= self.learning_rate <= 0.1:
+            errors.append("learning_rate should be between 0.0001 and 0.1")
+        
+        # Discount factor validation
+        if not 0.0 <= self.gamma <= 1.0:
+            errors.append("gamma must be between 0 and 1")
+        
+        # Epsilon validation
+        if not 0.0 <= self.epsilon_min <= self.epsilon_start <= 1.0:
+            errors.append("epsilon values must satisfy 0 <= epsilon_min <= epsilon_start <= 1")
+        
+        # Batch size validation
+        if self.batch_size > self.memory_size:
+            errors.append("batch_size cannot exceed memory_size")
+        
+        # Risk level validation
+        valid_risks = ["Low", "Medium", "High"]
+        if self.risk_level not in valid_risks:
+            errors.append(f"risk_level must be one of {valid_risks}")
+        
+        # Asset type validation
+        valid_assets = ["Crypto", "Stocks", "Forex", "Commodities"]
+        if self.asset_type not in valid_assets:
+            errors.append(f"asset_type must be one of {valid_assets}")
+        
+        # Sentiment influence validation
+        if not 0.0 <= self.sentiment_influence <= 1.0:
+            errors.append("sentiment_influence must be between 0 and 1")
+        
+        if errors:
+            logger.error(f"Configuration validation errors: {errors}")
+            raise ValueError(f"Invalid configuration: {'; '.join(errors)}")
+        
+        logger.info("Configuration validation passed")
+    
+    def _setup_paths(self):
+        """Create necessary directories"""
+        for path_attr in ['model_dir', 'log_dir', 'data_dir']:
+            path = Path(getattr(self, path_attr))
+            path.mkdir(parents=True, exist_ok=True)
+            setattr(self, f"{path_attr}_path", path)
+    
+    def _setup_device(self):
+        """Setup device configuration"""
+        import torch
+        if self.device == "auto":
+            self.device = "cuda" if self.use_cuda and torch.cuda.is_available() else "cpu"
+        else:
+            if self.device not in ["cpu", "cuda", "mps"]:
+                logger.warning(f"Unknown device {self.device}, defaulting to CPU")
+                self.device = "cpu"
+        
+        logger.info(f"Using device: {self.device}")
+    
+    def _setup_logging(self):
+        """Setup logging configuration"""
+        import logging
+        log_level = getattr(logging, self.log_level.upper())
+        logging.getLogger().setLevel(log_level)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert config to dictionary, excluding sensitive paths"""
+        config_dict = asdict(self)
+        # Remove absolute paths for serialization
+        for key in list(config_dict.keys()):
+            if key.endswith('_path') or 'dir' in key:
+                config_dict[key] = str(getattr(self, key)) if isinstance(getattr(self, key), Path) else getattr(self, key)
+        return config_dict
+    
+    def to_json(self, filepath: Optional[str] = None) -> str:
+        """Serialize config to JSON"""
+        config_dict = self.to_dict()
+        json_str = json.dumps(config_dict, indent=2, default=str)
+        
+        if filepath:
+            with open(filepath, 'w') as f:
+                f.write(json_str)
+            logger.info(f"Config saved to {filepath}")
+        
+        return json_str
+    
+    @classmethod
+    def from_json(cls, filepath: str) -> 'TradingConfig':
+        """Load config from JSON file"""
+        try:
+            with open(filepath, 'r') as f:
+                config_dict = json.load(f)
+            
+            # Create dataclass instance
+            config = cls(**config_dict)
+            logger.info(f"Config loaded from {filepath}")
+            return config
+        except Exception as e:
+            logger.error(f"Error loading config from {filepath}: {e}")
+            raise
+    
+    @classmethod
+    def from_dict(cls, config_dict: Dict[str, Any]) -> 'TradingConfig':
+        """Create config from dictionary"""
+        return cls(**config_dict)
+    
+    def save(self, filepath: str):
+        """Save config to file"""
+        self.to_json(filepath)
+    
+    @staticmethod
+    def load(filepath: str) -> 'TradingConfig':
+        """Static method to load config"""
+        return TradingConfig.from_json(filepath)
+    
+    def update(self, **kwargs):
+        """Update config parameters and revalidate"""
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+            else:
+                logger.warning(f"Unknown config parameter: {key}")
+        
+        self._validate()
+        logger.info("Config updated and validated")
+    
+    def get_agent_params(self) -> Dict[str, Any]:
+        """Get parameters specific to agent"""
+        return {
+            'learning_rate': self.learning_rate,
+            'gamma': self.gamma,
+            'epsilon_start': self.epsilon_start,
+            'epsilon_min': self.epsilon_min,
+            'epsilon_decay': self.epsilon_decay,
+            'memory_size': self.memory_size,
+            'batch_size': self.batch_size,
+            'target_update_freq': self.target_update_freq,
+            'gradient_clip': self.gradient_clip,
+            'device': self.device
+        }
+    
+    def get_env_params(self) -> Dict[str, Any]:
+        """Get parameters specific to environment"""
+        return {
+            'initial_balance': self.initial_balance,
+            'max_steps': self.max_steps,
+            'transaction_cost': self.transaction_cost,
+            'risk_level': self.risk_level,
+            'asset_type': self.asset_type,
+            'use_sentiment': self.use_sentiment,
+            'sentiment_influence': self.sentiment_influence,
+            'sentiment_update_freq': self.sentiment_update_freq
+        }
+    
+    def __str__(self) -> str:
+        """String representation of config"""
+        return json.dumps(self.to_dict(), indent=2)
+
+
+# Legacy compatibility
+class LegacyTradingConfig:
+    """Wrapper for backward compatibility"""
+    
+    def __init__(self, config_file: Optional[str] = None):
+        if config_file and os.path.exists(config_file):
+            self.config = TradingConfig.from_json(config_file)
+        else:
+            self.config = TradingConfig()
+    
+    def __getattr__(self, name):
+        return getattr(self.config, name)
+    
     def to_dict(self):
-        return {key: value for key, value in self.__dict__.items() 
-                if not key.startswith('_')}
+        return self.config.to_dict()
+
+
+# Default config instance
+DEFAULT_CONFIG = TradingConfig()
+
+# Example usage and config loading
+def create_config_from_env() -> TradingConfig:
+    """Create config from environment variables"""
+    import os
+    config_dict = {}
+    
+    env_mappings = {
+        'INITIAL_BALANCE': 'initial_balance',
+        'MAX_STEPS': 'max_steps',
+        'LEARNING_RATE': 'learning_rate',
+        'BATCH_SIZE': 'batch_size',
+        'USE_CUDA': 'use_cuda'
+    }
+    
+    for env_var, config_key in env_mappings.items():
+        env_value = os.getenv(env_var)
+        if env_value is not None:
+            try:
+                # Try to convert to appropriate type
+                if config_key in ['initial_balance', 'learning_rate']:
+                    config_dict[config_key] = float(env_value)
+                elif config_key in ['max_steps', 'batch_size']:
+                    config_dict[config_key] = int(env_value)
+                elif config_key == 'use_cuda':
+                    config_dict[config_key] = env_value.lower() in ('true', '1', 'yes')
+            except ValueError:
+                logger.warning(f"Invalid environment variable {env_var}: {env_value}")
+    
+    if config_dict:
+        base_config = TradingConfig()
+        base_config.update(**config_dict)
+        return base_config
+    
+    return DEFAULT_CONFIG