#!/usr/bin/env python3 """ Scalping Dashboard Runner - 100% REAL MARKET DATA ONLY CRITICAL: This dashboard uses EXCLUSIVELY real market data. NO synthetic, mock, or simulated data is allowed. All trading decisions come from real market analysis. """ 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 run_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'] for symbol in test_symbols: # Force fresh data fetch (no cache) data = data_provider.get_historical_data(symbol, '1s', limit=100, refresh=True) if data is None or data.empty: logger.error(f"❌ CRITICAL: No real 1s data for {symbol}") return False # Validate data quality for scalping if len(data) < 50: logger.error(f"❌ CRITICAL: Insufficient real data for scalping {symbol}") return False # Check for realistic price variations price_std = data['close'].std() if price_std == 0: logger.error(f"❌ CRITICAL: Static prices detected - possible synthetic data {symbol}") return False logger.info(f"✅ Real 1s data validated: {symbol} - {len(data)} candles, price_std: {price_std:.4f}") logger.info("✅ REAL MARKET DATA CONNECTION VALIDATED FOR SCALPING") 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._real_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 _real_trading_loop(self): """ Real trading analysis loop using live market data ONLY """ logger.info("🔄 Starting REAL trading analysis loop...") while self.running: try: # Analyze real market conditions for ETH/USDT and BTC/USDT symbols = ['ETH/USDT', 'BTC/USDT'] for symbol in symbols: # Get real-time market analysis from orchestrator analysis = self.orchestrator.analyze_market_conditions(symbol) if analysis is None: logger.warning(f"⚠ī¸ No real market analysis available for {symbol}") continue # Get real market data for decision making current_data = self.data_provider.get_historical_data( symbol, '1s', limit=20, refresh=True ) if current_data is None or current_data.empty: logger.warning(f"⚠ī¸ No real current data for {symbol}") continue # Make trading decision based on REAL market analysis decision = self.orchestrator.make_trading_decision(symbol) if decision and decision.action in ['BUY', 'SELL']: self.trade_count += 1 current_price = current_data['close'].iloc[-1] logger.info(f"đŸ”Ĩ REAL TRADING DECISION #{self.trade_count}:") logger.info(f" 📊 {decision.action} {symbol} @ ${current_price:.2f}") logger.info(f" 📈 Confidence: {decision.confidence:.1%}") logger.info(f" 💰 Based on REAL market analysis") logger.info(f" 🕐 {datetime.now().strftime('%H:%M:%S')}") # Wait between real analysis cycles (scalping frequency) time.sleep(5) # 5-second analysis cycles for scalping except Exception as e: logger.error(f"❌ Error in real trading analysis: {e}") time.sleep(10) # Longer wait on error 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 real data logger.info("🔍 Testing orchestrator with real market data...") test_analysis = orchestrator.analyze_market_conditions('ETH/USDT') if test_analysis is None: logger.error("❌ CRITICAL: Orchestrator failed to analyze real market data") 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 run_scalping_dashboard(data_provider, orchestrator) 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)