cash works again!
This commit is contained in:
Dobromir Popov
@ -1,440 +1,190 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Run Ultra-Fast Scalping Dashboard (500x Leverage)
|
||||
Scalping Dashboard Runner - 100% REAL MARKET DATA ONLY
|
||||
|
||||
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
|
||||
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 asyncio
|
||||
from threading import Thread
|
||||
import sys
|
||||
import time
|
||||
import random
|
||||
from datetime import datetime, timedelta
|
||||
from dataclasses import dataclass
|
||||
from typing import Dict, List, Optional
|
||||
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, TradingAction, TimeframePrediction
|
||||
from web.scalping_dashboard import ScalpingDashboard
|
||||
from core.enhanced_orchestrator import EnhancedTradingOrchestrator
|
||||
from web.scalping_dashboard import run_scalping_dashboard
|
||||
|
||||
# Setup logging
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
setup_logging()
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
@dataclass
|
||||
class Trade:
|
||||
"""Individual trade tracking for PnL calculation"""
|
||||
trade_id: int
|
||||
symbol: str
|
||||
action: str # 'BUY', 'SELL'
|
||||
entry_price: float
|
||||
quantity: float
|
||||
entry_time: datetime
|
||||
confidence: float
|
||||
exit_price: Optional[float] = None
|
||||
exit_time: Optional[datetime] = None
|
||||
pnl: Optional[float] = None
|
||||
fees: Optional[float] = None
|
||||
leverage: int = 500
|
||||
is_closed: bool = False
|
||||
|
||||
class UltraFastScalpingRunner:
|
||||
"""Ultra-fast scalping dashboard runner with 500x leverage simulation and PnL tracking"""
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the ultra-fast scalping system with PnL tracking"""
|
||||
self.config = get_config()
|
||||
self.data_provider = DataProvider(self.config)
|
||||
self.orchestrator = EnhancedTradingOrchestrator(self.data_provider)
|
||||
|
||||
# Create the specialized scalping dashboard
|
||||
self.dashboard = ScalpingDashboard(
|
||||
data_provider=self.data_provider,
|
||||
orchestrator=self.orchestrator
|
||||
)
|
||||
|
||||
# Ultra-fast simulation state
|
||||
self.running = False
|
||||
self.simulation_thread = None
|
||||
self.exit_monitor_thread = None
|
||||
self.trade_count = 0
|
||||
|
||||
# PnL Tracking System
|
||||
self.open_positions: Dict[int, Trade] = {} # Track open positions by trade_id
|
||||
self.closed_trades: List[Trade] = [] # History of closed trades
|
||||
self.total_pnl = 0.0
|
||||
self.total_fees = 0.0
|
||||
self.win_count = 0
|
||||
self.loss_count = 0
|
||||
self.leverage = 500 # 500x leverage
|
||||
self.trading_fee = 0.0002 # 0.02% per trade
|
||||
self.balance = 10000.0 # Starting balance
|
||||
|
||||
# Price tracking for PnL calculation
|
||||
self.current_prices = {
|
||||
'ETH/USDT': 3050.0,
|
||||
'BTC/USDT': 67000.0
|
||||
}
|
||||
|
||||
# Scalping parameters
|
||||
self.min_exit_time = 2 # Minimum 2 seconds before exit
|
||||
self.max_exit_time = 15 # Maximum 15 seconds before forced exit
|
||||
|
||||
logger.info("🚀 Ultra-Fast Scalping Runner with PnL Tracking initialized")
|
||||
logger.info("⚡ 500x Leverage Mode Activated")
|
||||
logger.info(f"💰 Starting Balance: ${self.balance:.2f}")
|
||||
logger.info(f"📊 Leverage: {self.leverage}x")
|
||||
logger.info(f"💳 Trading Fee: {self.trading_fee*100:.3f}% per trade")
|
||||
logger.info(f"⏱️ Trade Duration: {self.min_exit_time}-{self.max_exit_time} seconds")
|
||||
logger.info("📊 Timeframes: 1s (primary), 1m, 1h, 1d")
|
||||
|
||||
def start_ultra_fast_simulation(self):
|
||||
"""Start ultra-fast trading simulation for 500x leverage scalping"""
|
||||
self.running = True
|
||||
self.simulation_thread = Thread(target=self._ultra_fast_loop, daemon=True)
|
||||
self.exit_monitor_thread = Thread(target=self._monitor_exits, daemon=True)
|
||||
|
||||
self.simulation_thread.start()
|
||||
self.exit_monitor_thread.start()
|
||||
|
||||
logger.info("🚀 Ultra-fast scalping simulation started")
|
||||
logger.info("⚡ Generating trades every 3-8 seconds")
|
||||
logger.info("📊 Monitoring trade exits for PnL calculation")
|
||||
|
||||
def _ultra_fast_loop(self):
|
||||
"""Ultra-fast scalping simulation loop with trade entry"""
|
||||
while self.running:
|
||||
try:
|
||||
# Update current prices with realistic movement
|
||||
self._update_prices()
|
||||
|
||||
# Ultra-fast scalping - trades every 3-8 seconds
|
||||
for symbol in ['ETH/USDT', 'BTC/USDT']:
|
||||
# 40% chance of action (very active scalping)
|
||||
if random.random() > 0.6:
|
||||
self._execute_trade(symbol)
|
||||
|
||||
# Ultra-fast interval (3-8 seconds between trades)
|
||||
sleep_time = random.uniform(3, 8)
|
||||
time.sleep(sleep_time)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error in ultra-fast scalping loop: {e}")
|
||||
time.sleep(2)
|
||||
|
||||
def _execute_trade(self, symbol: str):
|
||||
"""Execute a new scalping trade"""
|
||||
self.trade_count += 1
|
||||
|
||||
# Create ultra-fast timeframe predictions
|
||||
timeframe_predictions = []
|
||||
|
||||
# Focus on 1s predictions (primary for scalping)
|
||||
for tf, weight in [('1s', 0.6), ('1m', 0.2), ('1h', 0.15), ('1d', 0.05)]:
|
||||
# More aggressive probabilities for scalping
|
||||
if tf == '1s': # Primary scalping signal
|
||||
action_probs = [
|
||||
random.uniform(0.05, 0.25), # SELL
|
||||
random.uniform(0.20, 0.40), # HOLD
|
||||
random.uniform(0.35, 0.75) # BUY (bias for bull market)
|
||||
]
|
||||
else:
|
||||
action_probs = [
|
||||
random.uniform(0.1, 0.4), # SELL
|
||||
random.uniform(0.3, 0.6), # HOLD
|
||||
random.uniform(0.1, 0.4) # BUY
|
||||
]
|
||||
|
||||
# Normalize probabilities
|
||||
total = sum(action_probs)
|
||||
action_probs = [p/total for p in action_probs]
|
||||
|
||||
best_action_idx = action_probs.index(max(action_probs))
|
||||
actions = ['SELL', 'HOLD', 'BUY']
|
||||
best_action = actions[best_action_idx]
|
||||
|
||||
tf_pred = TimeframePrediction(
|
||||
timeframe=tf,
|
||||
action=best_action,
|
||||
confidence=random.uniform(0.65, 0.95), # High confidence for scalping
|
||||
probabilities={
|
||||
'SELL': action_probs[0],
|
||||
'HOLD': action_probs[1],
|
||||
'BUY': action_probs[2]
|
||||
},
|
||||
timestamp=datetime.now(),
|
||||
market_features={
|
||||
'volatility': random.uniform(0.005, 0.02), # Higher volatility for 1s
|
||||
'volume': random.uniform(2000, 15000), # High volume for scalping
|
||||
'trend_strength': random.uniform(0.4, 0.9),
|
||||
'leverage': '500x',
|
||||
'scalping_signal': tf == '1s'
|
||||
}
|
||||
)
|
||||
timeframe_predictions.append(tf_pred)
|
||||
|
||||
# Create scalping action (focus on non-HOLD actions)
|
||||
primary_action = timeframe_predictions[0].action # Use 1s timeframe
|
||||
if primary_action == 'HOLD':
|
||||
primary_action = random.choice(['BUY', 'SELL']) # Force action for demo
|
||||
|
||||
# Get current price and calculate trade details
|
||||
entry_price = self.current_prices[symbol]
|
||||
quantity = random.uniform(0.01, 0.05) # Small quantities for scalping
|
||||
confidence = random.uniform(0.70, 0.95)
|
||||
|
||||
# Create trade record
|
||||
trade = Trade(
|
||||
trade_id=self.trade_count,
|
||||
symbol=symbol,
|
||||
action=primary_action,
|
||||
entry_price=entry_price,
|
||||
quantity=quantity,
|
||||
entry_time=datetime.now(),
|
||||
confidence=confidence,
|
||||
leverage=self.leverage
|
||||
)
|
||||
|
||||
# Store open position
|
||||
self.open_positions[self.trade_count] = trade
|
||||
|
||||
# Calculate position value and fees
|
||||
position_value = quantity * entry_price
|
||||
leveraged_value = position_value * self.leverage
|
||||
entry_fee = position_value * self.trading_fee
|
||||
|
||||
# Create ultra-fast trading action for dashboard
|
||||
scalping_action = TradingAction(
|
||||
symbol=symbol,
|
||||
action=primary_action,
|
||||
quantity=quantity,
|
||||
confidence=confidence,
|
||||
price=entry_price,
|
||||
timestamp=datetime.now(),
|
||||
reasoning={
|
||||
'model': 'Ultra-Fast Scalping AI',
|
||||
'leverage': f'{self.leverage}x',
|
||||
'timeframe_primary': '1s',
|
||||
'scalping_mode': True,
|
||||
'trade_id': self.trade_count,
|
||||
'expected_duration': f"{random.uniform(2, 8):.1f}s",
|
||||
'market_regime': random.choice(['trending_up', 'momentum', 'breakout']),
|
||||
'position_value': f"${leveraged_value:.2f}",
|
||||
'entry_fee': f"${entry_fee:.2f}"
|
||||
},
|
||||
timeframe_analysis=timeframe_predictions
|
||||
)
|
||||
|
||||
# Add to dashboard
|
||||
self.dashboard.add_trading_decision(scalping_action)
|
||||
|
||||
# Log trade entry with detailed information
|
||||
logger.info(f"🔥 TRADE #{self.trade_count} OPENED:")
|
||||
logger.info(f" 📊 {primary_action} {symbol} @ ${entry_price:.2f}")
|
||||
logger.info(f" 📈 Quantity: {quantity:.4f} | Confidence: {confidence:.1%}")
|
||||
logger.info(f" 💰 Position Value: ${leveraged_value:.2f} ({self.leverage}x leverage)")
|
||||
logger.info(f" 💳 Entry Fee: ${entry_fee:.4f}")
|
||||
logger.info(f" ⏱️ Expected Exit: {self.min_exit_time}-{self.max_exit_time}s")
|
||||
|
||||
def _monitor_exits(self):
|
||||
"""Monitor open positions and execute exits for PnL calculation"""
|
||||
while self.running:
|
||||
try:
|
||||
current_time = datetime.now()
|
||||
positions_to_close = []
|
||||
|
||||
for trade_id, trade in self.open_positions.items():
|
||||
time_elapsed = (current_time - trade.entry_time).total_seconds()
|
||||
|
||||
# Check if trade should be closed
|
||||
should_close = False
|
||||
|
||||
# Force close after max time
|
||||
if time_elapsed >= self.max_exit_time:
|
||||
should_close = True
|
||||
|
||||
# Probabilistic close after min time (scalping style)
|
||||
elif time_elapsed >= self.min_exit_time:
|
||||
close_probability = (time_elapsed - self.min_exit_time) / (self.max_exit_time - self.min_exit_time)
|
||||
if random.random() < close_probability * 0.3: # 30% max probability per check
|
||||
should_close = True
|
||||
|
||||
if should_close:
|
||||
positions_to_close.append(trade_id)
|
||||
|
||||
# Close positions and calculate PnL
|
||||
for trade_id in positions_to_close:
|
||||
self._close_position(trade_id)
|
||||
|
||||
time.sleep(0.5) # Check every 500ms for ultra-fast scalping
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error in exit monitoring: {e}")
|
||||
time.sleep(1)
|
||||
|
||||
def _close_position(self, trade_id: int):
|
||||
"""Close a position and calculate PnL"""
|
||||
if trade_id not in self.open_positions:
|
||||
return
|
||||
|
||||
trade = self.open_positions[trade_id]
|
||||
|
||||
# Get current exit price
|
||||
exit_price = self.current_prices[trade.symbol]
|
||||
trade.exit_price = exit_price
|
||||
trade.exit_time = datetime.now()
|
||||
|
||||
# Calculate PnL based on trade direction
|
||||
if trade.action == 'BUY':
|
||||
# Long position: profit when price goes up
|
||||
price_change = (exit_price - trade.entry_price) / trade.entry_price
|
||||
else: # SELL
|
||||
# Short position: profit when price goes down
|
||||
price_change = (trade.entry_price - exit_price) / trade.entry_price
|
||||
|
||||
# Calculate leveraged PnL
|
||||
position_value = trade.quantity * trade.entry_price
|
||||
raw_pnl = position_value * price_change * self.leverage
|
||||
|
||||
# Calculate fees (entry + exit)
|
||||
entry_fee = position_value * self.trading_fee
|
||||
exit_fee = trade.quantity * exit_price * self.trading_fee
|
||||
total_fees = entry_fee + exit_fee
|
||||
|
||||
# Net PnL after fees
|
||||
net_pnl = raw_pnl - total_fees
|
||||
|
||||
# Update trade record
|
||||
trade.pnl = net_pnl
|
||||
trade.fees = total_fees
|
||||
trade.is_closed = True
|
||||
|
||||
# Update totals
|
||||
self.total_pnl += net_pnl
|
||||
self.total_fees += total_fees
|
||||
|
||||
if net_pnl > 0:
|
||||
self.win_count += 1
|
||||
else:
|
||||
self.loss_count += 1
|
||||
|
||||
# Update dashboard metrics
|
||||
self.dashboard.scalping_metrics['total_pnl'] = self.total_pnl
|
||||
self.dashboard.scalping_metrics['win_rate'] = self.win_count / (self.win_count + self.loss_count) if (self.win_count + self.loss_count) > 0 else 0
|
||||
|
||||
# Move to closed trades
|
||||
self.closed_trades.append(trade)
|
||||
del self.open_positions[trade_id]
|
||||
|
||||
# Calculate trade duration
|
||||
duration = (trade.exit_time - trade.entry_time).total_seconds()
|
||||
|
||||
# Log detailed PnL information
|
||||
pnl_color = "🟢" if net_pnl > 0 else "🔴"
|
||||
logger.info(f"{pnl_color} TRADE #{trade_id} CLOSED:")
|
||||
logger.info(f" 📊 {trade.action} {trade.symbol}: ${trade.entry_price:.2f} → ${exit_price:.2f}")
|
||||
logger.info(f" 📈 Price Change: {price_change*100:+.3f}%")
|
||||
logger.info(f" ⏱️ Duration: {duration:.1f}s")
|
||||
logger.info(f" 💰 Raw PnL: ${raw_pnl:+.2f} ({self.leverage}x leverage)")
|
||||
logger.info(f" 💳 Total Fees: ${total_fees:.4f}")
|
||||
logger.info(f" 🎯 Net PnL: ${net_pnl:+.2f}")
|
||||
logger.info(f" 📊 Total PnL: ${self.total_pnl:+.2f} | Win Rate: {self.dashboard.scalping_metrics['win_rate']*100:.1f}%")
|
||||
logger.info(" " + "="*50)
|
||||
|
||||
def _update_prices(self):
|
||||
"""Update current prices with realistic movement"""
|
||||
for symbol in self.current_prices:
|
||||
# Small random price movement (typical for 1s intervals)
|
||||
current_price = self.current_prices[symbol]
|
||||
|
||||
# More volatile movement for realistic scalping
|
||||
if symbol == 'ETH/USDT':
|
||||
change_percent = random.normalvariate(0, 0.0008) # ~0.08% standard deviation
|
||||
else: # BTC/USDT
|
||||
change_percent = random.normalvariate(0, 0.0006) # ~0.06% standard deviation
|
||||
|
||||
new_price = current_price * (1 + change_percent)
|
||||
|
||||
# Keep prices within reasonable bounds
|
||||
if symbol == 'ETH/USDT':
|
||||
new_price = max(3000, min(3100, new_price))
|
||||
else: # BTC/USDT
|
||||
new_price = max(66000, min(68000, new_price))
|
||||
|
||||
self.current_prices[symbol] = new_price
|
||||
|
||||
def _get_realistic_price(self, symbol: str) -> float:
|
||||
"""Get realistic price for symbol"""
|
||||
return self.current_prices[symbol]
|
||||
|
||||
def run_scalping_dashboard(self, host='127.0.0.1', port=8051):
|
||||
"""Run the ultra-fast scalping dashboard"""
|
||||
logger.info("🔥 ULTRA-FAST SCALPING DASHBOARD WITH PnL TRACKING 🔥")
|
||||
logger.info(f"🌐 Starting at http://{host}:{port}")
|
||||
logger.info("📊 Dashboard Features:")
|
||||
logger.info(" • Full-width 1s ETH/USDT candlestick chart")
|
||||
logger.info(" • 3 small ETH charts: 1m, 1h, 1d")
|
||||
logger.info(" • 1 small BTC 1s chart")
|
||||
logger.info(" • 100ms ultra-fast updates")
|
||||
logger.info(" • 500x leverage simulation")
|
||||
logger.info(" • Real-time PnL tracking and logging")
|
||||
logger.info("")
|
||||
logger.info("🎯 Optimized for ultra-fast scalping trades")
|
||||
logger.info("⚡ Generating trading signals every 3-8 seconds")
|
||||
logger.info("💰 Real-time PnL calculation with fees and leverage")
|
||||
|
||||
# Start ultra-fast simulation
|
||||
self.start_ultra_fast_simulation()
|
||||
|
||||
# Run dashboard
|
||||
try:
|
||||
self.dashboard.run(host=host, port=port, debug=False)
|
||||
except KeyboardInterrupt:
|
||||
logger.info("🛑 Scalping dashboard stopped by user")
|
||||
finally:
|
||||
self.running = False
|
||||
if self.simulation_thread:
|
||||
self.simulation_thread.join(timeout=2)
|
||||
if self.exit_monitor_thread:
|
||||
self.exit_monitor_thread.join(timeout=2)
|
||||
|
||||
# Final session summary
|
||||
total_trades = len(self.closed_trades)
|
||||
logger.info("💼 FINAL SCALPING SESSION SUMMARY:")
|
||||
logger.info("="*60)
|
||||
logger.info(f" 📊 Total Trades: {total_trades}")
|
||||
logger.info(f" 🎯 Total PnL: ${self.total_pnl:+.2f}")
|
||||
logger.info(f" 💳 Total Fees: ${self.total_fees:.2f}")
|
||||
logger.info(f" 🟢 Wins: {self.win_count} | 🔴 Losses: {self.loss_count}")
|
||||
logger.info(f" 📈 Win Rate: {self.dashboard.scalping_metrics['win_rate']*100:.1f}%")
|
||||
logger.info(f" 💰 Starting Balance: ${self.balance:.2f}")
|
||||
logger.info(f" 💰 Final Balance: ${self.balance + self.total_pnl:.2f}")
|
||||
logger.info(f" 📊 Return: {((self.balance + self.total_pnl) / self.balance - 1) * 100:+.2f}%")
|
||||
logger.info("="*60)
|
||||
|
||||
def main():
|
||||
"""Main function"""
|
||||
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("=== ULTRA-FAST SCALPING SYSTEM WITH PnL TRACKING ===")
|
||||
logger.info("💰 500x Leverage Mode")
|
||||
logger.info("⚡ Optimized for 1s-8s trades")
|
||||
logger.info("📊 Real-time PnL calculation and logging")
|
||||
logger.info("🔍 VALIDATING REAL MARKET DATA CONNECTION...")
|
||||
|
||||
# Create and run scalping dashboard
|
||||
runner = UltraFastScalpingRunner()
|
||||
runner.run_scalping_dashboard()
|
||||
# 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"Fatal error: {e}")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
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__":
|
||||
main()
|
||||
exit_code = main()
|
||||
sys.exit(exit_code if exit_code else 0)
|
||||
Reference in New Issue
Block a user