gogo2/main_clean.py

#!/usr/bin/env python3
"""
Clean Trading System - Main Entry Point

Unified entry point for the clean trading architecture with these modes:
- test: Test data provider and orchestrator
- cnn: Train CNN models only
- rl: Train RL agents only
- train: Train both CNN and RL models
- trade: Live trading mode
- web: Web dashboard with real-time charts

Usage:
    python main_clean.py --mode [test|cnn|rl|train|trade|web] --symbol ETH/USDT
"""

import asyncio
import argparse
import logging
import sys
from pathlib import Path
from threading import Thread
import time

# Add project root to path
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))

from core.config import get_config, setup_logging
from core.data_provider import DataProvider
from core.orchestrator import TradingOrchestrator

logger = logging.getLogger(__name__)

def run_data_test():
    """Test the enhanced data provider functionality"""
    try:
        config = get_config()
        logger.info("Testing Enhanced Data Provider...")
        
        # Test data provider with multiple timeframes
        data_provider = DataProvider(
            symbols=['ETH/USDT'],
            timeframes=['1s', '1m', '1h', '4h']  # Include 1s for scalping
        )
        
        # Test historical data
        logger.info("Testing historical data fetching...")
        df = data_provider.get_historical_data('ETH/USDT', '1h', limit=100)
        if df is not None:
            logger.info(f"[SUCCESS] Historical data: {len(df)} candles loaded")
            logger.info(f"   Columns: {len(df.columns)} total")
            logger.info(f"   Date range: {df['timestamp'].min()} to {df['timestamp'].max()}")
            
            # Show indicator breakdown
            basic_cols = ['timestamp', 'open', 'high', 'low', 'close', 'volume']
            indicators = [col for col in df.columns if col not in basic_cols]
            logger.info(f"   Technical indicators: {len(indicators)}")
        else:
            logger.error("[FAILED] Failed to load historical data")
        
        # Test multi-timeframe feature matrix
        logger.info("Testing multi-timeframe feature matrix...")
        feature_matrix = data_provider.get_feature_matrix('ETH/USDT', ['1h', '4h'], window_size=20)
        if feature_matrix is not None:
            logger.info(f"[SUCCESS] Feature matrix shape: {feature_matrix.shape}")
            logger.info(f"   Timeframes: {feature_matrix.shape[0]}")
            logger.info(f"   Window size: {feature_matrix.shape[1]}")
            logger.info(f"   Features: {feature_matrix.shape[2]}")
        else:
            logger.error("[FAILED] Failed to create feature matrix")
        
        # Test health check
        health = data_provider.health_check()
        logger.info(f"[SUCCESS] Data provider health check completed")
        
        logger.info("Enhanced data provider test completed successfully!")
        
    except Exception as e:
        logger.error(f"Error in data test: {e}")
        import traceback
        logger.error(traceback.format_exc())
        raise

def run_cnn_training():
    """Train CNN models only"""
    try:
        logger.info("Starting CNN Training Mode...")
        
        # Initialize components
        data_provider = DataProvider(
            symbols=['ETH/USDT', 'BTC/USDT'], 
            timeframes=['1s', '1m', '5m', '1h', '4h']
        )
        orchestrator = TradingOrchestrator(data_provider)
        
        logger.info("Creating CNN training data...")
        
        # Prepare multi-timeframe, multi-symbol feature matrices
        symbols = ['ETH/USDT', 'BTC/USDT']
        timeframes = ['1m', '5m', '1h', '4h']
        
        for symbol in symbols:
            logger.info(f"Preparing CNN data for {symbol}...")
            
            feature_matrix = data_provider.get_feature_matrix(
                symbol, timeframes, window_size=50
            )
            
            if feature_matrix is not None:
                logger.info(f"CNN training data ready for {symbol}: {feature_matrix.shape}")
                # Here you would integrate with your CNN training module
                # Example: cnn_model.train(feature_matrix, labels)
            else:
                logger.warning(f"Could not prepare CNN data for {symbol}")
        
        logger.info("CNN training preparation completed!")
        logger.info("Note: Integrate this with your actual CNN training module")
        
    except Exception as e:
        logger.error(f"Error in CNN training: {e}")
        raise

def run_rl_training():
    """Train RL agents only"""
    try:
        logger.info("Starting RL Training Mode...")
        
        # Initialize components for RL
        data_provider = DataProvider(
            symbols=['ETH/USDT'], 
            timeframes=['1s', '1m', '5m']  # Focus on short timeframes for RL
        )
        orchestrator = TradingOrchestrator(data_provider)
        
        logger.info("Setting up RL environment...")
        
        # Get scalping data for RL training
        scalping_data = data_provider.get_latest_candles('ETH/USDT', '1s', limit=1000)
        
        if not scalping_data.empty:
            logger.info(f"RL training data ready: {len(scalping_data)} 1s candles")
            logger.info(f"Price range: ${scalping_data['close'].min():.2f} - ${scalping_data['close'].max():.2f}")
            
            # Here you would integrate with your RL training module
            # Example: rl_agent.train(environment_data=scalping_data)
        else:
            logger.warning("No scalping data available for RL training")
        
        logger.info("RL training preparation completed!")
        logger.info("Note: Integrate this with your actual RL training module")
        
    except Exception as e:
        logger.error(f"Error in RL training: {e}")
        raise

def run_combined_training():
    """Train both CNN and RL models"""
    try:
        logger.info("Starting Combined Training Mode...")
        
        # Run CNN training first
        logger.info("Phase 1: CNN Training")
        run_cnn_training()
        
        # Then RL training
        logger.info("Phase 2: RL Training")  
        run_rl_training()
        
        logger.info("Combined training completed!")
        
    except Exception as e:
        logger.error(f"Error in combined training: {e}")
        raise

def run_live_trading():
    """Run live trading mode"""
    try:
        logger.info("Starting Live Trading Mode...")
        
        # Initialize for live trading with 1s scalping focus
        data_provider = DataProvider(
            symbols=['ETH/USDT'], 
            timeframes=['1s', '1m', '5m', '15m']
        )
        orchestrator = TradingOrchestrator(data_provider)
        
        # Start real-time data streaming
        logger.info("Starting real-time data streaming...")
        
        # This would integrate with your live trading logic
        logger.info("Live trading mode ready!")
        logger.info("Note: Integrate this with your actual trading execution")
        
    except Exception as e:
        logger.error(f"Error in live trading: {e}")
        raise

def run_web_dashboard(port: int = 8050, demo_mode: bool = True):
    """Run the enhanced web dashboard"""
    try:
        from web.dashboard import TradingDashboard
        
        logger.info("Starting Enhanced Web Dashboard...")
        
        # Initialize components with 1s scalping focus
        data_provider = DataProvider(
            symbols=['ETH/USDT'], 
            timeframes=['1s', '1m', '5m', '1h', '4h']
        )
        orchestrator = TradingOrchestrator(data_provider)
        
        # Create dashboard
        dashboard = TradingDashboard(data_provider, orchestrator)
        
        if demo_mode:
            # Start demo mode with realistic scalping decisions
            logger.info("Starting scalping demo mode...")
            
            def scalping_demo_thread():
                """Generate realistic scalping decisions"""
                import random
                import time
                from datetime import datetime
                from core.orchestrator import TradingDecision
                
                actions = ['BUY', 'SELL', 'HOLD']
                action_weights = [0.3, 0.3, 0.4]  # More holds in scalping
                base_price = 3000.0
                
                while True:
                    try:
                        # Simulate small price movements for scalping
                        price_change = random.uniform(-5, 5)  # Smaller movements
                        current_price = max(base_price + price_change, 1000)
                        
                        # Create scalping decision
                        action = random.choices(actions, weights=action_weights)[0]
                        confidence = random.uniform(0.7, 0.95)  # Higher confidence for scalping
                        
                        decision = TradingDecision(
                            action=action,
                            confidence=confidence,
                            symbol='ETH/USDT',
                            price=current_price,
                            timestamp=datetime.now(),
                            reasoning={'scalping_demo': True, 'timeframe': '1s'},
                            memory_usage={'demo': 0}
                        )
                        
                        dashboard.add_trading_decision(decision)
                        logger.info(f"Scalping: {action} ETH/USDT @${current_price:.2f} (conf: {confidence:.2f})")
                        
                        # Update base price occasionally
                        if random.random() < 0.2:
                            base_price = current_price
                        
                        time.sleep(3)  # Faster decisions for scalping
                        
                    except Exception as e:
                        logger.error(f"Error in scalping demo: {e}")
                        time.sleep(5)
            
            # Start scalping demo thread
            demo_thread_instance = Thread(target=scalping_demo_thread, daemon=True)
            demo_thread_instance.start()
        
        # Run dashboard
        dashboard.run(port=port, debug=False)
        
    except Exception as e:
        logger.error(f"Error running web dashboard: {e}")
        import traceback
        logger.error(traceback.format_exc())
        raise

async def main():
    """Main entry point with clean mode selection"""
    parser = argparse.ArgumentParser(description='Clean Trading System - Unified Entry Point')
    parser.add_argument('--mode', 
                       choices=['test', 'cnn', 'rl', 'train', 'trade', 'web'], 
                       default='test', 
                       help='Operation mode')
    parser.add_argument('--symbol', type=str, default='ETH/USDT',
                       help='Trading symbol (default: ETH/USDT)')
    parser.add_argument('--port', type=int, default=8050,
                       help='Web dashboard port (default: 8050)')
    parser.add_argument('--demo', action='store_true',
                       help='Run web dashboard in demo mode')
    
    args = parser.parse_args()
    
    # Setup logging
    setup_logging()
    
    try:
        logger.info("=" * 60)
        logger.info("CLEAN TRADING SYSTEM - UNIFIED LAUNCH")
        logger.info(f"Mode: {args.mode.upper()}")
        logger.info(f"Symbol: {args.symbol}")
        logger.info("=" * 60)
        
        # Route to appropriate mode
        if args.mode == 'test':
            run_data_test()
        elif args.mode == 'cnn':
            run_cnn_training()
        elif args.mode == 'rl':
            run_rl_training()
        elif args.mode == 'train':
            run_combined_training()
        elif args.mode == 'trade':
            run_live_trading()
        elif args.mode == 'web':
            run_web_dashboard(port=args.port, demo_mode=args.demo)
        
        logger.info("Operation completed successfully!")
        
    except KeyboardInterrupt:
        logger.info("System shutdown requested by user")
    except Exception as e:
        logger.error(f"Fatal error: {e}")
        import traceback
        logger.error(traceback.format_exc())
        return 1
    
    return 0

if __name__ == "__main__":
    sys.exit(asyncio.run(main()))