diff --git a/_dev/notes.md b/_dev/notes.md index d3c91d1..f969db5 100644 --- a/_dev/notes.md +++ b/_dev/notes.md @@ -18,8 +18,7 @@ we stopped showing executed trades on the chart. let's add them back update chart every second as well. the list with closed trades is not updated. clear session button does not clear all data. -add buttons for quick manual buy/sell (max 1 lot. sell closes long, buy closes short if already open position exists) - +fix the dash. it still flickers every 10 seconds for a second. update the chart every second. maintain zoom and position of the chart if possible. set default chart to 15 minutes, but allow zoom out to the current 5 hours (keep the data cached) diff --git a/web/dashboard.py b/web/dashboard.py index 7d2b61b..10ae1fe 100644 --- a/web/dashboard.py +++ b/web/dashboard.py @@ -3362,19 +3362,22 @@ class TradingDashboard: [Input('interval-component', 'n_intervals')] ) def update_dashboard(n_intervals): - """OPTIMIZED Update dashboard with smart caching and throttling""" + """ANTI-FLICKER Update dashboard with consistent data and COB integration""" update_start = time.time() try: - # Smart update scheduling - optimized for 1s responsiveness - is_price_update = True # Price updates every interval (1s) - is_chart_update = True # Chart updates every 1s for real-time feel - is_heavy_update = n_intervals % 10 == 0 # Heavy operations every 10s - is_cleanup_update = n_intervals % 60 == 0 # Cleanup every 60s + # CONSISTENT UPDATE STRATEGY - Single data source per cycle to prevent flickering + is_price_update = True # Always update price (1s) + is_chart_update = n_intervals % 2 == 0 # Chart every 2 seconds to reduce load + is_heavy_update = n_intervals % 30 == 0 # Heavy operations every 30s + is_cleanup_update = n_intervals % 300 == 0 # Cleanup every 5 minutes - # Cleanup old data occasionally + # Minimal cleanup to prevent interference if is_cleanup_update: - self._cleanup_old_data() + try: + self._cleanup_old_data() + except: + pass # Don't let cleanup interfere with updates # Fast-path for basic price updates symbol = self.config.symbols[0] if self.config.symbols else "ETH/USDT" @@ -3392,7 +3395,7 @@ class TradingDashboard: try: if hasattr(self, '_last_price_cache'): cache_time, cached_price = self._last_price_cache - if time.time() - cache_time < 30: # Use cache if < 30s old + if time.time() - cache_time < 60: # Use cache if < 60s old (extended) current_price = cached_price data_source = "PRICE_CACHE" @@ -3407,13 +3410,13 @@ class TradingDashboard: except Exception as e: logger.debug(f"Price fetch error: {e}") - # If no real price available, skip most updates + # If no real price available, use cached dashboard state to prevent flickering if not current_price: if hasattr(self, '_last_dashboard_state'): # Return cached dashboard state with error message - state = self._last_dashboard_state + state = list(self._last_dashboard_state) # Create copy state[0] = f"NO DATA [{data_source}] @ {datetime.now().strftime('%H:%M:%S')}" - return state + return tuple(state) else: # Return minimal error state empty_fig = self._create_empty_chart("Error", "No price data available") @@ -3426,7 +3429,7 @@ class TradingDashboard: chart_data = None if hasattr(self, '_cached_signal_data'): cache_time, cached_data = self._cached_signal_data - if time.time() - cache_time < 30: # Use cache if < 30s old + if time.time() - cache_time < 60: # Use cache if < 60s old (extended) chart_data = cached_data if chart_data is None: @@ -3488,24 +3491,48 @@ class TradingDashboard: # MEXC status (simple) mexc_status = "LIVE" if (self.trading_executor and self.trading_executor.trading_enabled and not self.trading_executor.simulation_mode) else "SIM" - # OPTIMIZED CHART - Using new optimized version with trade caching + # ANTI-FLICKER CHART - Smart caching with zoom preservation if is_chart_update: try: - # Always try to create fresh chart for real-time updates - # Only use cache as emergency fallback - price_chart = self._create_price_chart(symbol) + # Check if we need to create a new chart or just update data + needs_new_chart = False - # Cache the successful chart for emergency fallback - if price_chart is not None: - self._cached_price_chart = price_chart - self._cached_chart_data_time = time.time() + if not hasattr(self, '_cached_price_chart') or self._cached_price_chart is None: + needs_new_chart = True + elif hasattr(self, '_cached_chart_data_time'): + # Only recreate chart if data is very old (5 minutes) + if time.time() - self._cached_chart_data_time > 300: + needs_new_chart = True else: - # If chart creation failed, try cached version - if hasattr(self, '_cached_price_chart'): - price_chart = self._cached_price_chart - logger.debug("Using cached chart due to creation failure") + needs_new_chart = True + + if needs_new_chart: + # Create new chart with anti-flicker optimizations + price_chart = self._create_anti_flicker_chart(symbol) + + # Cache the successful chart + if price_chart is not None: + self._cached_price_chart = price_chart + self._cached_chart_data_time = time.time() else: - price_chart = self._create_empty_chart("Chart Loading", "Initializing chart data...") + # If chart creation failed, try cached version or create empty + if hasattr(self, '_cached_price_chart') and self._cached_price_chart is not None: + price_chart = self._cached_price_chart + logger.debug("Using cached chart due to creation failure") + else: + price_chart = self._create_empty_chart("Chart Loading", "Initializing chart data...") + else: + # Use cached chart to prevent flickering + price_chart = self._cached_price_chart + + # Update chart title with current price (minimal update) + try: + if price_chart and current_price: + price_chart.update_layout( + title=f"{symbol} 15M Chart (Default) | ${current_price:.2f} | {data_source} | {update_time}" + ) + except Exception as e: + logger.debug(f"Chart title update error: {e}") except Exception as e: logger.debug(f"Chart error: {e}") @@ -3513,7 +3540,7 @@ class TradingDashboard: price_chart = getattr(self, '_cached_price_chart', self._create_empty_chart("Chart Error", "Chart temporarily unavailable")) else: - # Use cached chart (should not happen since is_chart_update is always True now) + # Use cached chart (fallback) price_chart = getattr(self, '_cached_price_chart', self._create_empty_chart("Loading", "Chart loading...")) @@ -3586,9 +3613,9 @@ class TradingDashboard: # Generate COB 4-column content try: - cob_status_content = self._create_cob_status_content() - eth_cob_content = self._create_symbol_cob_content('ETH/USDT') - btc_cob_content = self._create_symbol_cob_content('BTC/USDT') + cob_status_content = self._create_enhanced_cob_status_content() + eth_cob_content = self._create_detailed_cob_content('ETH/USDT') + btc_cob_content = self._create_detailed_cob_content('BTC/USDT') except Exception as e: logger.warning(f"COB content error: {e}") cob_status_content = [html.P("COB data loading...", className="text-muted")] @@ -3604,8 +3631,17 @@ class TradingDashboard: cnn_monitoring_content, cob_status_content, eth_cob_content, btc_cob_content ) - # Cache the result for emergencies - self._last_dashboard_state = result + # Prepare final dashboard state + dashboard_state = ( + price_text, pnl_text, pnl_class, fees_text, position_text, position_class, + trade_count_text, portfolio_text, mexc_status, price_chart, training_metrics, + decisions_list, session_perf, closed_trades_table, system_status['icon_class'], + system_status['title'], system_status['details'], leverage_text, risk_level, + cnn_monitoring_content, cob_status_content, eth_cob_content, btc_cob_content + ) + + # Cache the dashboard state for fallback + self._last_dashboard_state = dashboard_state # Performance logging update_time_ms = (time.time() - update_start) * 1000 @@ -3843,6 +3879,636 @@ class TradingDashboard: ) return fig + def _create_optimized_chart_with_cob(self, symbol: str, current_price: float, data_source: str, update_time: str) -> go.Figure: + """Create optimized chart with 15-minute default view and COB data integration""" + try: + # Get 15-minute data for default view (but keep 5-hour data cached for zoom-out) + df_15m = self.data_provider.get_historical_data(symbol, '1m', limit=15, refresh=False) + df_5h = None + + # Get WebSocket data for real-time updates + ws_df = None + try: + ws_df = self.get_realtime_tick_data(symbol, limit=100) + if ws_df is not None and not ws_df.empty: + # Aggregate WebSocket ticks to 1-minute bars + ws_1m = self._aggregate_1s_to_1m(ws_df) + if ws_1m is not None and not ws_1m.empty: + # Merge with historical data + if df_15m is not None and not df_15m.empty: + # Combine recent historical with real-time + combined_df = pd.concat([df_15m.iloc[:-2], ws_1m.tail(3)], ignore_index=False) + df_15m = combined_df.tail(15) + except Exception as e: + logger.debug(f"WebSocket data integration error: {e}") + + # Fallback to cached 5-hour data for zoom-out capability + if df_15m is None or df_15m.empty: + df_5h = self.data_provider.get_historical_data(symbol, '1m', limit=300, refresh=False) + if df_5h is not None and not df_5h.empty: + df_15m = df_5h.tail(15) # Use last 15 minutes as default + + if df_15m is None or df_15m.empty: + return self._create_empty_chart("No Data", f"No chart data available for {symbol}") + + # Ensure timezone consistency + df_15m = self._ensure_timezone_consistency(df_15m) + + # Create main candlestick chart + fig = go.Figure() + + # Add candlestick trace + fig.add_trace(go.Candlestick( + x=df_15m.index, + open=df_15m['open'], + high=df_15m['high'], + low=df_15m['low'], + close=df_15m['close'], + name=symbol, + increasing_line_color='#26a69a', + decreasing_line_color='#ef5350', + increasing_fillcolor='rgba(38, 166, 154, 0.3)', + decreasing_fillcolor='rgba(239, 83, 80, 0.3)' + )) + + # Add trade markers + self._add_trade_markers_to_chart(fig, symbol, df_15m) + + # Add Williams pivot points (with error handling) + try: + pivot_points = self._get_williams_pivot_points_for_chart(df_15m) + if pivot_points and len(pivot_points) > 0: + self._add_williams_pivot_points_to_chart_safe(fig, pivot_points) + except Exception as e: + logger.debug(f"Williams pivot points error: {e}") + + # Chart layout with 15-minute default view + fig.update_layout( + title=f"{symbol} - ${current_price:.2f} | 15M Default View | {data_source} @ {update_time}", + template="plotly_dark", + height=400, + showlegend=False, + xaxis=dict( + title="Time", + rangeslider=dict(visible=False), + type="date", + showgrid=True, + gridcolor='rgba(128, 128, 128, 0.2)' + ), + yaxis=dict( + title="Price ($)", + showgrid=True, + gridcolor='rgba(128, 128, 128, 0.2)', + fixedrange=False # Allow zoom + ), + margin=dict(l=10, r=10, t=40, b=10), + dragmode='pan', + font=dict(size=10) + ) + + # Add current price line + if current_price: + fig.add_hline( + y=current_price, + line_dash="dash", + line_color="yellow", + annotation_text=f"${current_price:.2f}", + annotation_position="right" + ) + + return fig + + except Exception as e: + logger.error(f"Error creating optimized chart: {e}") + return self._create_empty_chart("Chart Error", f"Error: {str(e)}") + + def _create_anti_flicker_chart(self, symbol: str) -> go.Figure: + """Create anti-flicker chart with 15-minute default view and zoom preservation""" + try: + # Get comprehensive data for 5 hours (for zoom-out capability) but default to 15 minutes + symbol_clean = symbol.replace('/', '') + + # Try to get WebSocket data first for real-time updates + ws_df = self.get_realtime_tick_data(symbol, limit=2000) + + # Get historical data for full 5-hour context (300 minutes) + df_5h = None + try: + df_5h = self.data_provider.get_historical_data(symbol, '1m', limit=300, refresh=False) + if df_5h is None or df_5h.empty: + df_5h = self.data_provider.get_historical_data(symbol, '1m', limit=300, refresh=True) + + if df_5h is not None and not df_5h.empty: + df_5h = self._ensure_timezone_consistency(df_5h) + logger.debug(f"[ANTI-FLICKER] Got {len(df_5h)} historical 1m bars for {symbol}") + except Exception as e: + logger.warning(f"[ANTI-FLICKER] Error getting historical data: {e}") + + # Combine WebSocket and historical data if both available + if ws_df is not None and not ws_df.empty and df_5h is not None and not df_5h.empty: + try: + # Resample WebSocket data to 1-minute bars + ws_df_1m = ws_df.resample('1min').agg({ + 'open': 'first', + 'high': 'max', + 'low': 'min', + 'close': 'last', + 'volume': 'sum' + }).dropna() + + if not ws_df_1m.empty: + # Merge datasets - WebSocket data is more recent + df_combined = pd.concat([df_5h, ws_df_1m]).drop_duplicates().sort_index() + df_5h = df_combined + logger.debug(f"[ANTI-FLICKER] Combined data: {len(df_5h)} total bars") + except Exception as e: + logger.debug(f"[ANTI-FLICKER] Data combination failed: {e}") + + # Use the best available data + if df_5h is not None and not df_5h.empty: + df = df_5h + data_source = "Historical+WS" if ws_df is not None and not ws_df.empty else "Historical" + elif ws_df is not None and not ws_df.empty: + df = ws_df + data_source = "WebSocket" + else: + return self._create_empty_chart(f"{symbol} Chart", "No data available for chart") + + # Ensure proper DatetimeIndex + if not isinstance(df.index, pd.DatetimeIndex): + try: + df.index = pd.to_datetime(df.index) + df = self._ensure_timezone_consistency(df) + except Exception as e: + logger.warning(f"[ANTI-FLICKER] Index conversion failed: {e}") + df.index = pd.date_range(start=pd.Timestamp.now() - pd.Timedelta(minutes=len(df)), + periods=len(df), freq='1min') + + # Create the chart with anti-flicker optimizations + fig = make_subplots( + rows=2, cols=1, + shared_xaxes=True, + vertical_spacing=0.1, + subplot_titles=(f'{symbol} 15M Chart (Default View)', 'Volume'), + row_heights=[0.7, 0.3] + ) + + # Add price line (smooth line instead of candlesticks for better performance) + fig.add_trace( + go.Scatter( + x=df.index, + y=df['close'], + mode='lines', + name=f"{symbol} Price", + line=dict(color='#00ff88', width=2), + hovertemplate='$%{y:.2f}
%{x}' + ), + row=1, col=1 + ) + + # Add volume bars + fig.add_trace( + go.Bar( + x=df.index, + y=df['volume'] if 'volume' in df.columns else [100] * len(df), + name='Volume', + marker_color='rgba(0, 255, 136, 0.3)', + hovertemplate='Volume: %{y}
%{x}' + ), + row=2, col=1 + ) + + # Add moving averages for trend analysis + if len(df) >= 20: + df_ma = df.copy() + df_ma['sma_20'] = df_ma['close'].rolling(window=20).mean() + fig.add_trace( + go.Scatter( + x=df_ma.index, + y=df_ma['sma_20'], + name='SMA 20', + line=dict(color='#ff1493', width=1), + opacity=0.8 + ), + row=1, col=1 + ) + + # Add trade markers (both signals and closed trades) + self._add_comprehensive_trade_markers(fig, symbol, df) + + # Set default 15-minute view (last 15 minutes of data) + if len(df) > 15: + # Default to last 15 minutes + end_time = df.index[-1] + start_time = end_time - pd.Timedelta(minutes=15) + + fig.update_layout( + xaxis=dict( + range=[start_time, end_time], + type='date' + ) + ) + + # Configure layout with zoom preservation + current_price = df['close'].iloc[-1] if not df.empty else 0 + fig.update_layout( + title=f"{symbol} 15M Chart (Default) | ${current_price:.2f} | {data_source} | {datetime.now().strftime('%H:%M:%S')}", + template="plotly_dark", + height=400, + showlegend=True, + legend=dict( + yanchor="top", + y=0.99, + xanchor="left", + x=0.01, + bgcolor="rgba(0,0,0,0.5)" + ), + hovermode='x unified', + dragmode='pan', + # Preserve zoom and pan settings + uirevision=f"{symbol}_chart_ui" # This preserves zoom/pan state + ) + + # Remove range slider for better performance + fig.update_layout(xaxis_rangeslider_visible=False) + + # Add client-side data management script + fig.add_annotation( + text=f"""""", + showarrow=False, + x=0, y=0, + xref="paper", yref="paper", + font=dict(size=1), + opacity=0 + ) + + return fig + + except Exception as e: + logger.error(f"[ANTI-FLICKER] Error creating chart for {symbol}: {e}") + return self._create_empty_chart(f"{symbol} Chart", f"Chart Error: {str(e)}") + + def _add_trade_markers_to_chart(self, fig, symbol: str, df: pd.DataFrame): + """Add trade markers to chart with anti-flicker optimizations""" + try: + # Get recent decisions for the chart timeframe + if not self.recent_decisions: + return + + # Filter decisions to chart timeframe + chart_start = df.index[0] if not df.empty else datetime.now() - timedelta(hours=5) + chart_end = df.index[-1] if not df.empty else datetime.now() + + filtered_decisions = [ + d for d in self.recent_decisions + if chart_start <= d.get('timestamp', datetime.now()) <= chart_end + ] + + if not filtered_decisions: + return + + # Separate buy and sell signals + buy_signals = [d for d in filtered_decisions if d.get('action') == 'BUY'] + sell_signals = [d for d in filtered_decisions if d.get('action') == 'SELL'] + + # Add BUY markers + if buy_signals: + fig.add_trace( + go.Scatter( + x=[d['timestamp'] for d in buy_signals], + y=[d.get('price', 0) for d in buy_signals], + mode='markers', + marker=dict( + symbol='triangle-up', + size=10, + color='#00e676', + line=dict(color='white', width=1) + ), + name='BUY Signals', + text=[f"BUY @ ${d.get('price', 0):.2f}" for d in buy_signals], + hovertemplate='%{text}
%{x}' + ), + row=1, col=1 + ) + + # Add SELL markers + if sell_signals: + fig.add_trace( + go.Scatter( + x=[d['timestamp'] for d in sell_signals], + y=[d.get('price', 0) for d in sell_signals], + mode='markers', + marker=dict( + symbol='triangle-down', + size=10, + color='#ff5252', + line=dict(color='white', width=1) + ), + name='SELL Signals', + text=[f"SELL @ ${d.get('price', 0):.2f}" for d in sell_signals], + hovertemplate='%{text}
%{x}' + ), + row=1, col=1 + ) + + except Exception as e: + logger.debug(f"[ANTI-FLICKER] Error adding trade markers: {e}") + + def _add_comprehensive_trade_markers(self, fig, symbol: str, df: pd.DataFrame): + """Add comprehensive trade markers including both signals and closed trades""" + try: + # Chart timeframe + chart_start = df.index[0] if not df.empty else datetime.now() - timedelta(hours=5) + chart_end = df.index[-1] if not df.empty else datetime.now() + + # 1. ADD RECENT DECISIONS (BUY/SELL SIGNALS) + if self.recent_decisions: + filtered_decisions = [] + for decision in self.recent_decisions: + if isinstance(decision, dict) and 'timestamp' in decision: + decision_time = decision['timestamp'] + if isinstance(decision_time, datetime): + # Convert to timezone-naive for comparison + if decision_time.tzinfo is not None: + decision_time_local = decision_time.astimezone(self.timezone) + decision_time_naive = decision_time_local.replace(tzinfo=None) + else: + decision_time_naive = decision_time + + # Check if within chart timeframe + chart_start_naive = chart_start.replace(tzinfo=None) if hasattr(chart_start, 'tzinfo') and chart_start.tzinfo else chart_start + chart_end_naive = chart_end.replace(tzinfo=None) if hasattr(chart_end, 'tzinfo') and chart_end.tzinfo else chart_end + + if chart_start_naive <= decision_time_naive <= chart_end_naive: + filtered_decisions.append(decision) + + # Separate executed vs blocked signals + executed_buys = [d for d in filtered_decisions if d.get('action') == 'BUY' and d.get('signal_type') == 'EXECUTED'] + blocked_buys = [d for d in filtered_decisions if d.get('action') == 'BUY' and d.get('signal_type') != 'EXECUTED'] + executed_sells = [d for d in filtered_decisions if d.get('action') == 'SELL' and d.get('signal_type') == 'EXECUTED'] + blocked_sells = [d for d in filtered_decisions if d.get('action') == 'SELL' and d.get('signal_type') != 'EXECUTED'] + + # Add executed BUY signals + if executed_buys: + fig.add_trace( + go.Scatter( + x=[self._to_local_timezone(d['timestamp']) for d in executed_buys], + y=[d.get('price', 0) for d in executed_buys], + mode='markers', + marker=dict( + symbol='triangle-up', + size=12, + color='#00ff88', + line=dict(color='white', width=2) + ), + name='BUY (Executed)', + hovertemplate='BUY EXECUTED
Price: $%{y:.2f}
%{x}' + ), + row=1, col=1 + ) + + # Add blocked BUY signals + if blocked_buys: + fig.add_trace( + go.Scatter( + x=[self._to_local_timezone(d['timestamp']) for d in blocked_buys], + y=[d.get('price', 0) for d in blocked_buys], + mode='markers', + marker=dict( + symbol='triangle-up-open', + size=10, + color='#00ff88', + line=dict(color='#00ff88', width=2) + ), + name='BUY (Blocked)', + hovertemplate='BUY BLOCKED
Price: $%{y:.2f}
%{x}' + ), + row=1, col=1 + ) + + # Add executed SELL signals + if executed_sells: + fig.add_trace( + go.Scatter( + x=[self._to_local_timezone(d['timestamp']) for d in executed_sells], + y=[d.get('price', 0) for d in executed_sells], + mode='markers', + marker=dict( + symbol='triangle-down', + size=12, + color='#ff6b6b', + line=dict(color='white', width=2) + ), + name='SELL (Executed)', + hovertemplate='SELL EXECUTED
Price: $%{y:.2f}
%{x}' + ), + row=1, col=1 + ) + + # Add blocked SELL signals + if blocked_sells: + fig.add_trace( + go.Scatter( + x=[self._to_local_timezone(d['timestamp']) for d in blocked_sells], + y=[d.get('price', 0) for d in blocked_sells], + mode='markers', + marker=dict( + symbol='triangle-down-open', + size=10, + color='#ff6b6b', + line=dict(color='#ff6b6b', width=2) + ), + name='SELL (Blocked)', + hovertemplate='SELL BLOCKED
Price: $%{y:.2f}
%{x}' + ), + row=1, col=1 + ) + + # 2. ADD CLOSED TRADES (ENTRY/EXIT PAIRS WITH CONNECTING LINES) + if self.closed_trades: + chart_trades = [] + for trade in self.closed_trades: + if not isinstance(trade, dict): + continue + + entry_time = trade.get('entry_time') + exit_time = trade.get('exit_time') + + if not entry_time or not exit_time: + continue + + try: + # Convert times for comparison + if isinstance(entry_time, datetime): + if entry_time.tzinfo is None: + entry_time_naive = entry_time + else: + entry_time_naive = entry_time.astimezone(self.timezone).replace(tzinfo=None) + else: + continue + + if isinstance(exit_time, datetime): + if exit_time.tzinfo is None: + exit_time_naive = exit_time + else: + exit_time_naive = exit_time.astimezone(self.timezone).replace(tzinfo=None) + else: + continue + + # Check if trade overlaps with chart timeframe + chart_start_naive = chart_start.replace(tzinfo=None) if hasattr(chart_start, 'tzinfo') and chart_start.tzinfo else chart_start + chart_end_naive = chart_end.replace(tzinfo=None) if hasattr(chart_end, 'tzinfo') and chart_end.tzinfo else chart_end + + if (chart_start_naive <= entry_time_naive <= chart_end_naive) or (chart_start_naive <= exit_time_naive <= chart_end_naive): + chart_trades.append(trade) + except Exception as e: + logger.debug(f"Error processing trade timestamps: {e}") + continue + + # Plot closed trades with profit/loss styling + if chart_trades: + profitable_entries_x, profitable_entries_y = [], [] + profitable_exits_x, profitable_exits_y = [], [] + losing_entries_x, losing_entries_y = [], [] + losing_exits_x, losing_exits_y = [], [] + + for trade in chart_trades: + entry_price = trade.get('entry_price', 0) + exit_price = trade.get('exit_price', 0) + entry_time = trade.get('entry_time') + exit_time = trade.get('exit_time') + net_pnl = trade.get('net_pnl', 0) + + if not all([entry_price, exit_price, entry_time, exit_time]): + continue + + # Convert times to local timezone for display + entry_time_local = self._to_local_timezone(entry_time) + exit_time_local = self._to_local_timezone(exit_time) + + # Add connecting line + line_color = '#00ff88' if net_pnl > 0 else '#ff6b6b' + fig.add_trace( + go.Scatter( + x=[entry_time_local, exit_time_local], + y=[entry_price, exit_price], + mode='lines', + line=dict(color=line_color, width=2, dash='dash'), + name="Trade Path", + showlegend=False, + hoverinfo='skip' + ), + row=1, col=1 + ) + + # Collect trade points by profitability + if net_pnl > 0: + profitable_entries_x.append(entry_time_local) + profitable_entries_y.append(entry_price) + profitable_exits_x.append(exit_time_local) + profitable_exits_y.append(exit_price) + else: + losing_entries_x.append(entry_time_local) + losing_entries_y.append(entry_price) + losing_exits_x.append(exit_time_local) + losing_exits_y.append(exit_price) + + # Add profitable trade entry markers + if profitable_entries_x: + fig.add_trace( + go.Scatter( + x=profitable_entries_x, + y=profitable_entries_y, + mode='markers', + marker=dict( + color='#00ff88', + size=14, + symbol='triangle-up', + line=dict(color='white', width=1) + ), + name="Profitable Entry", + showlegend=True, + hovertemplate="PROFITABLE ENTRY
Price: $%{y:.2f}
%{x}" + ), + row=1, col=1 + ) + + # Add profitable trade exit markers + if profitable_exits_x: + fig.add_trace( + go.Scatter( + x=profitable_exits_x, + y=profitable_exits_y, + mode='markers', + marker=dict( + color='#00ff88', + size=14, + symbol='triangle-down', + line=dict(color='white', width=1) + ), + name="Profitable Exit", + showlegend=True, + hovertemplate="PROFITABLE EXIT
Price: $%{y:.2f}
%{x}" + ), + row=1, col=1 + ) + + # Add losing trade markers (smaller, hollow) + if losing_entries_x: + fig.add_trace( + go.Scatter( + x=losing_entries_x, + y=losing_entries_y, + mode='markers', + marker=dict( + color='#ff6b6b', + size=10, + symbol='triangle-up-open', + line=dict(color='#ff6b6b', width=1) + ), + name="Losing Entry", + showlegend=True, + hovertemplate="LOSING ENTRY
Price: $%{y:.2f}
%{x}" + ), + row=1, col=1 + ) + + if losing_exits_x: + fig.add_trace( + go.Scatter( + x=losing_exits_x, + y=losing_exits_y, + mode='markers', + marker=dict( + color='#ff6b6b', + size=10, + symbol='triangle-down-open', + line=dict(color='#ff6b6b', width=1) + ), + name="Losing Exit", + showlegend=True, + hovertemplate="LOSING EXIT
Price: $%{y:.2f}
%{x}" + ), + row=1, col=1 + ) + + logger.debug(f"[COMPREHENSIVE] Added {len(chart_trades)} closed trades to chart") + + except Exception as e: + logger.debug(f"[COMPREHENSIVE] Error adding trade markers: {e}") + def _create_price_chart(self, symbol: str) -> go.Figure: """Create price chart with volume and Williams pivot points from cached data""" try: @@ -5913,6 +6579,12 @@ class TradingDashboard: self.tick_cache = [] self.max_tick_cache = 2000 # Keep last 2000 1-second ticks for chart + # COB data cache for real-time streaming (multiple updates per second) + self.cob_cache = { + 'ETH/USDT': {'last_update': 0, 'data': None, 'updates_count': 0}, + 'BTC/USDT': {'last_update': 0, 'data': None, 'updates_count': 0} + } + # ETH/USDT primary symbol for scalping symbol = "ethusdt" @@ -5971,6 +6643,9 @@ class TradingDashboard: self.last_ws_update = current_time self.ws_update_count += 1 + # UPDATE COB DATA CACHE - Stream COB data for real-time updates + self._update_cob_cache_from_orchestrator('ETH/USDT') + # Log every 100 updates for monitoring if self.ws_update_count % 100 == 0: cache_size = len(self.tick_cache) if hasattr(self, 'tick_cache') else 0 @@ -6103,6 +6778,93 @@ class TradingDashboard: logger.warning(f"[WS] Error getting tick data for {symbol}: {e}") return None + def _update_cob_cache_from_orchestrator(self, symbol: str): + """Update COB cache from orchestrator for real-time streaming (multiple updates per second)""" + try: + if not hasattr(self.orchestrator, 'cob_integration') or not self.orchestrator.cob_integration: + return + + current_time = time.time() + + # Get COB snapshot from orchestrator + cob_snapshot = None + if hasattr(self.orchestrator.cob_integration, 'get_cob_snapshot'): + cob_snapshot = self.orchestrator.cob_integration.get_cob_snapshot(symbol) + + if cob_snapshot: + # Update cache with timestamp + self.cob_cache[symbol] = { + 'last_update': current_time, + 'data': cob_snapshot, + 'updates_count': self.cob_cache[symbol].get('updates_count', 0) + 1 + } + + # Log periodic updates (every 50 COB updates to avoid spam) + if self.cob_cache[symbol]['updates_count'] % 50 == 0: + logger.debug(f"[COB-WS] {symbol} - Update #{self.cob_cache[symbol]['updates_count']}, " + f"Levels: {len(cob_snapshot.consolidated_bids) + len(cob_snapshot.consolidated_asks)}") + + except Exception as e: + logger.debug(f"[COB-WS] Error updating COB cache for {symbol}: {e}") + + def get_cob_data_for_dashboard(self, symbol: str) -> Dict: + """Get formatted COB data for dashboard display""" + try: + if symbol not in self.cob_cache or not self.cob_cache[symbol]['data']: + return None + + cob_snapshot = self.cob_cache[symbol]['data'] + current_time = time.time() + + # Check if data is fresh (within last 5 seconds) + if current_time - self.cob_cache[symbol]['last_update'] > 5: + return None + + # Format COB data for dashboard + formatted_data = { + 'symbol': symbol, + 'current_price': cob_snapshot.current_price, + 'last_update': self.cob_cache[symbol]['last_update'], + 'updates_count': self.cob_cache[symbol]['updates_count'], + 'bids': [], + 'asks': [], + 'liquidity_stats': { + 'total_bid_liquidity': 0, + 'total_ask_liquidity': 0, + 'levels_count': len(cob_snapshot.consolidated_bids) + len(cob_snapshot.consolidated_asks), + 'imbalance_1s': getattr(cob_snapshot, 'imbalance_1s', 0), + 'imbalance_5s': getattr(cob_snapshot, 'imbalance_5s', 0), + 'imbalance_15s': getattr(cob_snapshot, 'imbalance_15s', 0), + 'imbalance_30s': getattr(cob_snapshot, 'imbalance_30s', 0) + } + } + + # Process bids (top 10) + for i, (price, size) in enumerate(cob_snapshot.consolidated_bids[:10]): + total_value = price * size + formatted_data['bids'].append({ + 'price': price, + 'size': size, + 'total': total_value + }) + formatted_data['liquidity_stats']['total_bid_liquidity'] += total_value + + # Process asks (top 10) + for i, (price, size) in enumerate(cob_snapshot.consolidated_asks[:10]): + total_value = price * size + formatted_data['asks'].append({ + 'price': price, + 'size': size, + 'total': total_value + }) + formatted_data['liquidity_stats']['total_ask_liquidity'] += total_value + + return formatted_data + + except Exception as e: + logger.debug(f"[COB-WS] Error formatting COB data for {symbol}: {e}") + return None + def _create_cnn_monitoring_content(self) -> List: """Create CNN monitoring and prediction analysis content""" try: @@ -8280,6 +9042,59 @@ class TradingDashboard: logger.warning(f"Error calculating Williams pivot points: {e}") return None + def _add_williams_pivot_points_to_chart_safe(self, fig, pivot_points: List[Dict], row: int = 1): + """Safely add Williams pivot points to chart with proper error handling""" + try: + if not pivot_points or len(pivot_points) == 0: + return + + # Process pivot points list + for pivot_data in pivot_points: + if not isinstance(pivot_data, dict): + continue + + timestamp = pivot_data.get('timestamp') + price = pivot_data.get('price') + pivot_type = pivot_data.get('type', 'unknown') + + if timestamp is None or price is None: + continue + + # Determine marker properties based on pivot type + if pivot_type.lower() in ['high', 'swing_high']: + marker_symbol = 'triangle-down' + marker_color = '#ff6b6b' + marker_size = 8 + elif pivot_type.lower() in ['low', 'swing_low']: + marker_symbol = 'triangle-up' + marker_color = '#4ecdc4' + marker_size = 8 + else: + marker_symbol = 'circle' + marker_color = '#95a5a6' + marker_size = 6 + + # Add scatter trace for pivot point + fig.add_trace(go.Scatter( + x=[timestamp], + y=[price], + mode='markers', + marker=dict( + symbol=marker_symbol, + size=marker_size, + color=marker_color, + line=dict(width=1, color='white') + ), + name=f'{pivot_type} Pivot', + showlegend=False, + hovertemplate=f'{pivot_type} Pivot
Price: ${price:.2f}
Time: %{{x}}' + )) + + logger.debug(f"[CHART] Added {len(pivot_points)} Williams pivot points safely") + + except Exception as e: + logger.debug(f"Error adding Williams pivot points safely: {e}") + def _add_williams_pivot_points_to_chart(self, fig, pivot_points: Dict, row: int = 1): """Add Williams pivot points as small triangles to the chart with proper timezone conversion""" try: @@ -9138,6 +9953,230 @@ class TradingDashboard: except: return [html.P("CNN monitoring unavailable", className="text-muted")] + def _create_enhanced_cob_status_content(self) -> List: + """Create enhanced COB status content with real data integration""" + try: + content = [] + + # Check if we have enhanced orchestrator with COB integration + if not hasattr(self.orchestrator, 'cob_integration') or not self.orchestrator.cob_integration: + content.append(html.P([ + html.I(className="fas fa-exclamation-triangle text-warning me-2"), + "COB integration not available" + ], className="small")) + return content + + # COB Integration Status + content.append(html.P([ + html.I(className="fas fa-check-circle text-success me-2"), + "COB integration ACTIVE" + ], className="small fw-bold")) + + # Get COB provider stats + try: + cob_provider = self.orchestrator.cob_integration.cob_provider + if hasattr(cob_provider, 'trade_counts'): + eth_trades = cob_provider.trade_counts.get('ETH/USDT', 0) + btc_trades = cob_provider.trade_counts.get('BTC/USDT', 0) + + content.append(html.P([ + html.Strong("Trade Tracking: "), + f"ETH: {eth_trades:,} | BTC: {btc_trades:,}" + ], className="text-success small")) + except: + pass + + # Training Pipeline Status + if hasattr(self.orchestrator, 'enhanced_rl_training') and self.orchestrator.enhanced_rl_training: + content.append(html.P([ + html.I(className="fas fa-brain text-info me-2"), + "COB → CNN/RL pipeline ACTIVE" + ], className="small")) + + # Show feature dimensions + try: + cob_features = getattr(self.orchestrator, 'latest_cob_features', {}) + cob_state = getattr(self.orchestrator, 'latest_cob_state', {}) + + if cob_features: + eth_features = cob_features.get('ETH/USDT') + btc_features = cob_features.get('BTC/USDT') + + if eth_features is not None: + content.append(html.P([ + html.Strong("CNN Features: "), + f"ETH: {eth_features.shape}, BTC: {btc_features.shape if btc_features is not None else 'N/A'}" + ], className="text-info small")) + + if cob_state: + eth_state = cob_state.get('ETH/USDT') + btc_state = cob_state.get('BTC/USDT') + + if eth_state is not None: + content.append(html.P([ + html.Strong("RL State: "), + f"ETH: {eth_state.shape}, BTC: {btc_state.shape if btc_state is not None else 'N/A'}" + ], className="text-info small")) + except: + pass + else: + content.append(html.P([ + html.I(className="fas fa-times-circle text-danger me-2"), + "Training pipeline inactive" + ], className="small")) + + # Data flow indicators + content.append(html.Hr()) + content.append(html.P([ + html.I(className="fas fa-arrow-right text-secondary me-1"), + "Binance WebSocket → COB Provider" + ], className="small")) + content.append(html.P([ + html.I(className="fas fa-arrow-right text-secondary me-1"), + "COB Integration → Feature Extraction" + ], className="small")) + content.append(html.P([ + html.I(className="fas fa-arrow-right text-secondary me-1"), + "Features → CNN/RL Models" + ], className="small")) + + return content + + except Exception as e: + logger.error(f"Error creating enhanced COB status content: {e}") + return [html.P(f"COB status error: {str(e)}", className="text-danger")] + + def _create_detailed_cob_content(self, symbol: str) -> List: + """Create detailed COB content similar to COB dashboard""" + try: + content = [] + + # Check if we have enhanced orchestrator with COB integration + if not hasattr(self.orchestrator, 'cob_integration') or not self.orchestrator.cob_integration: + content.append(html.P("COB integration not available", className="text-warning small")) + return content + + # Get COB snapshot + cob_snapshot = None + try: + cob_snapshot = self.orchestrator.cob_integration.get_cob_snapshot(symbol) + except Exception as e: + logger.debug(f"Error getting COB snapshot for {symbol}: {e}") + + if not cob_snapshot: + content.append(html.P(f"COB snapshot not available for {symbol}", className="text-muted small")) + return content + + # Symbol header with current price + content.append(html.H6(f"{symbol} - ${cob_snapshot.volume_weighted_mid:.2f}", + className="text-primary mb-2")) + + # Resolution info + resolution = "$20 buckets" if symbol == "BTC/USDT" else "$2 buckets" + content.append(html.P(f"Resolution: {resolution}", className="text-muted small")) + + # Create order book table + content.append(html.Div([ + html.Table([ + html.Thead([ + html.Tr([ + html.Th("Side", className="small"), + html.Th("Price", className="small"), + html.Th("Size", className="small"), + html.Th("Total ($)", className="small") + ]) + ]), + html.Tbody(self._create_cob_table_rows(cob_snapshot, symbol)) + ], className="table table-sm table-dark") + ])) + + # Liquidity and metrics + content.append(html.P([ + html.Strong("Liquidity: "), + f"${(cob_snapshot.total_bid_liquidity + cob_snapshot.total_ask_liquidity)/1000:.0f}K" + ], className="text-success small")) + + content.append(html.P([ + html.Strong("Levels: "), + f"{len(cob_snapshot.consolidated_bids) + len(cob_snapshot.consolidated_asks)}" + ], className="text-info small")) + + # Imbalance metrics (if available) + try: + imbalance_1s = cob_snapshot.imbalance_metrics.get('1s', 0) * 100 + imbalance_5s = cob_snapshot.imbalance_metrics.get('5s', 0) * 100 + imbalance_15s = cob_snapshot.imbalance_metrics.get('15s', 0) * 100 + imbalance_30s = cob_snapshot.imbalance_metrics.get('30s', 0) * 100 + + content.append(html.P([ + html.Strong("Imbalance: "), + f"{imbalance_1s:.1f}% (1s) | {imbalance_5s:.1f}% (5s) | {imbalance_15s:.1f}% (15s) | {imbalance_30s:.1f}% (30s)" + ], className="text-warning small")) + except: + pass + + # Update count + try: + updates = getattr(cob_snapshot, 'update_count', 0) + content.append(html.P([ + html.Strong("Updates: "), + f"{updates}" + ], className="text-secondary small")) + except: + pass + + return content + + except Exception as e: + logger.error(f"Error creating detailed COB content for {symbol}: {e}") + return [html.P(f"COB error: {str(e)}", className="text-danger")] + + def _create_cob_table_rows(self, cob_snapshot, symbol: str) -> List: + """Create order book table rows similar to COB dashboard""" + try: + rows = [] + + # Get top levels (limit to 10 each side for dashboard display) + top_asks = sorted(cob_snapshot.consolidated_asks, key=lambda x: x['price'], reverse=True)[:10] + top_bids = sorted(cob_snapshot.consolidated_bids, key=lambda x: x['price'], reverse=True)[:10] + + # Add ASK rows (highest to lowest) + for ask in top_asks: + price = ask['price'] + size = ask['size'] + total_usd = price * size + + rows.append(html.Tr([ + html.Td("ASK", className="text-danger small"), + html.Td(f"${price:.2f}", className="small"), + html.Td(f"{size:.3f}", className="small"), + html.Td(f"${total_usd/1000:.0f}K", className="small") + ])) + + # Add separator row + rows.append(html.Tr([ + html.Td("---", className="text-muted small", colSpan=4) + ])) + + # Add BID rows (highest to lowest) + for bid in top_bids: + price = bid['price'] + size = bid['size'] + total_usd = price * size + + rows.append(html.Tr([ + html.Td("BID", className="text-success small"), + html.Td(f"${price:.2f}", className="small"), + html.Td(f"{size:.3f}", className="small"), + html.Td(f"${total_usd/1000:.0f}K", className="small") + ])) + + return rows + + except Exception as e: + logger.error(f"Error creating COB table rows: {e}") + return [html.Tr([html.Td("Error loading order book", colSpan=4, className="text-danger small")])] + def _create_cob_status_content(self) -> List: """Create COB status and training pipeline content""" try: