enhanced

web/scalping_dashboard.py

@@ -22,6 +22,7 @@ from typing import Dict, List, Optional, Any
 import pandas as pd
 import numpy as np
 import requests
+import uuid
 
 import dash
 from dash import dcc, html, Input, Output
@@ -33,6 +34,159 @@ from core.enhanced_orchestrator import EnhancedTradingOrchestrator, TradingActio
 
 logger = logging.getLogger(__name__)
 
+class TradingSession:
+    """
+    Session-based trading with $100 starting balance
+    Tracks P&L for each session but resets between sessions
+    """
+    
+    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  # $100 USD starting balance
+        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 = {}  # symbol -> {'size': float, 'entry_price': float, 'side': str}
+        self.trade_history = []
+        self.last_action = None
+        
+        logger.info(f"🏁 NEW TRADING SESSION STARTED")
+        logger.info(f"📊 Session ID: {self.session_id}")
+        logger.info(f"💰 Starting Balance: ${self.starting_balance:.2f}")
+        logger.info(f"⏰ Start Time: {self.start_time.strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    def execute_trade(self, action: TradingAction, current_price: float):
+        """Execute a trading action and update P&L"""
+        try:
+            symbol = action.symbol
+            
+            # Calculate position size based on confidence and leverage
+            leverage = 500  # 500x leverage
+            risk_per_trade = 0.02  # 2% risk per trade
+            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':
+                # Close any existing short position
+                if symbol in self.positions and self.positions[symbol]['side'] == 'SHORT':
+                    self._close_position(symbol, current_price, 'BUY')
+                
+                # Open new long position
+                self.positions[symbol] = {
+                    'size': position_size,
+                    'entry_price': current_price,
+                    'side': 'LONG'
+                }
+                trade_info['pnl'] = 0  # No immediate P&L on entry
+                
+            elif action.action == 'SELL':
+                # Close any existing long position
+                if symbol in self.positions and self.positions[symbol]['side'] == 'LONG':
+                    pnl = self._close_position(symbol, current_price, 'SELL')
+                    trade_info['pnl'] = pnl
+                else:
+                    # Open new short position
+                    self.positions[symbol] = {
+                        'size': position_size,
+                        'entry_price': current_price,
+                        'side': 'SHORT'
+                    }
+                    trade_info['pnl'] = 0
+            
+            elif action.action == 'HOLD':
+                # No position change, just track
+                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}"
+            
+            # Update current balance
+            self.current_balance = self.starting_balance + self.total_pnl
+            
+            logger.info(f"💹 TRADE EXECUTED: {action.action} {symbol} @ ${current_price:.2f}")
+            logger.info(f"📊 Position Size: {position_size:.6f} (${position_value:.2f})")
+            logger.info(f"💰 Session P&L: ${self.total_pnl:+.2f} | Balance: ${self.current_balance:.2f}")
+            
+            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 an existing 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']
+        
+        # Calculate P&L
+        if side == 'LONG':
+            pnl = (exit_price - entry_price) * size
+        else:  # SHORT
+            pnl = (entry_price - exit_price) * size
+        
+        # Update session P&L
+        self.total_pnl += pnl
+        
+        # Track win/loss
+        if pnl > 0:
+            self.winning_trades += 1
+        else:
+            self.losing_trades += 1
+        
+        # Remove position
+        del self.positions[symbol]
+        
+        logger.info(f"📈 POSITION CLOSED: {side} {symbol}")
+        logger.info(f"📊 Entry: ${entry_price:.2f} | Exit: ${exit_price:.2f}")
+        logger.info(f"💰 Trade P&L: ${pnl:+.2f}")
+        
+        return pnl
+    
+    def get_win_rate(self) -> float:
+        """Calculate current win rate"""
+        total_closed_trades = self.winning_trades + self.losing_trades
+        if total_closed_trades == 0:
+            return 0.78  # Default win rate
+        return self.winning_trades / total_closed_trades
+    
+    def get_session_summary(self) -> dict:
+        """Get complete session summary"""
+        return {
+            'session_id': self.session_id,
+            'start_time': self.start_time,
+            'duration': datetime.now() - self.start_time,
+            'starting_balance': self.starting_balance,
+            'current_balance': self.current_balance,
+            'total_pnl': self.total_pnl,
+            'total_trades': self.total_trades,
+            'winning_trades': self.winning_trades,
+            'losing_trades': self.losing_trades,
+            'win_rate': self.get_win_rate(),
+            'open_positions': len(self.positions),
+            'trade_history': self.trade_history
+        }
+
 class RealTimeScalpingDashboard:
     """Real-time scalping dashboard with WebSocket streaming and ultra-low latency"""
     
@@ -42,19 +196,14 @@ class RealTimeScalpingDashboard:
         self.data_provider = data_provider or DataProvider()
         self.orchestrator = orchestrator or EnhancedTradingOrchestrator(self.data_provider)
         
+        # Initialize new trading session with $100 starting balance
+        self.trading_session = TradingSession()
+        
         # Timezone setup
         self.timezone = pytz.timezone('Europe/Sofia')
         
-        # Dashboard state
+        # Dashboard state - now using session-based metrics
         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 = {
@@ -92,22 +241,56 @@ class RealTimeScalpingDashboard:
         logger.info("🚀 Real-Time Scalping Dashboard initialized with LIVE STREAMING")
         logger.info("📡 WebSocket price streaming enabled")
         logger.info(f"🌍 Timezone: {self.timezone}")
+        logger.info(f"💰 Session Balance: ${self.trading_session.starting_balance:.2f}")
     
     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", 
+                html.H1("💹 Live Scalping Dashboard (500x Leverage) - Session Trading", 
                        className="text-center mb-4 text-white"),
-                html.P(f"🌍 Sofia Time Zone | 📡 Live WebSocket Streaming | ⚡ 100ms Updates", 
+                html.P(f"🌍 Sofia Time Zone | 📡 Live WebSocket Streaming | ⚡ 100ms Updates | 💰 Session: ${self.trading_session.starting_balance:.0f} Starting Balance", 
                        className="text-center text-info"),
                 
+                # Session info row
+                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(f"${self.trading_session.starting_balance:.0f}", className="text-primary"),
+                        html.P("Starting Balance", className="text-white")
+                    ], className="col-md-2 text-center"),
+                    
+                    html.Div([
+                        html.H4(id="current-balance", className="text-success"),
+                        html.P("Current Balance", className="text-white")
+                    ], className="col-md-2 text-center"),
+                    
+                    html.Div([
+                        html.H4(id="session-duration", className="text-info"),
+                        html.P("Session Time", className="text-white")
+                    ], className="col-md-2 text-center"),
+                    
+                    html.Div([
+                        html.H4(id="open-positions", className="text-warning"),
+                        html.P("Open Positions", className="text-white")
+                    ], className="col-md-2 text-center"),
+                    
+                    html.Div([
+                        html.H4("500x", className="text-danger"),
+                        html.P("Leverage", className="text-white")
+                    ], className="col-md-2 text-center")
+                ], className="row mb-3"),
+                
                 # Live metrics row
                 html.Div([
                     html.Div([
                         html.H3(id="live-pnl", className="text-success"),
-                        html.P("Total P&L", className="text-white")
+                        html.P("Session P&L", className="text-white")
                     ], className="col-md-2 text-center"),
                     
                     html.Div([
@@ -169,7 +352,7 @@ class RealTimeScalpingDashboard:
             
             # Live actions log
             html.Div([
-                html.H5("🔥 Live Trading Actions (Real-Time Stream)", className="text-center mb-3"),
+                html.H5("💹 Live Session Trading Actions (Real-Time Stream)", className="text-center mb-3"),
                 html.Div(id="actions-log")
             ], className="mb-4"),
             
@@ -186,6 +369,9 @@ class RealTimeScalpingDashboard:
         
         @self.app.callback(
             [
+                Output('current-balance', 'children'),
+                Output('session-duration', 'children'),
+                Output('open-positions', 'children'),
                 Output('live-pnl', 'children'),
                 Output('win-rate', 'children'),
                 Output('total-trades', 'children'),
@@ -205,11 +391,17 @@ class RealTimeScalpingDashboard:
             """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"
+                    # Calculate session duration
+                    duration = datetime.now() - self.trading_session.start_time
+                    duration_str = f"{int(duration.total_seconds()//3600):02d}:{int((duration.total_seconds()%3600)//60):02d}:{int(duration.total_seconds()%60):02d}"
+                    
+                    # Update session metrics
+                    current_balance = f"${self.trading_session.current_balance:.2f}"
+                    open_positions = str(len(self.trading_session.positions))
+                    pnl = f"${self.trading_session.total_pnl:+.2f}"
+                    win_rate = f"{self.trading_session.get_win_rate()*100:.1f}%"
+                    total_trades = str(self.trading_session.total_trades)
+                    last_action = self.trading_session.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..."
@@ -218,6 +410,8 @@ class RealTimeScalpingDashboard:
                     # Refresh chart data every 10 intervals (1 second)
                     if n_intervals % 10 == 0:
                         self._refresh_live_data()
+                        # Check for new trading decisions from orchestrator
+                        self._process_orchestrator_decisions()
                     
                     # Create real-time charts
                     main_eth_chart = self._create_live_chart('ETH/USDT', '1s', main_chart=True)
@@ -230,7 +424,7 @@ class RealTimeScalpingDashboard:
                     actions_log = self._create_live_actions_log()
                     
                     return (
-                        pnl, win_rate, total_trades, last_action, eth_price, btc_price,
+                        current_balance, duration_str, open_positions, 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
                     )
@@ -238,7 +432,7 @@ class RealTimeScalpingDashboard:
             except Exception as e:
                 logger.error(f"Error in real-time update: {e}")
                 return (
-                    "$0.00", "0%", "0", "ERROR", "🔄 Loading...", "🔄 Loading...",
+                    "$100.00", "00:00:00", "0", "$0.00", "0%", "0", "ERROR", "🔄 Loading...", "🔄 Loading...",
                     {}, {}, {}, {}, {}, "🔄 Loading real-time data..."
                 )
     
@@ -463,18 +657,27 @@ class RealTimeScalpingDashboard:
             return fig
     
     def _create_live_actions_log(self):
-        """Create live trading actions log"""
+        """Create live trading actions log with session information"""
         if not self.recent_decisions:
-            return html.P("⏳ Waiting for live trading signals from real-time stream...", 
+            return html.P("⏳ Waiting for live trading signals from session...", 
                          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")
+            
+            # Find corresponding trade in session history for P&L info
+            trade_pnl = ""
+            for trade in reversed(self.trading_session.trade_history):
+                if (trade['timestamp'].replace(tzinfo=None) - action.timestamp.replace(tzinfo=None)).total_seconds() < 5:
+                    if trade.get('pnl', 0) != 0:
+                        trade_pnl = f" | P&L: ${trade['pnl']:+.2f}"
+                    break
+            
             log_items.append(
                 html.P(
-                    f"🔥 {sofia_time} | {action.action} {action.symbol} @ ${action.price:.2f} "
-                    f"(Confidence: {action.confidence:.1%}) | 📡 LIVE STREAM",
+                    f"💹 {sofia_time} | {action.action} {action.symbol} @ ${action.price:.2f} "
+                    f"(Confidence: {action.confidence:.1%}) | Session Trade{trade_pnl}",
                     className="text-center mb-1 text-light"
                 )
             )
@@ -482,18 +685,18 @@ class RealTimeScalpingDashboard:
         return html.Div(log_items)
     
     def add_trading_decision(self, decision: TradingAction):
-        """Add trading decision with Sofia timezone"""
+        """Add trading decision with Sofia timezone and session tracking"""
         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}"
+        # Update session last action (trade count is updated in execute_trade)
+        self.trading_session.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}")
+        logger.info(f"🔥 {sofia_time} | Session trading decision: {decision.action} {decision.symbol} @ ${decision.price:.2f}")
     
     def stop_streaming(self):
         """Stop all WebSocket streams"""
@@ -509,21 +712,166 @@ class RealTimeScalpingDashboard:
     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(f"💹 Starting Live Scalping Dashboard (500x Leverage) at http://{host}:{port}")
+            logger.info("🏁 SESSION TRADING FEATURES:")
+            logger.info(f"   • Session ID: {self.trading_session.session_id}")
+            logger.info(f"   • Starting Balance: ${self.trading_session.starting_balance:.2f}")
+            logger.info("   • Session-based P&L tracking (resets each session)")
+            logger.info("   • Real-time trade execution with 500x leverage")
+            logger.info("   • Clean accounting logs for all trades")
+            logger.info("📡 TECHNICAL 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...")
+            logger.info("👋 Shutting down session trading dashboard...")
+            # Log final session summary
+            summary = self.trading_session.get_session_summary()
+            logger.info(f"📊 FINAL SESSION SUMMARY:")
+            logger.info(f"   • Session: {summary['session_id']}")
+            logger.info(f"   • Duration: {summary['duration']}")
+            logger.info(f"   • Final P&L: ${summary['total_pnl']:+.2f}")
+            logger.info(f"   • Total Trades: {summary['total_trades']}")
+            logger.info(f"   • Win Rate: {summary['win_rate']:.1%}")
+            logger.info(f"   • Final Balance: ${summary['current_balance']:.2f}")
         finally:
             self.stop_streaming()
 
+    def _process_orchestrator_decisions(self):
+        """
+        Process trading decisions from orchestrator and execute trades in the session
+        """
+        try:
+            # Check if orchestrator has new decisions
+            # This could be enhanced to use async calls, but for now we'll simulate based on market conditions
+            
+            # Get current prices for trade execution
+            eth_price = self.live_prices.get('ETH/USDT', 0)
+            btc_price = self.live_prices.get('BTC/USDT', 0)
+            
+            # Simple trading logic based on recent price movements (demo for session testing)
+            if eth_price > 0 and len(self.chart_data['ETH/USDT']['1s']) > 0:
+                recent_eth_data = self.chart_data['ETH/USDT']['1s'].tail(5)
+                if not recent_eth_data.empty:
+                    price_change = (eth_price - recent_eth_data['close'].iloc[0]) / recent_eth_data['close'].iloc[0]
+                    
+                    # Generate trading signals every ~30 seconds based on price movement
+                    if len(self.trading_session.trade_history) == 0 or \
+                       (datetime.now() - self.trading_session.trade_history[-1]['timestamp']).total_seconds() > 30:
+                        
+                        if price_change > 0.001:  # 0.1% price increase
+                            action = TradingAction(
+                                symbol='ETH/USDT',
+                                action='BUY',
+                                confidence=0.6 + min(abs(price_change) * 10, 0.3),
+                                timestamp=datetime.now(self.timezone),
+                                price=eth_price,
+                                quantity=0.01
+                            )
+                            self._execute_session_trade(action, eth_price)
+                            
+                        elif price_change < -0.001:  # 0.1% price decrease
+                            action = TradingAction(
+                                symbol='ETH/USDT',
+                                action='SELL',
+                                confidence=0.6 + min(abs(price_change) * 10, 0.3),
+                                timestamp=datetime.now(self.timezone),
+                                price=eth_price,
+                                quantity=0.01
+                            )
+                            self._execute_session_trade(action, eth_price)
+            
+            # Similar logic for BTC (less frequent)
+            if btc_price > 0 and len(self.chart_data['BTC/USDT']['1s']) > 0:
+                recent_btc_data = self.chart_data['BTC/USDT']['1s'].tail(3)
+                if not recent_btc_data.empty:
+                    price_change = (btc_price - recent_btc_data['close'].iloc[0]) / recent_btc_data['close'].iloc[0]
+                    
+                    # BTC trades less frequently
+                    btc_trades = [t for t in self.trading_session.trade_history if t['symbol'] == 'BTC/USDT']
+                    if len(btc_trades) == 0 or \
+                       (datetime.now() - btc_trades[-1]['timestamp']).total_seconds() > 60:
+                        
+                        if abs(price_change) > 0.002:  # 0.2% price movement for BTC
+                            action_type = 'BUY' if price_change > 0 else 'SELL'
+                            action = TradingAction(
+                                symbol='BTC/USDT',
+                                action=action_type,
+                                confidence=0.7 + min(abs(price_change) * 5, 0.25),
+                                timestamp=datetime.now(self.timezone),
+                                price=btc_price,
+                                quantity=0.001
+                            )
+                            self._execute_session_trade(action, btc_price)
+                            
+        except Exception as e:
+            logger.error(f"Error processing orchestrator decisions: {e}")
+    
+    def _execute_session_trade(self, action: TradingAction, current_price: float):
+        """
+        Execute trade in the trading session and update all metrics
+        """
+        try:
+            # Execute the trade in the session
+            trade_info = self.trading_session.execute_trade(action, current_price)
+            
+            if trade_info:
+                # Add to recent decisions for display
+                self.add_trading_decision(action)
+                
+                # Log session trade
+                logger.info(f"🎯 SESSION TRADE: {action.action} {action.symbol}")
+                logger.info(f"💰 Position Value: ${trade_info['value']:.2f}")
+                logger.info(f"📊 Confidence: {action.confidence:.1%}")
+                logger.info(f"💵 Session Balance: ${self.trading_session.current_balance:.2f}")
+                
+                # Log trade history for accounting
+                self._log_trade_for_accounting(trade_info)
+                
+        except Exception as e:
+            logger.error(f"Error executing session trade: {e}")
+    
+    def _log_trade_for_accounting(self, trade_info: dict):
+        """
+        Log trade for clean accounting purposes - this will be used even after broker API connection
+        """
+        try:
+            # Create accounting log entry
+            accounting_entry = {
+                'session_id': self.trading_session.session_id,
+                'timestamp': trade_info['timestamp'].isoformat(),
+                'symbol': trade_info['symbol'],
+                'action': trade_info['action'],
+                'price': trade_info['price'],
+                'size': trade_info['size'],
+                'value': trade_info['value'],
+                'confidence': trade_info['confidence'],
+                'pnl': trade_info.get('pnl', 0),
+                'session_balance': self.trading_session.current_balance,
+                'session_total_pnl': self.trading_session.total_pnl
+            }
+            
+            # Write to trade log file (append mode)
+            log_file = f"trade_logs/session_{self.trading_session.session_id}_{datetime.now().strftime('%Y%m%d')}.json"
+            
+            # Ensure trade_logs directory exists
+            import os
+            os.makedirs('trade_logs', exist_ok=True)
+            
+            # Append trade to log file
+            import json
+            with open(log_file, 'a') as f:
+                f.write(json.dumps(accounting_entry) + '\n')
+            
+            logger.info(f"📝 Trade logged for accounting: {log_file}")
+            
+        except Exception as e:
+            logger.error(f"Error logging trade for accounting: {e}")
+
 def create_scalping_dashboard(data_provider=None, orchestrator=None):
     """Create real-time dashboard instance"""
     return RealTimeScalpingDashboard(data_provider, orchestrator)