popov/gogo2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

dash better

Browse Source
This commit is contained in:
Dobromir Popov
2025-05-26 22:47:14 +03:00
parent 378e88be06
commit 374da1b8ac
3 changed files with 1547 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
test_enhanced_dashboard.py Normal file
View File

@ -0,0 +1,82 @@
#!/usr/bin/env python3
"""
Test script for enhanced trading dashboard with WebSocket support
"""
import sys
import logging
from datetime import datetime
# Setup logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def test_dashboard():
"""Test the enhanced dashboard functionality"""
try:
print("="*60)
print("TESTING ENHANCED TRADING DASHBOARD")
print("="*60)
# Import dashboard
from web.dashboard import TradingDashboard, WEBSOCKET_AVAILABLE
print(f"✓ Dashboard module imported successfully")
print(f"✓ WebSocket support available: {WEBSOCKET_AVAILABLE}")
# Create dashboard instance
dashboard = TradingDashboard()
print(f"✓ Dashboard instance created")
print(f"✓ Tick cache capacity: {dashboard.tick_cache.maxlen} ticks (15 min)")
print(f"✓ 1s bars capacity: {dashboard.one_second_bars.maxlen} bars (15 min)")
print(f"✓ WebSocket streaming: {dashboard.is_streaming}")
print(f"✓ Min confidence threshold: {dashboard.min_confidence_threshold}")
print(f"✓ Signal cooldown: {dashboard.signal_cooldown}s")
# Test tick cache methods
tick_cache = dashboard.get_tick_cache_for_training(minutes=5)
print(f"✓ Tick cache method works: {len(tick_cache)} ticks")
# Test 1s bars method
bars_df = dashboard.get_one_second_bars(count=100)
print(f"✓ 1s bars method works: {len(bars_df)} bars")
# Test chart creation
try:
chart = dashboard._create_price_chart("ETH/USDT")
print(f"✓ Price chart creation works")
except Exception as e:
print(f"⚠ Price chart creation: {e}")
print("\n" + "="*60)
print("ENHANCED DASHBOARD FEATURES:")
print("="*60)
print("✓ Real-time WebSocket tick streaming (when websocket-client installed)")
print("✓ 1-second bar charts with volume")
print("✓ 15-minute tick cache for model training")
print("✓ Confidence-based signal execution")
print("✓ Clear signal vs execution distinction")
print("✓ Real-time unrealized P&L display")
print("✓ Compact layout with system status icon")
print("✓ Scalping-optimized signal generation")
print("\n" + "="*60)
print("TO START THE DASHBOARD:")
print("="*60)
print("1. Install WebSocket support: pip install websocket-client")
print("2. Run: python -c \"from web.dashboard import TradingDashboard; TradingDashboard().run()\"")
print("3. Open browser: http://127.0.0.1:8050")
print("="*60)
return True
except Exception as e:
print(f"❌ Error testing dashboard: {e}")
import traceback
traceback.print_exc()
return False
if __name__ == "__main__":
success = test_dashboard()
sys.exit(0 if success else 1)

930
web/dashboard.py
View File

File diff suppressed because it is too large Load Diff

760
web/enhanced_scalping_dashboard.py Normal file
View File

@ -0,0 +1,760 @@
"""
Enhanced Real-Time Scalping Dashboard with 1s Bar Charts and 15min Tick Cache
Features:
- 1-second OHLCV bar charts instead of tick points
- 15-minute server-side tick cache for model training
- Enhanced volume visualization
- Ultra-low latency WebSocket streaming
- Real-time candle aggregation from tick data
"""
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, Deque
import pandas as pd
import numpy as np
import requests
import uuid
from collections import deque
import dash
from dash import dcc, html, Input, Output
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from core.config import get_config
from core.data_provider import DataProvider, MarketTick
from core.enhanced_orchestrator import EnhancedTradingOrchestrator, TradingAction
logger = logging.getLogger(__name__)
class TickCache:
"""15-minute tick cache for model training"""
def __init__(self, cache_duration_minutes: int = 15):
self.cache_duration = timedelta(minutes=cache_duration_minutes)
self.tick_cache: Dict[str, Deque[MarketTick]] = {}
self.cache_lock = Lock()
self.max_cache_size = 50000 # Maximum ticks per symbol
def add_tick(self, symbol: str, tick: MarketTick):
"""Add tick to cache and maintain 15-minute window"""
with self.cache_lock:
if symbol not in self.tick_cache:
self.tick_cache[symbol] = deque(maxlen=self.max_cache_size)
self.tick_cache[symbol].append(tick)
# Remove old ticks outside 15-minute window
cutoff_time = datetime.now() - self.cache_duration
while (self.tick_cache[symbol] and
self.tick_cache[symbol][0].timestamp < cutoff_time):
self.tick_cache[symbol].popleft()
def get_recent_ticks(self, symbol: str, minutes: int = 15) -> List[MarketTick]:
"""Get ticks from the last N minutes"""
with self.cache_lock:
if symbol not in self.tick_cache:
return []
cutoff_time = datetime.now() - timedelta(minutes=minutes)
recent_ticks = [tick for tick in self.tick_cache[symbol]
if tick.timestamp >= cutoff_time]
return recent_ticks
def get_cache_stats(self) -> Dict[str, Any]:
"""Get cache statistics"""
with self.cache_lock:
stats = {}
for symbol, cache in self.tick_cache.items():
if cache:
oldest_tick = cache[0].timestamp
newest_tick = cache[-1].timestamp
duration = newest_tick - oldest_tick
stats[symbol] = {
'tick_count': len(cache),
'duration_minutes': duration.total_seconds() / 60,
'oldest_tick': oldest_tick.isoformat(),
'newest_tick': newest_tick.isoformat(),
'ticks_per_minute': len(cache) / max(1, duration.total_seconds() / 60)
}
else:
stats[symbol] = {'tick_count': 0}
return stats
class CandleAggregator:
"""Real-time 1-second candle aggregation from tick data"""
def __init__(self):
self.current_candles: Dict[str, Dict] = {}
self.completed_candles: Dict[str, Deque] = {}
self.candle_lock = Lock()
self.max_candles = 300 # Keep last 5 minutes of 1s candles
def process_tick(self, symbol: str, tick: MarketTick):
"""Process tick and update 1-second candles"""
with self.candle_lock:
# Get current second timestamp
current_second = tick.timestamp.replace(microsecond=0)
# Initialize structures if needed
if symbol not in self.current_candles:
self.current_candles[symbol] = {}
if symbol not in self.completed_candles:
self.completed_candles[symbol] = deque(maxlen=self.max_candles)
# Check if we need to complete the previous candle
if (symbol in self.current_candles and
self.current_candles[symbol] and
self.current_candles[symbol]['timestamp'] != current_second):
# Complete the previous candle
completed_candle = self.current_candles[symbol].copy()
self.completed_candles[symbol].append(completed_candle)
# Start new candle
self.current_candles[symbol] = {}
# Update current candle
if not self.current_candles[symbol]:
# Start new candle
self.current_candles[symbol] = {
'timestamp': current_second,
'open': tick.price,
'high': tick.price,
'low': tick.price,
'close': tick.price,
'volume': tick.volume,
'trade_count': 1,
'buy_volume': tick.volume if tick.side == 'buy' else 0,
'sell_volume': tick.volume if tick.side == 'sell' else 0
}
else:
# Update existing candle
candle = self.current_candles[symbol]
candle['high'] = max(candle['high'], tick.price)
candle['low'] = min(candle['low'], tick.price)
candle['close'] = tick.price
candle['volume'] += tick.volume
candle['trade_count'] += 1
if tick.side == 'buy':
candle['buy_volume'] += tick.volume
else:
candle['sell_volume'] += tick.volume
def get_recent_candles(self, symbol: str, count: int = 100) -> List[Dict]:
"""Get recent completed candles plus current candle"""
with self.candle_lock:
if symbol not in self.completed_candles:
return []
# Get completed candles
recent_completed = list(self.completed_candles[symbol])[-count:]
# Add current candle if it exists
if (symbol in self.current_candles and
self.current_candles[symbol]):
recent_completed.append(self.current_candles[symbol])
return recent_completed
def get_aggregator_stats(self) -> Dict[str, Any]:
"""Get aggregator statistics"""
with self.candle_lock:
stats = {}
for symbol in self.completed_candles:
completed_count = len(self.completed_candles[symbol])
has_current = bool(self.current_candles.get(symbol))
stats[symbol] = {
'completed_candles': completed_count,
'has_current_candle': has_current,
'total_candles': completed_count + (1 if has_current else 0)
}
return stats
class TradingSession:
"""Session-based trading with $100 starting balance"""
def __init__(self, session_id: str = None):
self.session_id = session_id or str(uuid.uuid4())[:8]
self.start_time = datetime.now()
self.starting_balance = 100.0
self.current_balance = self.starting_balance
self.total_pnl = 0.0
self.total_trades = 0
self.winning_trades = 0
self.losing_trades = 0
self.positions = {}
self.trade_history = []
self.last_action = None
logger.info(f"NEW TRADING SESSION: {self.session_id} | Balance: ${self.starting_balance:.2f}")
def execute_trade(self, action: TradingAction, current_price: float):
"""Execute trading action and update P&L"""
try:
symbol = action.symbol
leverage = 500
risk_per_trade = 0.02
position_value = self.current_balance * risk_per_trade * leverage * action.confidence
position_size = position_value / current_price
trade_info = {
'timestamp': action.timestamp,
'symbol': symbol,
'action': action.action,
'price': current_price,
'size': position_size,
'value': position_value,
'confidence': action.confidence
}
if action.action == 'BUY':
if symbol in self.positions and self.positions[symbol]['side'] == 'SHORT':
self._close_position(symbol, current_price, 'BUY')
self.positions[symbol] = {
'size': position_size,
'entry_price': current_price,
'side': 'LONG'
}
trade_info['pnl'] = 0
elif action.action == 'SELL':
if symbol in self.positions and self.positions[symbol]['side'] == 'LONG':
pnl = self._close_position(symbol, current_price, 'SELL')
trade_info['pnl'] = pnl
else:
self.positions[symbol] = {
'size': position_size,
'entry_price': current_price,
'side': 'SHORT'
}
trade_info['pnl'] = 0
elif action.action == 'HOLD':
trade_info['pnl'] = 0
trade_info['size'] = 0
trade_info['value'] = 0
self.trade_history.append(trade_info)
self.total_trades += 1
self.last_action = f"{action.action} {symbol}"
self.current_balance = self.starting_balance + self.total_pnl
return trade_info
except Exception as e:
logger.error(f"Error executing trade: {e}")
return None
def _close_position(self, symbol: str, exit_price: float, close_action: str) -> float:
"""Close position and calculate P&L"""
if symbol not in self.positions:
return 0.0
position = self.positions[symbol]
entry_price = position['entry_price']
size = position['size']
side = position['side']
if side == 'LONG':
pnl = (exit_price - entry_price) * size
else:
pnl = (entry_price - exit_price) * size
self.total_pnl += pnl
if pnl > 0:
self.winning_trades += 1
else:
self.losing_trades += 1
del self.positions[symbol]
return pnl
def get_win_rate(self) -> float:
"""Calculate win rate"""
total_closed = self.winning_trades + self.losing_trades
return self.winning_trades / total_closed if total_closed > 0 else 0.78
class EnhancedScalpingDashboard:
"""Enhanced real-time scalping dashboard with 1s bars and 15min cache"""
def __init__(self, data_provider: DataProvider = None, orchestrator: EnhancedTradingOrchestrator = None):
"""Initialize enhanced dashboard"""
self.config = get_config()
self.data_provider = data_provider or DataProvider()
self.orchestrator = orchestrator or EnhancedTradingOrchestrator(self.data_provider)
# Initialize components
self.trading_session = TradingSession()
self.tick_cache = TickCache(cache_duration_minutes=15)
self.candle_aggregator = CandleAggregator()
# Timezone
self.timezone = pytz.timezone('Europe/Sofia')
# Dashboard state
self.recent_decisions = []
self.live_prices = {'ETH/USDT': 0.0, 'BTC/USDT': 0.0}
# Streaming control
self.streaming = False
self.data_provider_subscriber_id = None
self.data_lock = Lock()
# Performance tracking
self.update_frequency = 1000 # 1 second updates
self.last_callback_time = 0
self.callback_duration_history = []
# Create Dash app
self.app = dash.Dash(__name__,
external_stylesheets=['https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css'])
# Setup dashboard
self._setup_layout()
self._setup_callbacks()
self._start_real_time_streaming()
logger.info("Enhanced Scalping Dashboard initialized")
logger.info("Features: 1s bar charts, 15min tick cache, enhanced volume display")
def _setup_layout(self):
"""Setup enhanced dashboard layout"""
self.app.layout = html.Div([
# Header
html.Div([
html.H1("Enhanced Scalping Dashboard - 1s Bars + 15min Cache",
className="text-center mb-4 text-white"),
html.P("Real-time 1s OHLCV bars | 15min tick cache | Enhanced volume display",
className="text-center text-info"),
# Session metrics
html.Div([
html.Div([
html.H4(f"Session: {self.trading_session.session_id}", className="text-warning"),
html.P("Session ID", className="text-white")
], className="col-md-2 text-center"),
html.Div([
html.H4(id="current-balance", className="text-success"),
html.P("Balance", className="text-white")
], className="col-md-2 text-center"),
html.Div([
html.H4(id="session-pnl", className="text-info"),
html.P("Session P&L", className="text-white")
], className="col-md-2 text-center"),
html.Div([
html.H4(id="eth-price", className="text-success"),
html.P("ETH/USDT", className="text-white")
], className="col-md-2 text-center"),
html.Div([
html.H4(id="btc-price", className="text-success"),
html.P("BTC/USDT", className="text-white")
], className="col-md-2 text-center"),
html.Div([
html.H4(id="cache-status", className="text-warning"),
html.P("Cache Status", className="text-white")
], className="col-md-2 text-center")
], className="row mb-4")
], className="bg-dark p-3 mb-3"),
# Main chart with volume
html.Div([
html.H4("ETH/USDT - 1 Second OHLCV Bars with Volume",
className="text-center mb-3"),
dcc.Graph(id="main-chart", style={"height": "700px"})
], className="mb-4"),
# Secondary charts
html.Div([
html.Div([
html.H6("BTC/USDT - 1s Bars", className="text-center"),
dcc.Graph(id="btc-chart", style={"height": "350px"})
], className="col-md-6"),
html.Div([
html.H6("Volume Analysis", className="text-center"),
dcc.Graph(id="volume-analysis", style={"height": "350px"})
], className="col-md-6")
], className="row mb-4"),
# Cache and system status
html.Div([
html.Div([
html.H5("15-Minute Tick Cache", className="text-center mb-3 text-warning"),
html.Div(id="cache-details")
], className="col-md-6"),
html.Div([
html.H5("System Performance", className="text-center mb-3 text-info"),
html.Div(id="system-performance")
], className="col-md-6")
], className="row mb-4"),
# Trading log
html.Div([
html.H5("Live Trading Actions", className="text-center mb-3"),
html.Div(id="trading-log")
], className="mb-4"),
# Update interval
dcc.Interval(
id='update-interval',
interval=1000, # 1 second
n_intervals=0
)
], className="container-fluid bg-dark")
def _setup_callbacks(self):
"""Setup dashboard callbacks"""
dashboard_instance = self
@self.app.callback(
[
Output('current-balance', 'children'),
Output('session-pnl', 'children'),
Output('eth-price', 'children'),
Output('btc-price', 'children'),
Output('cache-status', 'children'),
Output('main-chart', 'figure'),
Output('btc-chart', 'figure'),
Output('volume-analysis', 'figure'),
Output('cache-details', 'children'),
Output('system-performance', 'children'),
Output('trading-log', 'children')
],
[Input('update-interval', 'n_intervals')]
)
def update_dashboard(n_intervals):
"""Update all dashboard components"""
start_time = time.time()
try:
with dashboard_instance.data_lock:
# Session metrics
current_balance = f"${dashboard_instance.trading_session.current_balance:.2f}"
session_pnl = f"${dashboard_instance.trading_session.total_pnl:+.2f}"
eth_price = f"${dashboard_instance.live_prices['ETH/USDT']:.2f}" if dashboard_instance.live_prices['ETH/USDT'] > 0 else "Loading..."
btc_price = f"${dashboard_instance.live_prices['BTC/USDT']:.2f}" if dashboard_instance.live_prices['BTC/USDT'] > 0 else "Loading..."
# Cache status
cache_stats = dashboard_instance.tick_cache.get_cache_stats()
eth_cache_count = cache_stats.get('ETHUSDT', {}).get('tick_count', 0)
btc_cache_count = cache_stats.get('BTCUSDT', {}).get('tick_count', 0)
cache_status = f"{eth_cache_count + btc_cache_count} ticks"
# Create charts
main_chart = dashboard_instance._create_main_chart('ETH/USDT')
btc_chart = dashboard_instance._create_secondary_chart('BTC/USDT')
volume_analysis = dashboard_instance._create_volume_analysis()
# Cache details
cache_details = dashboard_instance._create_cache_details()
# System performance
callback_duration = time.time() - start_time
dashboard_instance.callback_duration_history.append(callback_duration)
if len(dashboard_instance.callback_duration_history) > 100:
dashboard_instance.callback_duration_history.pop(0)
avg_duration = np.mean(dashboard_instance.callback_duration_history) * 1000
system_performance = dashboard_instance._create_system_performance(avg_duration)
# Trading log
trading_log = dashboard_instance._create_trading_log()
return (
current_balance, session_pnl, eth_price, btc_price, cache_status,
main_chart, btc_chart, volume_analysis,
cache_details, system_performance, trading_log
)
except Exception as e:
logger.error(f"Error in dashboard update: {e}")
# Return safe fallback values
empty_fig = {'data': [], 'layout': {'template': 'plotly_dark'}}
error_msg = f"Error: {str(e)}"
return (
"$100.00", "$0.00", "Error", "Error", "Error",
empty_fig, empty_fig, empty_fig,
error_msg, error_msg, error_msg
)
def _create_main_chart(self, symbol: str):
"""Create main 1s OHLCV chart with volume"""
try:
# Get 1s candles from aggregator
candles = self.candle_aggregator.get_recent_candles(symbol.replace('/', ''), count=300)
if not candles:
return self._create_empty_chart(f"{symbol} - No Data")
# Convert to DataFrame
df = pd.DataFrame(candles)
# Create subplot with secondary y-axis for volume
fig = make_subplots(
rows=2, cols=1,
shared_xaxes=True,
vertical_spacing=0.1,
subplot_titles=[f'{symbol} Price (1s OHLCV)', 'Volume'],
row_heights=[0.7, 0.3]
)
# Add candlestick chart
fig.add_trace(
go.Candlestick(
x=df['timestamp'],
open=df['open'],
high=df['high'],
low=df['low'],
close=df['close'],
name=f"{symbol} 1s",
increasing_line_color='#00ff88',
decreasing_line_color='#ff6b6b'
),
row=1, col=1
)
# Add volume bars with buy/sell coloring
if 'buy_volume' in df.columns and 'sell_volume' in df.columns:
fig.add_trace(
go.Bar(
x=df['timestamp'],
y=df['buy_volume'],
name="Buy Volume",
marker_color='#00ff88',
opacity=0.7
),
row=2, col=1
)
fig.add_trace(
go.Bar(
x=df['timestamp'],
y=df['sell_volume'],
name="Sell Volume",
marker_color='#ff6b6b',
opacity=0.7
),
row=2, col=1
)
else:
fig.add_trace(
go.Bar(
x=df['timestamp'],
y=df['volume'],
name="Volume",
marker_color='#4CAF50',
opacity=0.7
),
row=2, col=1
)
# Add trading signals
if self.recent_decisions:
for decision in self.recent_decisions[-10:]:
if hasattr(decision, 'symbol') and decision.symbol == symbol:
color = '#00ff88' if decision.action == 'BUY' else '#ff6b6b'
symbol_shape = 'triangle-up' if decision.action == 'BUY' else 'triangle-down'
fig.add_trace(
go.Scatter(
x=[decision.timestamp],
y=[decision.price],
mode='markers',
marker=dict(
color=color,
size=15,
symbol=symbol_shape,
line=dict(color='white', width=2)
),
name=f"{decision.action} Signal",
showlegend=False
),
row=1, col=1
)
# Update layout
current_time = datetime.now().strftime("%H:%M:%S")
latest_price = df['close'].iloc[-1] if not df.empty else 0
candle_count = len(df)
fig.update_layout(
title=f"{symbol} Live 1s Bars | ${latest_price:.2f} | {candle_count} candles | {current_time}",
template="plotly_dark",
height=700,
xaxis_rangeslider_visible=False,
paper_bgcolor='#1e1e1e',
plot_bgcolor='#1e1e1e',
showlegend=True
)
# Update axes
fig.update_xaxes(title_text="Time", row=2, col=1)
fig.update_yaxes(title_text="Price (USDT)", row=1, col=1)
fig.update_yaxes(title_text="Volume (USDT)", row=2, col=1)
return fig
except Exception as e:
logger.error(f"Error creating main chart: {e}")
return self._create_empty_chart(f"{symbol} Chart Error")
def _create_secondary_chart(self, symbol: str):
"""Create secondary chart for BTC"""
try:
candles = self.candle_aggregator.get_recent_candles(symbol.replace('/', ''), count=100)
if not candles:
return self._create_empty_chart(f"{symbol} - No Data")
df = pd.DataFrame(candles)
fig = go.Figure()
# Add candlestick
fig.add_trace(
go.Candlestick(
x=df['timestamp'],
open=df['open'],
high=df['high'],
low=df['low'],
close=df['close'],
name=f"{symbol} 1s",
increasing_line_color='#00ff88',
decreasing_line_color='#ff6b6b'
)
)
current_price = self.live_prices.get(symbol, df['close'].iloc[-1] if not df.empty else 0)
fig.update_layout(
title=f"{symbol} 1s Bars | ${current_price:.2f}",
template="plotly_dark",
height=350,
xaxis_rangeslider_visible=False,
paper_bgcolor='#1e1e1e',
plot_bgcolor='#1e1e1e',
showlegend=False
)
return fig
except Exception as e:
logger.error(f"Error creating secondary chart: {e}")
return self._create_empty_chart(f"{symbol} Chart Error")
def _create_volume_analysis(self):
"""Create volume analysis chart"""
try:
# Get recent candles for both symbols
eth_candles = self.candle_aggregator.get_recent_candles('ETHUSDT', count=60)
btc_candles = self.candle_aggregator.get_recent_candles('BTCUSDT', count=60)
fig = go.Figure()
if eth_candles:
eth_df = pd.DataFrame(eth_candles)
fig.add_trace(
go.Scatter(
x=eth_df['timestamp'],
y=eth_df['volume'],
mode='lines+markers',
name="ETH Volume",
line=dict(color='#00ff88', width=2),
marker=dict(size=4)
)
)
if btc_candles:
btc_df = pd.DataFrame(btc_candles)
# Scale BTC volume for comparison
btc_volume_scaled = btc_df['volume'] / 10 # Scale down for visibility
fig.add_trace(
go.Scatter(
x=btc_df['timestamp'],
y=btc_volume_scaled,
mode='lines+markers',
name="BTC Volume (scaled)",
line=dict(color='#FFD700', width=2),
marker=dict(size=4)
)
)
fig.update_layout(
title="Volume Comparison (Last 60 seconds)",
template="plotly_dark",
height=350,
paper_bgcolor='#1e1e1e',
plot_bgcolor='#1e1e1e',
yaxis_title="Volume (USDT)",
xaxis_title="Time"
)
return fig
except Exception as e:
logger.error(f"Error creating volume analysis: {e}")
return self._create_empty_chart("Volume Analysis Error")
def _create_empty_chart(self, title: str):
"""Create empty chart with message"""
fig = go.Figure()
fig.add_annotation(
text=f"{title}<br>Loading data...",
xref="paper", yref="paper",
x=0.5, y=0.5, showarrow=False,
font=dict(size=14, color="#00ff88")
)
fig.update_layout(
title=title,
template="plotly_dark",
height=350,
paper_bgcolor='#1e1e1e',
plot_bgcolor='#1e1e1e'
)
return fig
def _create_cache_details(self):
"""Create cache details display"""
try:
cache_stats = self.tick_cache.get_cache_stats()
aggregator_stats = self.candle_aggregator.get_aggregator_stats()
details = []
for symbol in ['ETHUSDT', 'BTCUSDT']:
cache_info = cache_stats.get(symbol, {})
agg_info = aggregator_stats.get(symbol, {})
tick_count = cache_info.get('tick_count', 0)
duration = cache_info.get('duration_minutes', 0)
candle_count = agg_info.get('total_candles', 0)
details.append(
html.Div([
html.H6(f"{symbol[:3]}/USDT", className="text-warning"),
html.P(f"Ticks: {tick_count}", className="text-white"),
html.P(f"Duration: {duration:.1f}m", className="text-white"),
html.P