Update app.py

app.py

@@ -13,8 +13,9 @@ import sys
 import os
 import threading
 from datetime import datetime, timedelta
+import asyncio
 
-# Set matplotlib backend - FIXED TYPO
+# Set matplotlib backend
 plt.switch_backend('Agg')
 
 # Create directories and init files
@@ -49,6 +50,8 @@ class RealTimeTradingDemo:
         self.action_history = []
         self.initialized = False
         self.start_time = None
+        self.last_update = None
+        self.update_callbacks = []
         
     def initialize_environment(self, initial_balance, risk_level, asset_type):
         """Initialize trading environment"""
@@ -74,8 +77,9 @@ class RealTimeTradingDemo:
             self.live_trading = False
             self.initialized = True
             self.start_time = datetime.now()
+            self.last_update = datetime.now()
             
-            # Initialize live data
+            # Initialize live data with more realistic pattern
             self._initialize_live_data()
             
             return "✅ محیط معاملاتی Real-Time راه‌اندازی شد!\n\n🎯 آماده برای شروع آموزش هوش مصنوعی..."
@@ -86,16 +90,21 @@ class RealTimeTradingDemo:
             return error_msg
     
     def _initialize_live_data(self):
-        """Initialize live trading data"""
-        # Generate realistic initial data
+        """Initialize live trading data with realistic patterns"""
         base_price = 100
-        for i in range(50):
-            price = base_price + np.random.normal(0, 2)
+        # Create realistic price pattern with some volatility
+        for i in range(100):
+            # Simulate realistic market movements
+            trend = np.sin(i * 0.1) * 5  # Long-term trend
+            noise = np.random.normal(0, 1.5)  # Market noise
+            price = base_price + trend + noise
+            
             self.live_data.append({
-                'timestamp': datetime.now() - timedelta(seconds=50-i),
-                'price': price,
+                'timestamp': datetime.now() - timedelta(seconds=100-i),
+                'price': max(50, price),  # Prevent negative prices
                 'action': 0,
-                'net_worth': self.env.initial_balance if self.env else 10000
+                'net_worth': self.env.initial_balance if self.env else 10000,
+                'volume': np.random.randint(1000, 10000)
             })
     
     def train_agent(self, num_episodes):
@@ -181,10 +190,10 @@ class RealTimeTradingDemo:
     def start_live_trading(self):
         """Start real-time live trading demo"""
         if not self.training_complete:
-            return "❌ لطفا اول آموزش را کامل کنید!", None, None
+            return "❌ لطفا اول آموزش را کامل کنید!", None, None, None
         
         if self.live_trading:
-            return "⚠️ معامله Real-Time در حال اجراست!", None, None
+            return "⚠️ معامله Real-Time در حال اجراست!", None, None, None
         
         self.live_trading = True
         self.live_data = []
@@ -197,12 +206,18 @@ class RealTimeTradingDemo:
         self.trading_thread.daemon = True
         self.trading_thread.start()
         
-        return "🎯 معامله Real-Time شروع شد!", self._create_live_chart(), self._create_performance_chart()
+        # Get initial status and charts
+        status = "🎯 معامله Real-Time شروع شد!\n\n📈 نمودارها هر 1 ثانیه آپدیت می‌شوند..."
+        live_chart = self._create_live_chart()
+        performance_chart = self._create_performance_chart()
+        stats_table = self._create_stats_table()
+        
+        return status, live_chart, performance_chart, stats_table
     
     def _live_trading_loop(self):
         """Main live trading loop"""
         step_count = 0
-        max_steps = 200  # Stop after 200 steps for demo
+        max_steps = 500  # Run for longer demo
         
         while self.live_trading and step_count < max_steps:
             try:
@@ -213,26 +228,40 @@ class RealTimeTradingDemo:
                 next_state, reward, done, info = self.env.step(action)
                 self.current_state = next_state
                 
-                # Update live data
+                # Update live data with realistic price movement
                 current_time = datetime.now()
+                last_price = self.live_data[-1]['price'] if self.live_data else 100
+                
+                # Simulate realistic price movement
+                price_change = np.random.normal(0, 0.5)  # Small random walk
+                if action == 1:  # Buy - slight upward pressure
+                    price_change += 0.1
+                elif action == 2:  # Sell - slight downward pressure
+                    price_change -= 0.1
+                
+                new_price = max(50, last_price + price_change)  # Prevent negative prices
+                
                 self.live_data.append({
                     'timestamp': current_time,
-                    'price': info['current_price'],
+                    'price': new_price,
                     'action': action,
-                    'net_worth': info['net_worth']
+                    'net_worth': info['net_worth'],
+                    'volume': np.random.randint(1000, 15000)
                 })
                 
-                # Keep only last 100 data points
-                if len(self.live_data) > 100:
+                # Keep only last 150 data points for performance
+                if len(self.live_data) > 150:
                     self.live_data.pop(0)
                 
                 self.action_history.append({
                     'step': step_count,
                     'action': action,
                     'reward': reward,
-                    'timestamp': current_time
+                    'timestamp': current_time,
+                    'price': new_price
                 })
                 
+                self.last_update = current_time
                 step_count += 1
                 time.sleep(1)  # 1 second between steps
                 
@@ -242,28 +271,50 @@ class RealTimeTradingDemo:
         
         self.live_trading = False
     
-    def get_live_update(self):
-        """Get real-time update for the interface"""
+    def get_live_data(self):
+        """Get real-time data for auto-updating charts"""
         if not self.live_trading:
-            return "🛑 معامله Real-Time متوقف شده", None, None
+            return {
+                "status": "🛑 معامله Real-Time متوقف شده",
+                "live_chart": self._create_live_chart(),
+                "performance_chart": self._create_performance_chart(),
+                "stats_table": self._create_stats_table()
+            }
         
         current_data = self.live_data[-1] if self.live_data else None
         if not current_data:
-            return "📊 در حال آماده‌سازی داده...", None, None
+            return {
+                "status": "📊 در حال آماده‌سازی داده...",
+                "live_chart": self._create_live_chart(),
+                "performance_chart": self._create_performance_chart(),
+                "stats_table": self._create_stats_table()
+            }
         
         action_names = ["نگهداری", "خرید", "فروش", "بستن"]
         action = current_data['action']
         action_text = action_names[action]
         
+        # Calculate performance metrics
+        initial_balance = self.env.initial_balance
+        current_net_worth = current_data['net_worth']
+        profit_loss = current_net_worth - initial_balance
+        profit_loss_pct = (profit_loss / initial_balance) * 100
+        
         status = (
             f"🎯 معامله Real-Time در حال اجرا...\n"
             f"💰 قیمت فعلی: ${current_data['price']:.2f}\n"
-            f"🎪 اقدام: {action_text}\n"
-            f"💼 ارزش پرتفولیو: ${current_data['net_worth']:.2f}\n"
+            f"🎪 اقدام اخیر: {action_text}\n"
+            f"💼 ارزش پرتفولیو: ${current_net_worth:.2f}\n"
+            f"📈 سود/زیان: ${profit_loss:.2f} ({profit_loss_pct:.2f}%)\n"
             f"⏰ آخرین بروزرسانی: {datetime.now().strftime('%H:%M:%S')}"
         )
         
-        return status, self._create_live_chart(), self._create_performance_chart()
+        return {
+            "status": status,
+            "live_chart": self._create_live_chart(),
+            "performance_chart": self._create_performance_chart(),
+            "stats_table": self._create_stats_table()
+        }
     
     def stop_live_trading(self):
         """Stop the live trading demo"""
@@ -273,21 +324,32 @@ class RealTimeTradingDemo:
         
         final_net_worth = self.live_data[-1]['net_worth'] if self.live_data else self.env.initial_balance
         initial_balance = self.env.initial_balance
+        profit_loss = final_net_worth - initial_balance
+        profit_loss_pct = (profit_loss / initial_balance) * 100
+        
+        # Calculate action statistics
+        actions = [h['action'] for h in self.action_history]
+        action_counts = {
+            "نگهداری": actions.count(0),
+            "خرید": actions.count(1),
+            "فروش": actions.count(2),
+            "بستن": actions.count(3)
+        }
         
         performance = (
             f"🛑 معامله Real-Time متوقف شد\n\n"
             f"📈 عملکرد نهایی:\n"
             f"• سرمایه اولیه: ${initial_balance:.2f}\n"
             f"• سرمایه نهایی: ${final_net_worth:.2f}\n"
-            f"• سود/زیان: ${final_net_worth - initial_balance:.2f}\n"
-            f"• درصد تغییر: {((final_net_worth - initial_balance) / initial_balance * 100):.2f}%\n"
-            f"• تعداد اقدامات: {len(self.action_history)}"
+            f"• سود/زیان: ${profit_loss:.2f} ({profit_loss_pct:.2f}%)\n"
+            f"• تعداد اقدامات: {len(self.action_history)}\n"
+            f"• خریدها: {action_counts['خرید']} | فروش‌ها: {action_counts['فروش']}"
         )
         
-        return performance, self._create_live_chart(), self._create_performance_chart()
+        return performance, self._create_live_chart(), self._create_performance_chart(), self._create_stats_table()
     
     def _create_live_chart(self):
-        """Create real-time trading chart"""
+        """Create real-time trading chart with advanced features"""
         if not self.live_data:
             fig = go.Figure()
             fig.update_layout(
@@ -299,19 +361,26 @@ class RealTimeTradingDemo:
         times = [d['timestamp'] for d in self.live_data]
         prices = [d['price'] for d in self.live_data]
         actions = [d['action'] for d in self.live_data]
+        volumes = [d['volume'] for d in self.live_data]
         
-        fig = go.Figure()
+        fig = make_subplots(
+            rows=2, cols=1,
+            subplot_titles=['🎯 نمودار قیمت لحظه‌ای', '📊 حجم معاملات'],
+            vertical_spacing=0.1,
+            row_heights=[0.7, 0.3]
+        )
         
-        # Price line
+        # Price line with gradient coloring based on trend
         fig.add_trace(go.Scatter(
             x=times,
             y=prices,
             mode='lines',
             name='قیمت',
-            line=dict(color='blue', width=3)
-        ))
+            line=dict(color='blue', width=3),
+            hovertemplate='<b>قیمت: $%{y:.2f}</b><br>زمان: %{x}<extra></extra>'
+        ), row=1, col=1)
         
-        # Action markers
+        # Action markers with different colors and sizes
         buy_times = [times[i] for i, action in enumerate(actions) if action == 1]
         buy_prices = [prices[i] for i, action in enumerate(actions) if action == 1]
         
@@ -327,8 +396,9 @@ class RealTimeTradingDemo:
                 y=buy_prices,
                 mode='markers',
                 name='خرید',
-                marker=dict(color='green', size=10, symbol='triangle-up')
-            ))
+                marker=dict(color='green', size=12, symbol='triangle-up', line=dict(width=2, color='darkgreen')),
+                hovertemplate='<b>🚀 خرید در $%{y:.2f}</b><br>زمان: %{x}<extra></extra>'
+            ), row=1, col=1)
         
         if sell_times:
             fig.add_trace(go.Scatter(
@@ -336,68 +406,159 @@ class RealTimeTradingDemo:
                 y=sell_prices,
                 mode='markers',
                 name='فروش',
-                marker=dict(color='red', size=10, symbol='triangle-down')
-            ))
+                marker=dict(color='red', size=12, symbol='triangle-down', line=dict(width=2, color='darkred')),
+                hovertemplate='<b>📉 فروش در $%{y:.2f}</b><br>زمان: %{x}<extra></extra>'
+            ), row=1, col=1)
+        
+        # Volume bars
+        fig.add_trace(go.Bar(
+            x=times,
+            y=volumes,
+            name='حجم',
+            marker_color='rgba(100, 100, 200, 0.6)',
+            hovertemplate='<b>حجم: %{y:,}</b><br>زمان: %{x}<extra></extra>'
+        ), row=2, col=1)
         
-        if close_times:
+        # Add moving average
+        if len(prices) > 10:
+            ma_10 = pd.Series(prices).rolling(window=10).mean()
             fig.add_trace(go.Scatter(
-                x=close_times,
-                y=close_prices,
-                mode='markers',
-                name='بستن',
-                marker=dict(color='orange', size=8, symbol='x')
-            ))
+                x=times,
+                y=ma_10,
+                mode='lines',
+                name='میانگین متحرک (10)',
+                line=dict(color='orange', width=2, dash='dash'),
+                hovertemplate='<b>MA10: $%{y:.2f}</b><br>زمان: %{x}<extra></extra>'
+            ), row=1, col=1)
         
         fig.update_layout(
-            title="🎯 نمودار معاملات Real-Time",
-            xaxis_title="زمان",
-            yaxis_title="قیمت",
-            height=400,
+            title="🎯 نمودار معاملات Real-Time - آپدیت لحظه‌ای",
+            height=500,
             showlegend=True,
-            template="plotly_white"
+            template="plotly_dark",
+            hovermode='x unified'
         )
         
+        fig.update_xaxes(title_text="زمان", row=2, col=1)
+        fig.update_yaxes(title_text="قیمت ($)", row=1, col=1)
+        fig.update_yaxes(title_text="حجم", row=2, col=1)
+        
         return fig
     
     def _create_performance_chart(self):
-        """Create performance chart"""
+        """Create animated performance chart"""
         if not self.live_data:
             fig = go.Figure()
             fig.update_layout(
                 title="📈 عملکرد پرتفولیو - در حال آماده‌سازی...",
-                height=300
+                height=350
             )
             return fig
         
         times = [d['timestamp'] for d in self.live_data]
         net_worths = [d['net_worth'] for d in self.live_data]
+        prices = [d['price'] for d in self.live_data]
         
-        fig = go.Figure()
+        fig = make_subplots(
+            rows=2, cols=1,
+            subplot_titles=['💼 ارزش پرتفولیو لحظه‌ای', '📈 نسبت عملکرد'],
+            vertical_spacing=0.15
+        )
         
+        # Net worth line
         fig.add_trace(go.Scatter(
             x=times,
             y=net_worths,
             mode='lines+markers',
             name='ارزش پرتفولیو',
-            line=dict(color='green', width=3),
-            marker=dict(size=4)
-        ))
+            line=dict(color='#00FF00', width=4),
+            marker=dict(size=6, color='#00FF00'),
+            hovertemplate='<b>پرتفولیو: $%{y:.2f}</b><br>زمان: %{x}<extra></extra>'
+        ), row=1, col=1)
         
         # Add initial balance line
         if self.env:
             fig.add_hline(y=self.env.initial_balance, line_dash="dash", 
-                         line_color="red", annotation_text="سرمایه اولیه")
+                         line_color="red", annotation_text="سرمایه اولیه",
+                         row=1, col=1)
+        
+        # Calculate performance ratio (current price / initial price)
+        if len(prices) > 1:
+            initial_price = prices[0]
+            performance_ratio = [(p / initial_price - 1) * 100 for p in prices]
+            
+            fig.add_trace(go.Scatter(
+                x=times,
+                y=performance_ratio,
+                mode='lines',
+                name='تغییرات قیمت (%)',
+                line=dict(color='cyan', width=3),
+                hovertemplate='<b>تغییر: %{y:.2f}%</b><br>زمان: %{x}<extra></extra>'
+            ), row=2, col=1)
         
         fig.update_layout(
-            title="💼 عملکرد پرتفولیو در زمان واقعی",
-            xaxis_title="زمان",
-            yaxis_title="ارزش ($)",
-            height=300,
-            template="plotly_white"
+            title="💼 عملکرد Real-Time پرتفولیو",
+            height=400,
+            template="plotly_dark",
+            showlegend=True,
+            hovermode='x unified'
         )
         
+        fig.update_yaxes(title_text="ارزش ($)", row=1, col=1)
+        fig.update_yaxes(title_text="تغییرات (%)", row=2, col=1)
+        
         return fig
     
+    def _create_stats_table(self):
+        """Create real-time statistics table"""
+        if not self.live_data:
+            return pd.DataFrame({
+                'متریک': ['در حال بارگذاری...'],
+                'مقدار': ['-']
+            })
+        
+        current_data = self.live_data[-1]
+        initial_balance = self.env.initial_balance
+        current_net_worth = current_data['net_worth']
+        
+        # Calculate statistics
+        profit_loss = current_net_worth - initial_balance
+        profit_loss_pct = (profit_loss / initial_balance) * 100
+        
+        # Price statistics
+        prices = [d['price'] for d in self.live_data]
+        price_change = prices[-1] - prices[0] if len(prices) > 1 else 0
+        price_change_pct = (price_change / prices[0]) * 100 if len(prices) > 1 else 0
+        
+        # Action statistics
+        actions = [d['action'] for d in self.live_data[-50:]]  # Last 50 actions
+        action_counts = {
+            "خرید": actions.count(1),
+            "فروش": actions.count(2),
+            "بستن": actions.count(3)
+        }
+        
+        stats_data = {
+            'متریک': [
+                '💰 قیمت فعلی',
+                '📈 تغییر قیمت',
+                '💼 ارزش پرتفولیو',
+                '🎯 سود/زیان',
+                '🔄 اقدامات اخیر',
+                '⏰ مدت اجرا'
+            ],
+            'مقدار': [
+                f'${current_data["price"]:.2f}',
+                f'{price_change_pct:+.2f}%',
+                f'${current_net_worth:.2f}',
+                f'${profit_loss:+.2f} ({profit_loss_pct:+.2f}%)',
+                f'خرید: {action_counts["خرید"]} | فروش: {action_counts["فروش"]}',
+                f'{len(self.action_history)} ثانیه'
+            ]
+        }
+        
+        return pd.DataFrame(stats_data)
+    
     def _create_training_progress(self, training_history):
         """Create training progress visualization"""
         if not training_history:
@@ -444,14 +605,14 @@ class RealTimeTradingDemo:
 # Initialize the demo
 demo = RealTimeTradingDemo()
 
-# Create Gradio interface
+# Create Gradio interface with auto-refresh
 def create_interface():
     with gr.Blocks(theme=gr.themes.Soft(), title="Real-Time Trading AI") as interface:
         gr.Markdown("""
         # 🚀 هوش مصنوعی معامله‌گر Real-Time
-        **آموزش و اجرای بلادرنگ روی نمودارهای زنده**
+        **آموزش و اجرای بلادرنگ روی نمودارهای زنده - آپدیت اتوماتیک هر 1 ثانیه**
         
-        *این سیستم ابتدا هوش مصنوعی را آموزش می‌دهد، سپس به صورت Real-Time روی بازار معامله می‌کند*
+        *نمودارها بصورت کاملاً متحرک و لحظه‌ای آپدیت می‌شوند*
         """)
         
         with gr.Row():
@@ -498,7 +659,7 @@ def create_interface():
                 status_output = gr.Textbox(
                     label="وضعیت عملیات",
                     interactive=False,
-                    lines=4
+                    lines=5
                 )
         
         with gr.Row():
@@ -523,7 +684,7 @@ def create_interface():
                 )
         
         with gr.Row():
-            gr.Markdown("## 🎯 فاز ۲: معامله Real-Time")
+            gr.Markdown("## 🎯 فاز ۲: معامله Real-Time (آپدیت اتوماتیک)")
             
         with gr.Row():
             with gr.Column(scale=1):
@@ -538,25 +699,60 @@ def create_interface():
                     variant="stop",
                     size="lg"
                 )
-            
-            with gr.Column(scale=1):
-                update_btn = gr.Button(
-                    "🔄 بروزرسانی لحظه‌ای", 
-                    variant="secondary",
-                    size="lg"
-                )
         
         with gr.Row():
-            with gr.Column(scale=1):
+            with gr.Column(scale=2):
                 live_chart = gr.Plot(
-                    label="📊 نمودار معاملات Real-Time"
+                    label="📊 نمودار معاملات Real-Time - آپدیت لحظه‌ای"
                 )
             
             with gr.Column(scale=1):
                 performance_chart = gr.Plot(
-                    label="💼 عملکرد پرتفولیو"
+                    label="💼 عملکرد پرتفولیو - آپدیت لحظه‌ای"
                 )
         
+        with gr.Row():
+            gr.Markdown("## 📈 آمار لحظه‌ای")
+            
+        with gr.Row():
+            stats_table = gr.Dataframe(
+                label="📊 متریک‌های Real-Time",
+                headers=['متریک', 'مقدار'],
+                datatype=['str', 'str'],
+                row_count=6,
+                col_count=2
+            )
+        
+        # Auto-refresh component
+        auto_refresh = gr.HTML("""
+        <script>
+        function setupAutoRefresh() {
+            let refreshInterval;
+            
+            function startAutoRefresh() {
+                refreshInterval = setInterval(() => {
+                    if (window.liveTradingActive) {
+                        // Trigger the refresh function
+                        const refreshBtn = document.querySelector('[data-testid="refresh-button"]');
+                        if (refreshBtn) refreshBtn.click();
+                    }
+                }, 1000); // Refresh every 1 second
+            }
+            
+            function stopAutoRefresh() {
+                clearInterval(refreshInterval);
+            }
+            
+            // Expose functions to global scope
+            window.startAutoRefresh = startAutoRefresh;
+            window.stopAutoRefresh = stopAutoRefresh;
+        }
+        
+        // Initialize when page loads
+        document.addEventListener('DOMContentLoaded', setupAutoRefresh);
+        </script>
+        """)
+        
         # Event handlers
         init_btn.click(
             demo.initialize_environment,
@@ -573,28 +769,39 @@ def create_interface():
         start_btn.click(
             demo.start_live_trading,
             inputs=[],
-            outputs=[status_output, live_chart, performance_chart]
+            outputs=[status_output, live_chart, performance_chart, stats_table]
+        ).then(
+            lambda: gr.HTML("<script>window.liveTradingActive = true; window.startAutoRefresh();</script>")
         )
         
-        update_btn.click(
-            demo.get_live_update,
+        # Auto-refresh function
+        def auto_refresh_data():
+            return demo.get_live_data()["status"], demo.get_live_data()["live_chart"], demo.get_live_data()["performance_chart"], demo.get_live_data()["stats_table"]
+        
+        # Set up periodic refresh
+        interface.load(
+            fn=auto_refresh_data,
             inputs=[],
-            outputs=[status_output, live_chart, performance_chart]
+            outputs=[status_output, live_chart, performance_chart, stats_table],
+            every=1000  # Refresh every 1000ms (1 second)
         )
         
         stop_btn.click(
             demo.stop_live_trading,
             inputs=[],
-            outputs=[status_output, live_chart, performance_chart]
+            outputs=[status_output, live_chart, performance_chart, stats_table]
+        ).then(
+            lambda: gr.HTML("<script>window.liveTradingActive = false; window.stopAutoRefresh();</script>")
         )
         
         gr.Markdown("""
-        ## 🧠 نحوه کار سیستم:
+        ## 🧠 ویژگی‌های سیستم Real-Time:
         
-        1. **راه‌اندازی محیط**: تنظیم پارامترهای اولیه
-        2. **آموزش هوش مصنوعی**: آموزش مدل با ۳۰ اپیزود
-        3. **معامله Real-Time**: اجرای بلادرنگ روی نمودار زنده
-        4. **مانیتورینگ**: مشاهده عملکرد لحظه‌ای
+        - 📊 **نمودارهای کاملاً متحرک** - آپدیت هر 1 ثانیه
+        - 🎯 **معامله لحظه‌ای** - تصمیم‌گیری AI در زمان واقعی
+        - 📈 **متریک‌های زنده** - آمار عملکرد به صورت لحظه‌ای
+        - 🔄 **آپدیت اتوماتیک** - بدون نیاز به کلیک دستی
+        - 💹 **داده‌های واقعی** - شبیه‌سازی بازار واقعی
         
         *توسعه داده شده توسط Omid Sakaki - 2024*
         """)