#!/usr/bin/env python3 """ Run Ultra-Fast Scalping Dashboard (500x Leverage) This script starts the custom scalping dashboard with: - Full-width 1s ETH/USDT candlestick chart - 3 small ETH charts: 1m, 1h, 1d - 1 small BTC 1s chart - Ultra-fast 100ms updates for scalping - Real-time PnL tracking and logging - Enhanced orchestrator with real AI model decisions """ import asyncio import logging import sys import time from datetime import datetime from pathlib import Path from threading import Thread # 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.enhanced_orchestrator import EnhancedTradingOrchestrator from web.scalping_dashboard import create_scalping_dashboard # Setup logging setup_logging() logger = logging.getLogger(__name__) def validate_real_market_connection(data_provider: DataProvider) -> bool: """ CRITICAL: Validate real market data connection Returns False if connection fails or data seems synthetic """ try: logger.info("VALIDATING REAL MARKET DATA CONNECTION...") # Test primary trading symbols test_symbols = ['ETH/USDT', 'BTC/USDT'] test_timeframes = ['1m', '5m'] for symbol in test_symbols: for timeframe in test_timeframes: # Force fresh data fetch (no cache) data = data_provider.get_historical_data(symbol, timeframe, limit=50, refresh=True) if data is None or data.empty: logger.error(f"CRITICAL: No real data for {symbol} {timeframe}") return False # Validate data quality for trading if len(data) < 10: logger.error(f"CRITICAL: Insufficient real data for {symbol} {timeframe}") return False # Check for realistic price ranges (basic sanity check) prices = data['close'].values if 'ETH' in symbol and (prices.min() < 100 or prices.max() > 10000): logger.error(f"CRITICAL: Unrealistic ETH prices detected - possible synthetic data") return False elif 'BTC' in symbol and (prices.min() < 10000 or prices.max() > 200000): logger.error(f"CRITICAL: Unrealistic BTC prices detected - possible synthetic data") return False logger.info(f"Real data validated: {symbol} {timeframe} - {len(data)} candles") logger.info("ALL REAL MARKET DATA CONNECTIONS VALIDATED") return True except Exception as e: logger.error(f"CRITICAL: Market data validation failed: {e}") return False class RealTradingEngine: """ Real trading engine that makes decisions based on live market analysis NO SYNTHETIC DATA - Uses orchestrator for real market analysis """ def __init__(self, data_provider: DataProvider, orchestrator: EnhancedTradingOrchestrator): self.data_provider = data_provider self.orchestrator = orchestrator self.running = False self.trade_count = 0 def start(self): """Start real trading analysis""" self.running = True trading_thread = Thread(target=self._run_async_trading_loop, daemon=True) trading_thread.start() logger.info("REAL TRADING ENGINE STARTED - NO SYNTHETIC DATA") def stop(self): """Stop trading analysis""" self.running = False logger.info("Real trading engine stopped") def _run_async_trading_loop(self): """Run the async trading loop in a separate thread""" asyncio.run(self._real_trading_loop()) async def _real_trading_loop(self): """ Real trading analysis loop using live market data ONLY """ logger.info("Starting REAL trading analysis loop...") while self.running: try: # Make coordinated decisions using the orchestrator decisions = await self.orchestrator.make_coordinated_decisions() for symbol, decision in decisions.items(): if decision and decision.action in ['BUY', 'SELL']: self.trade_count += 1 logger.info(f"REAL TRADING DECISION #{self.trade_count}:") logger.info(f" {decision.action} {symbol} @ ${decision.price:.2f}") logger.info(f" Confidence: {decision.confidence:.1%}") logger.info(f" Quantity: {decision.quantity:.6f}") logger.info(f" Based on REAL market analysis") logger.info(f" Time: {datetime.now().strftime('%H:%M:%S')}") # Log timeframe analysis for tf_pred in decision.timeframe_analysis: logger.info(f" {tf_pred.timeframe}: {tf_pred.action} " f"(conf: {tf_pred.confidence:.3f})") # Evaluate past actions for RL learning await self.orchestrator.evaluate_actions_with_rl() # Wait between real analysis cycles (60 seconds for enhanced decisions) await asyncio.sleep(60) except Exception as e: logger.error(f"Error in real trading analysis: {e}") await asyncio.sleep(30) # Wait on error def test_orchestrator_simple(orchestrator: EnhancedTradingOrchestrator) -> bool: """Simple test to verify orchestrator can make basic decisions""" try: # Run a simple async test loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) # Test making coordinated decisions decisions = loop.run_until_complete(orchestrator.make_coordinated_decisions()) loop.close() # Check if we got any results if isinstance(decisions, dict): logger.info(f"Orchestrator test successful - got decisions for {len(decisions)} symbols") return True else: logger.error("Orchestrator test failed - no decisions returned") return False except Exception as e: logger.error(f"Orchestrator test failed: {e}") return False def main(): """Main function for scalping dashboard with REAL DATA ONLY""" logger.info("STARTING SCALPING DASHBOARD - 100% REAL MARKET DATA") logger.info("Ultra-fast scalping with live market analysis") logger.info("ZERO SYNTHETIC DATA - REAL DECISIONS ONLY") try: # Initialize data provider data_provider = DataProvider() # CRITICAL: Validate real market data connection if not validate_real_market_connection(data_provider): logger.error("CRITICAL: Real market data validation FAILED") logger.error("Scalping dashboard will NOT start without verified real data") logger.error("NO SYNTHETIC DATA FALLBACK ALLOWED") return 1 # Initialize orchestrator with validated real data orchestrator = EnhancedTradingOrchestrator(data_provider) # Test orchestrator with a simple test logger.info("Testing orchestrator with real market data...") if not test_orchestrator_simple(orchestrator): logger.error("CRITICAL: Orchestrator validation failed") return 1 logger.info("Orchestrator validated with real market data") # Initialize real trading engine trading_engine = RealTradingEngine(data_provider, orchestrator) trading_engine.start() logger.info("LAUNCHING SCALPING DASHBOARD WITH 100% REAL DATA") logger.info("Real-time scalping decisions from live market analysis") # Start the scalping dashboard with real data dashboard = create_scalping_dashboard(data_provider, orchestrator) dashboard.run(host='127.0.0.1', port=8051, debug=False) except KeyboardInterrupt: logger.info("Scalping dashboard stopped by user") return 0 except Exception as e: logger.error(f"CRITICAL ERROR: {e}") logger.error("Scalping dashboard stopped - NO SYNTHETIC DATA FALLBACK") return 1 if __name__ == "__main__": exit_code = main() sys.exit(exit_code if exit_code else 0)