558 lines
24 KiB
Python
558 lines
24 KiB
Python
"""
|
|
Ultra-Fast Real-Time Scalping Dashboard (500x Leverage) - Live Data Streaming
|
|
|
|
Real-time WebSocket streaming dashboard with:
|
|
- Main 1s ETH/USDT chart (full width) with live updates
|
|
- 4 small charts: 1m ETH, 1h ETH, 1d ETH, 1s BTC
|
|
- WebSocket price streaming for instant updates
|
|
- Europe/Sofia timezone support
|
|
- Ultra-low latency UI updates (100ms)
|
|
- NO CACHED DATA - 100% live streaming
|
|
"""
|
|
|
|
import asyncio
|
|
import json
|
|
import logging
|
|
import time
|
|
import websockets
|
|
import pytz
|
|
from datetime import datetime, timedelta
|
|
from threading import Thread, Lock
|
|
from typing import Dict, List, Optional, Any
|
|
import pandas as pd
|
|
import numpy as np
|
|
import requests
|
|
|
|
import dash
|
|
from dash import dcc, html, Input, Output
|
|
import plotly.graph_objects as go
|
|
|
|
from core.config import get_config
|
|
from core.data_provider import DataProvider
|
|
from core.enhanced_orchestrator import EnhancedTradingOrchestrator, TradingAction
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
class RealTimeScalpingDashboard:
|
|
"""Real-time scalping dashboard with WebSocket streaming and ultra-low latency"""
|
|
|
|
def __init__(self, data_provider: DataProvider = None, orchestrator: EnhancedTradingOrchestrator = None):
|
|
"""Initialize the real-time dashboard with WebSocket streaming"""
|
|
self.config = get_config()
|
|
self.data_provider = data_provider or DataProvider()
|
|
self.orchestrator = orchestrator or EnhancedTradingOrchestrator(self.data_provider)
|
|
|
|
# Timezone setup
|
|
self.timezone = pytz.timezone('Europe/Sofia')
|
|
|
|
# Dashboard state
|
|
self.recent_decisions = []
|
|
self.scalping_metrics = {
|
|
'total_trades': 0,
|
|
'win_rate': 0.78,
|
|
'total_pnl': 0.0,
|
|
'avg_trade_time': 3.2,
|
|
'leverage': '500x',
|
|
'last_action': None
|
|
}
|
|
|
|
# Real-time price streaming data
|
|
self.live_prices = {
|
|
'ETH/USDT': 0.0,
|
|
'BTC/USDT': 0.0
|
|
}
|
|
|
|
# Real-time chart data (no caching - always fresh)
|
|
self.chart_data = {
|
|
'ETH/USDT': {
|
|
'1s': pd.DataFrame(),
|
|
'1m': pd.DataFrame(),
|
|
'1h': pd.DataFrame(),
|
|
'1d': pd.DataFrame()
|
|
},
|
|
'BTC/USDT': {
|
|
'1s': pd.DataFrame()
|
|
}
|
|
}
|
|
|
|
# WebSocket streaming control
|
|
self.streaming = False
|
|
self.websocket_threads = []
|
|
self.data_lock = Lock()
|
|
|
|
# Create Dash app with real-time updates
|
|
self.app = dash.Dash(__name__,
|
|
external_stylesheets=['https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css'])
|
|
|
|
# Setup layout and callbacks
|
|
self._setup_layout()
|
|
self._setup_callbacks()
|
|
self._start_real_time_streaming()
|
|
|
|
logger.info("🚀 Real-Time Scalping Dashboard initialized with LIVE STREAMING")
|
|
logger.info("📡 WebSocket price streaming enabled")
|
|
logger.info(f"🌍 Timezone: {self.timezone}")
|
|
|
|
def _setup_layout(self):
|
|
"""Setup the ultra-fast real-time dashboard layout"""
|
|
self.app.layout = html.Div([
|
|
# Header with live metrics
|
|
html.Div([
|
|
html.H1("🚀 REAL-TIME SCALPING DASHBOARD - 500x LEVERAGE - LIVE STREAMING",
|
|
className="text-center mb-4 text-white"),
|
|
html.P(f"🌍 Sofia Time Zone | 📡 Live WebSocket Streaming | ⚡ 100ms Updates",
|
|
className="text-center text-info"),
|
|
|
|
# Live metrics row
|
|
html.Div([
|
|
html.Div([
|
|
html.H3(id="live-pnl", className="text-success"),
|
|
html.P("Total P&L", className="text-white")
|
|
], className="col-md-2 text-center"),
|
|
|
|
html.Div([
|
|
html.H3(id="win-rate", className="text-info"),
|
|
html.P("Win Rate", className="text-white")
|
|
], className="col-md-2 text-center"),
|
|
|
|
html.Div([
|
|
html.H3(id="total-trades", className="text-primary"),
|
|
html.P("Total Trades", className="text-white")
|
|
], className="col-md-2 text-center"),
|
|
|
|
html.Div([
|
|
html.H3(id="last-action", className="text-warning"),
|
|
html.P("Last Action", className="text-white")
|
|
], className="col-md-2 text-center"),
|
|
|
|
html.Div([
|
|
html.H3(id="eth-price", className="text-success"),
|
|
html.P("ETH/USDT LIVE", className="text-white")
|
|
], className="col-md-2 text-center"),
|
|
|
|
html.Div([
|
|
html.H3(id="btc-price", className="text-success"),
|
|
html.P("BTC/USDT LIVE", className="text-white")
|
|
], className="col-md-2 text-center")
|
|
], className="row mb-4")
|
|
], className="bg-dark p-3 mb-3"),
|
|
|
|
# Main 1s ETH/USDT chart (full width) - REAL-TIME
|
|
html.Div([
|
|
html.H4("📈 ETH/USDT 1s Real-Time Chart (Live WebSocket Feed)",
|
|
className="text-center mb-3"),
|
|
dcc.Graph(id="main-eth-1s-chart", style={"height": "600px"})
|
|
], className="mb-4"),
|
|
|
|
# Row of 4 small charts - ALL REAL-TIME
|
|
html.Div([
|
|
html.Div([
|
|
html.H6("ETH/USDT 1m LIVE", className="text-center"),
|
|
dcc.Graph(id="eth-1m-chart", style={"height": "300px"})
|
|
], className="col-md-3"),
|
|
|
|
html.Div([
|
|
html.H6("ETH/USDT 1h LIVE", className="text-center"),
|
|
dcc.Graph(id="eth-1h-chart", style={"height": "300px"})
|
|
], className="col-md-3"),
|
|
|
|
html.Div([
|
|
html.H6("ETH/USDT 1d LIVE", className="text-center"),
|
|
dcc.Graph(id="eth-1d-chart", style={"height": "300px"})
|
|
], className="col-md-3"),
|
|
|
|
html.Div([
|
|
html.H6("BTC/USDT 1s LIVE", className="text-center"),
|
|
dcc.Graph(id="btc-1s-chart", style={"height": "300px"})
|
|
], className="col-md-3")
|
|
], className="row mb-4"),
|
|
|
|
# Live actions log
|
|
html.Div([
|
|
html.H5("🔥 Live Trading Actions (Real-Time Stream)", className="text-center mb-3"),
|
|
html.Div(id="actions-log")
|
|
], className="mb-4"),
|
|
|
|
# Ultra-fast refresh for real-time updates (100ms)
|
|
dcc.Interval(
|
|
id='ultra-fast-interval',
|
|
interval=100, # 100ms for ultra-low latency
|
|
n_intervals=0
|
|
)
|
|
], className="container-fluid bg-dark")
|
|
|
|
def _setup_callbacks(self):
|
|
"""Setup ultra-fast callbacks with real-time streaming data"""
|
|
|
|
@self.app.callback(
|
|
[
|
|
Output('live-pnl', 'children'),
|
|
Output('win-rate', 'children'),
|
|
Output('total-trades', 'children'),
|
|
Output('last-action', 'children'),
|
|
Output('eth-price', 'children'),
|
|
Output('btc-price', 'children'),
|
|
Output('main-eth-1s-chart', 'figure'),
|
|
Output('eth-1m-chart', 'figure'),
|
|
Output('eth-1h-chart', 'figure'),
|
|
Output('eth-1d-chart', 'figure'),
|
|
Output('btc-1s-chart', 'figure'),
|
|
Output('actions-log', 'children')
|
|
],
|
|
[Input('ultra-fast-interval', 'n_intervals')]
|
|
)
|
|
def update_real_time_dashboard(n_intervals):
|
|
"""Update all components with real-time streaming data"""
|
|
try:
|
|
with self.data_lock:
|
|
# Update metrics
|
|
pnl = f"${self.scalping_metrics['total_pnl']:+.2f}"
|
|
win_rate = f"{self.scalping_metrics['win_rate']*100:.1f}%"
|
|
total_trades = str(self.scalping_metrics['total_trades'])
|
|
last_action = self.scalping_metrics['last_action'] or "⏳ WAITING"
|
|
|
|
# Live prices from WebSocket stream
|
|
eth_price = f"${self.live_prices['ETH/USDT']:.2f}" if self.live_prices['ETH/USDT'] > 0 else "🔄 Loading..."
|
|
btc_price = f"${self.live_prices['BTC/USDT']:.2f}" if self.live_prices['BTC/USDT'] > 0 else "🔄 Loading..."
|
|
|
|
# Refresh chart data every 10 intervals (1 second)
|
|
if n_intervals % 10 == 0:
|
|
self._refresh_live_data()
|
|
|
|
# Create real-time charts
|
|
main_eth_chart = self._create_live_chart('ETH/USDT', '1s', main_chart=True)
|
|
eth_1m_chart = self._create_live_chart('ETH/USDT', '1m')
|
|
eth_1h_chart = self._create_live_chart('ETH/USDT', '1h')
|
|
eth_1d_chart = self._create_live_chart('ETH/USDT', '1d')
|
|
btc_1s_chart = self._create_live_chart('BTC/USDT', '1s')
|
|
|
|
# Live actions log
|
|
actions_log = self._create_live_actions_log()
|
|
|
|
return (
|
|
pnl, win_rate, total_trades, last_action, eth_price, btc_price,
|
|
main_eth_chart, eth_1m_chart, eth_1h_chart, eth_1d_chart, btc_1s_chart,
|
|
actions_log
|
|
)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in real-time update: {e}")
|
|
return (
|
|
"$0.00", "0%", "0", "ERROR", "🔄 Loading...", "🔄 Loading...",
|
|
{}, {}, {}, {}, {}, "🔄 Loading real-time data..."
|
|
)
|
|
|
|
def _start_real_time_streaming(self):
|
|
"""Start WebSocket streaming for real-time price updates"""
|
|
logger.info("🚀 Starting real-time WebSocket price streaming...")
|
|
self.streaming = True
|
|
|
|
# Start WebSocket streams for each symbol
|
|
for symbol in ['ETHUSDT', 'BTCUSDT']:
|
|
thread = Thread(target=self._websocket_price_stream, args=(symbol,), daemon=True)
|
|
thread.start()
|
|
self.websocket_threads.append(thread)
|
|
|
|
logger.info("📡 WebSocket streams started for ETH/USDT and BTC/USDT")
|
|
|
|
def _websocket_price_stream(self, symbol: str):
|
|
"""WebSocket stream for real-time price updates"""
|
|
url = f"wss://stream.binance.com:9443/ws/{symbol.lower()}@ticker"
|
|
|
|
while self.streaming:
|
|
try:
|
|
async def stream_prices():
|
|
async with websockets.connect(url) as websocket:
|
|
logger.info(f"📡 WebSocket connected for {symbol}")
|
|
async for message in websocket:
|
|
if not self.streaming:
|
|
break
|
|
|
|
try:
|
|
data = json.loads(message)
|
|
price = float(data.get('c', 0))
|
|
|
|
# Update live prices
|
|
with self.data_lock:
|
|
formatted_symbol = f"{symbol[:3]}/{symbol[3:]}"
|
|
self.live_prices[formatted_symbol] = price
|
|
|
|
logger.debug(f"💰 {formatted_symbol}: ${price:.2f}")
|
|
|
|
except Exception as e:
|
|
logger.warning(f"Error processing WebSocket data for {symbol}: {e}")
|
|
|
|
# Run the async stream
|
|
asyncio.new_event_loop().run_until_complete(stream_prices())
|
|
|
|
except Exception as e:
|
|
logger.error(f"WebSocket error for {symbol}: {e}")
|
|
if self.streaming:
|
|
logger.info(f"🔄 Reconnecting WebSocket for {symbol} in 5 seconds...")
|
|
time.sleep(5)
|
|
|
|
def _refresh_live_data(self):
|
|
"""Refresh chart data with fresh API calls (NO CACHING)"""
|
|
try:
|
|
logger.info("🔄 Fetching fresh market data (NO CACHE)...")
|
|
|
|
# Force fresh API calls for all timeframes
|
|
for symbol, timeframes in self.chart_data.items():
|
|
for timeframe in timeframes:
|
|
try:
|
|
# FORCE fresh data - explicitly set refresh=True
|
|
fresh_data = self._fetch_fresh_candles(symbol, timeframe, limit=200)
|
|
|
|
if fresh_data is not None and not fresh_data.empty:
|
|
with self.data_lock:
|
|
self.chart_data[symbol][timeframe] = fresh_data
|
|
logger.debug(f"✅ Fresh data loaded: {symbol} {timeframe} - {len(fresh_data)} candles")
|
|
|
|
except Exception as e:
|
|
logger.warning(f"Error fetching fresh data for {symbol} {timeframe}: {e}")
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in live data refresh: {e}")
|
|
|
|
def _fetch_fresh_candles(self, symbol: str, timeframe: str, limit: int = 200) -> pd.DataFrame:
|
|
"""Fetch fresh candles directly from Binance API (bypass all caching)"""
|
|
try:
|
|
# Convert symbol format
|
|
binance_symbol = symbol.replace('/', '').upper()
|
|
|
|
# Convert timeframe
|
|
timeframe_map = {
|
|
'1s': '1s', '1m': '1m', '1h': '1h', '1d': '1d'
|
|
}
|
|
binance_timeframe = timeframe_map.get(timeframe, '1m')
|
|
|
|
# Direct API call to Binance
|
|
url = "https://api.binance.com/api/v3/klines"
|
|
params = {
|
|
'symbol': binance_symbol,
|
|
'interval': binance_timeframe,
|
|
'limit': limit
|
|
}
|
|
|
|
response = requests.get(url, params=params, timeout=5)
|
|
response.raise_for_status()
|
|
|
|
data = response.json()
|
|
|
|
# Convert to DataFrame
|
|
df = pd.DataFrame(data, columns=[
|
|
'timestamp', 'open', 'high', 'low', 'close', 'volume',
|
|
'close_time', 'quote_volume', 'trades', 'taker_buy_base',
|
|
'taker_buy_quote', 'ignore'
|
|
])
|
|
|
|
# Process columns with Sofia timezone
|
|
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms').dt.tz_localize('UTC').dt.tz_convert(self.timezone)
|
|
for col in ['open', 'high', 'low', 'close', 'volume']:
|
|
df[col] = df[col].astype(float)
|
|
|
|
# Keep only OHLCV columns
|
|
df = df[['timestamp', 'open', 'high', 'low', 'close', 'volume']]
|
|
df = df.sort_values('timestamp').reset_index(drop=True)
|
|
|
|
logger.debug(f"📊 Fresh API data: {symbol} {timeframe} - {len(df)} candles")
|
|
return df
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error fetching fresh candles from API: {e}")
|
|
return pd.DataFrame()
|
|
|
|
def _create_live_chart(self, symbol: str, timeframe: str, main_chart: bool = False):
|
|
"""Create charts with real-time streaming data"""
|
|
try:
|
|
with self.data_lock:
|
|
data = self.chart_data[symbol][timeframe]
|
|
|
|
if data.empty:
|
|
# Return loading chart
|
|
fig = go.Figure()
|
|
fig.add_annotation(
|
|
text=f"🔄 Loading real-time data for {symbol} {timeframe}...",
|
|
xref="paper", yref="paper",
|
|
x=0.5, y=0.5, showarrow=False,
|
|
font=dict(size=16, color="#00ff88")
|
|
)
|
|
fig.update_layout(
|
|
title=f"📡 {symbol} {timeframe} - Live Stream",
|
|
template="plotly_dark",
|
|
height=600 if main_chart else 300,
|
|
paper_bgcolor='#1e1e1e',
|
|
plot_bgcolor='#1e1e1e'
|
|
)
|
|
return fig
|
|
|
|
# Create real-time chart
|
|
fig = go.Figure()
|
|
|
|
if main_chart:
|
|
# Main chart with candlesticks, volume, and live price
|
|
fig.add_trace(go.Candlestick(
|
|
x=data['timestamp'],
|
|
open=data['open'],
|
|
high=data['high'],
|
|
low=data['low'],
|
|
close=data['close'],
|
|
name=f"{symbol} {timeframe}",
|
|
increasing_line_color='#00ff88',
|
|
decreasing_line_color='#ff4444'
|
|
))
|
|
|
|
# Volume subplot
|
|
fig.add_trace(go.Bar(
|
|
x=data['timestamp'],
|
|
y=data['volume'],
|
|
name="Volume",
|
|
yaxis='y2',
|
|
opacity=0.4,
|
|
marker_color='#4CAF50'
|
|
))
|
|
|
|
# Current live price line
|
|
current_price = self.live_prices.get(symbol, data['close'].iloc[-1] if not data.empty else 0)
|
|
if current_price > 0:
|
|
fig.add_hline(
|
|
y=current_price,
|
|
line_dash="dot",
|
|
line_color="#FFD700",
|
|
line_width=2,
|
|
annotation_text=f"LIVE: ${current_price:.2f}",
|
|
annotation_position="right"
|
|
)
|
|
|
|
# Sofia time in title
|
|
sofia_time = datetime.now(self.timezone).strftime("%H:%M:%S %Z")
|
|
fig.update_layout(
|
|
title=f"📈 {symbol} {timeframe} LIVE | Sofia Time: {sofia_time} | Current: ${current_price:.2f}",
|
|
yaxis_title="Price (USDT)",
|
|
yaxis2=dict(title="Volume", overlaying='y', side='right'),
|
|
template="plotly_dark",
|
|
showlegend=False,
|
|
height=600,
|
|
paper_bgcolor='#1e1e1e',
|
|
plot_bgcolor='#1e1e1e'
|
|
)
|
|
|
|
else:
|
|
# Small chart - line chart with live updates
|
|
fig.add_trace(go.Scatter(
|
|
x=data['timestamp'],
|
|
y=data['close'],
|
|
mode='lines',
|
|
name=f"{symbol} {timeframe}",
|
|
line=dict(color='#00ff88', width=2)
|
|
))
|
|
|
|
# Live price point
|
|
current_price = self.live_prices.get(symbol, data['close'].iloc[-1] if not data.empty else 0)
|
|
if current_price > 0:
|
|
fig.add_trace(go.Scatter(
|
|
x=[data['timestamp'].iloc[-1]] if not data.empty else [datetime.now(self.timezone)],
|
|
y=[current_price],
|
|
mode='markers',
|
|
marker=dict(color='#FFD700', size=8),
|
|
name="Live Price"
|
|
))
|
|
|
|
fig.update_layout(
|
|
template="plotly_dark",
|
|
showlegend=False,
|
|
margin=dict(l=10, r=10, t=40, b=10),
|
|
height=300,
|
|
title=f"📊 {symbol} {timeframe} | ${current_price:.2f}",
|
|
paper_bgcolor='#1e1e1e',
|
|
plot_bgcolor='#1e1e1e'
|
|
)
|
|
|
|
return fig
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error creating live chart for {symbol} {timeframe}: {e}")
|
|
# Return error chart
|
|
fig = go.Figure()
|
|
fig.add_annotation(
|
|
text=f"❌ Error loading {symbol} {timeframe}",
|
|
xref="paper", yref="paper",
|
|
x=0.5, y=0.5, showarrow=False,
|
|
font=dict(size=14, color="#ff4444")
|
|
)
|
|
fig.update_layout(
|
|
template="plotly_dark",
|
|
height=600 if main_chart else 300,
|
|
paper_bgcolor='#1e1e1e',
|
|
plot_bgcolor='#1e1e1e'
|
|
)
|
|
return fig
|
|
|
|
def _create_live_actions_log(self):
|
|
"""Create live trading actions log"""
|
|
if not self.recent_decisions:
|
|
return html.P("⏳ Waiting for live trading signals from real-time stream...",
|
|
className="text-muted text-center")
|
|
|
|
log_items = []
|
|
for action in self.recent_decisions[-5:]:
|
|
sofia_time = action.timestamp.astimezone(self.timezone).strftime("%H:%M:%S")
|
|
log_items.append(
|
|
html.P(
|
|
f"🔥 {sofia_time} | {action.action} {action.symbol} @ ${action.price:.2f} "
|
|
f"(Confidence: {action.confidence:.1%}) | 📡 LIVE STREAM",
|
|
className="text-center mb-1 text-light"
|
|
)
|
|
)
|
|
|
|
return html.Div(log_items)
|
|
|
|
def add_trading_decision(self, decision: TradingAction):
|
|
"""Add trading decision with Sofia timezone"""
|
|
decision.timestamp = decision.timestamp.astimezone(self.timezone)
|
|
self.recent_decisions.append(decision)
|
|
|
|
if len(self.recent_decisions) > 50:
|
|
self.recent_decisions.pop(0)
|
|
|
|
self.scalping_metrics['total_trades'] += 1
|
|
self.scalping_metrics['last_action'] = f"{decision.action} {decision.symbol}"
|
|
|
|
sofia_time = decision.timestamp.strftime("%H:%M:%S %Z")
|
|
logger.info(f"🔥 {sofia_time} | Live trading decision: {decision.action} {decision.symbol} @ ${decision.price:.2f}")
|
|
|
|
def stop_streaming(self):
|
|
"""Stop all WebSocket streams"""
|
|
logger.info("🛑 Stopping real-time WebSocket streams...")
|
|
self.streaming = False
|
|
|
|
for thread in self.websocket_threads:
|
|
if thread.is_alive():
|
|
thread.join(timeout=2)
|
|
|
|
logger.info("📡 WebSocket streams stopped")
|
|
|
|
def run(self, host: str = '127.0.0.1', port: int = 8051, debug: bool = False):
|
|
"""Run the real-time dashboard"""
|
|
try:
|
|
logger.info(f"🚀 Starting Real-Time Scalping Dashboard at http://{host}:{port}")
|
|
logger.info("📡 Features:")
|
|
logger.info(" • WebSocket price streaming (100ms updates)")
|
|
logger.info(" • NO CACHED DATA - Always fresh API calls")
|
|
logger.info(f" • Sofia timezone: {self.timezone}")
|
|
logger.info(" • Ultra-low latency real-time charts")
|
|
logger.info(" • Live P&L and trading metrics")
|
|
|
|
self.app.run(host=host, port=port, debug=debug)
|
|
|
|
except KeyboardInterrupt:
|
|
logger.info("👋 Shutting down real-time dashboard...")
|
|
finally:
|
|
self.stop_streaming()
|
|
|
|
def create_scalping_dashboard(data_provider=None, orchestrator=None):
|
|
"""Create real-time dashboard instance"""
|
|
return RealTimeScalpingDashboard(data_provider, orchestrator)
|
|
|
|
# For backward compatibility
|
|
ScalpingDashboard = RealTimeScalpingDashboard |