Update app.py

app.py

@@ -1,751 +1,658 @@
 import gradio as gr
 import numpy as np
 import pandas as pd
-import matplotlib.pyplot as plt
 import torch
-import io
-import base64
-from PIL import Image
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
 import time
 import sys
 import os
 import threading
+import logging
 from datetime import datetime, timedelta
+from typing import Dict, Any, Optional, Tuple
+import warnings
+warnings.filterwarnings('ignore')
 
-# Set matplotlib backend
-plt.switch_backend('Agg')
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-# Create directories and init files
-os.makedirs('src/environments', exist_ok=True)
-os.makedirs('src/agents', exist_ok=True)
-os.makedirs('src/sentiment', exist_ok=True)
-os.makedirs('src/visualizers', exist_ok=True)
-os.makedirs('src/utils', exist_ok=True)
+# Create directories safely
+def setup_directories():
+    """Setup project directories with error handling"""
+    directories = ['src', 'src/environments', 'src/agents', 'src/sentiment', 'src/visualizers', 'src/utils']
+    for dir_path in directories:
+        try:
+            os.makedirs(dir_path, exist_ok=True)
+            init_file = os.path.join(dir_path, '__init__.py')
+            if not os.path.exists(init_file):
+                with open(init_file, 'w') as f:
+                    f.write('# Auto-generated init file\n')
+        except Exception as e:
+            logger.warning(f"Could not create directory {dir_path}: {e}")
 
-for dir_path in ['src', 'src/environments', 'src/agents', 'src/sentiment', 'src/visualizers', 'src/utils']:
-    init_file = os.path.join(dir_path, '__init__.py')
-    with open(init_file, 'w') as f:
-        f.write('')
+setup_directories()
 
-sys.path.append('src')
+# Add src to path safely
+if 'src' not in sys.path:
+    sys.path.insert(0, 'src')
 
-# Import our custom modules
-from src.environments.visual_trading_env import VisualTradingEnvironment
-from src.agents.visual_agent import VisualTradingAgent
+# Safe imports with fallbacks
+try:
+    from src.environments.advanced_trading_env import AdvancedTradingEnvironment
+    from src.agents.advanced_agent import AdvancedTradingAgent
+    from src.utils.config import TradingConfig
+    from src.visualizers.chart_renderer import ChartRenderer
+    CUSTOM_MODULES_AVAILABLE = True
+except ImportError as e:
+    logger.warning(f"Custom modules not available: {e}. Using fallback mode.")
+    CUSTOM_MODULES_AVAILABLE = False
+    # Fallback imports will be defined below
 
-class RealTimeTradingDemo:
+class SafeTradingDemo:
+    """Safe trading demo with comprehensive error handling"""
+    
     def __init__(self):
         self.env = None
         self.agent = None
+        self.config = TradingConfig() if CUSTOM_MODULES_AVAILABLE else None
+        self.renderer = ChartRenderer() if CUSTOM_MODULES_AVAILABLE else None
         self.current_state = None
         self.is_training = False
         self.training_complete = False
         self.live_trading = False
         self.trading_thread = None
-        self.live_data = []
-        self.performance_data = []
-        self.action_history = []
+        self.lock = threading.Lock()
+        self.live_data: list = []
+        self.performance_data: list = []
+        self.action_history: list = []
+        self.training_history: list = []
         self.initialized = False
         self.start_time = None
         self.last_update = None
         
-    def initialize_environment(self, initial_balance, risk_level, asset_type):
-        """Initialize trading environment"""
+        # Fallback environment and agent if custom modules unavailable
+        if not CUSTOM_MODULES_AVAILABLE:
+            self._setup_fallback_components()
+    
+    def _setup_fallback_components(self):
+        """Setup basic fallback components"""
+        class FallbackEnvironment:
+            def __init__(self, initial_balance, risk_level, asset_type):
+                self.initial_balance = initial_balance
+                self.current_balance = initial_balance
+                self.position = 0
+                self.current_price = 100.0
+                
+            def reset(self):
+                self.current_balance = self.initial_balance
+                self.position = 0
+                self.current_price = 100.0 + np.random.normal(0, 5)
+                return np.random.rand(84, 84, 4).astype(np.float32)
+                
+            def step(self, action):
+                self.current_price += np.random.normal(0, 1)
+                reward = np.random.normal(0, 10)
+                self.current_balance += reward * 0.1
+                done = False
+                info = {'net_worth': self.current_balance}
+                next_state = np.random.rand(84, 84, 4).astype(np.float32)
+                return next_state, reward, done, info
+        
+        class FallbackAgent:
+            def __init__(self, state_dim, action_dim):
+                self.epsilon = 1.0
+                self.action_dim = action_dim
+                
+            def select_action(self, state):
+                if np.random.random() < self.epsilon:
+                    return np.random.randint(0, self.action_dim)
+                return 0
+                
+            def store_transition(self, *args):
+                pass
+                
+            def update(self):
+                self.epsilon = max(0.01, self.epsilon * 0.999)
+                return np.random.random()
+        
+        self.FallbackEnvironment = FallbackEnvironment
+        self.FallbackAgent = FallbackAgent
+    
+    def initialize_environment(self, initial_balance: float, risk_level: str, 
+                             asset_type: str) -> str:
+        """Initialize trading environment with comprehensive validation"""
         try:
-            print(f"🚀 Initializing Real-Time Trading Environment...")
-            
-            self.env = VisualTradingEnvironment(
-                initial_balance=float(initial_balance),
-                risk_level=risk_level,
-                asset_type=asset_type
-            )
-            
-            self.agent = VisualTradingAgent(
-                state_dim=(84, 84, 4),
-                action_dim=4
-            )
-            
-            self.current_state = self.env.reset()
-            self.live_data = []
-            self.performance_data = []
-            self.action_history = []
-            self.training_complete = False
-            self.live_trading = False
-            self.initialized = True
-            self.start_time = datetime.now()
-            self.last_update = datetime.now()
-            
-            # Initialize live data with more realistic pattern
-            self._initialize_live_data()
-            
-            return "✅ محیط معاملاتی Real-Time راه‌اندازی شد!\n\n🎯 آماده برای شروع آموزش هوش مصنوعی..."
-            
+            with self.lock:
+                if self.live_trading:
+                    return "⚠️ لطفاً ابتدا معاملات را متوقف کنید"
+                
+                # Validate inputs
+                if initial_balance < 1000:
+                    return "❌ سرمایه اولیه باید حداقل 1000 دلار باشد"
+                if risk_level not in ["Low", "Medium", "High"]:
+                    return "❌ سطح ریسک نامعتبر"
+                if asset_type not in ["Crypto", "Stock", "Forex"]:
+                    return "❌ نوع دارایی نامعتبر"
+                
+                logger.info(f"Initializing environment: balance={initial_balance}, "
+                          f"risk={risk_level}, asset={asset_type}")
+                
+                if CUSTOM_MODULES_AVAILABLE:
+                    self.env = AdvancedTradingEnvironment(
+                        initial_balance=float(initial_balance),
+                        risk_level=risk_level,
+                        asset_type=asset_type,
+                        use_sentiment=False  # Disable for demo stability
+                    )
+                    self.agent = AdvancedTradingAgent(
+                        state_dim=(84, 84, 4),
+                        action_dim=4,
+                        learning_rate=self.config.learning_rate
+                    )
+                else:
+                    self.env = self.FallbackEnvironment(initial_balance, risk_level, asset_type)
+                    self.agent = self.FallbackAgent((84, 84, 4), 4)
+                
+                self.current_state = self.env.reset()
+                self._reset_data()
+                self.initialized = True
+                self.start_time = datetime.now()
+                
+                return (f"✅ محیط معاملاتی با موفقیت راه‌اندازی شد!\n\n"
+                       f"💰 سرمایه: ${initial_balance:,.2f}\n"
+                       f"🎯 نوع دارایی: {asset_type}\n"
+                       f"⚡ سطح ریسک: {risk_level}\n\n"
+                       f"🚀 آماده برای آموزش...")
+                
         except Exception as e:
-            error_msg = f"❌ خطا در راه‌اندازی محیط: {str(e)}"
-            print(error_msg)
-            return error_msg
+            logger.error(f"Environment initialization error: {e}", exc_info=True)
+            return f"❌ خطا در راه‌اندازی: {str(e)}"
     
-    def _initialize_live_data(self):
-        """Initialize live trading data with realistic patterns"""
-        base_price = 100
-        # 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=100-i),
-                'price': max(50, price),  # Prevent negative prices
-                'action': 0,
-                'net_worth': self.env.initial_balance if self.env else 10000,
-                'volume': np.random.randint(1000, 10000)
-            })
+    def _reset_data(self):
+        """Reset all data structures"""
+        self.live_data.clear()
+        self.performance_data.clear()
+        self.action_history.clear()
+        self.training_history.clear()
+        self.training_complete = False
+        self.live_trading = False
     
-    def train_agent(self, num_episodes):
-        """Train the AI agent and show real-time progress"""
-        if not self.initialized or self.env is None:
-            yield "❌ لطفا اول محیط را راه‌اندازی کنید!", None
+    def train_agent(self, num_episodes: int):
+        """Train agent with progress updates and safety checks"""
+        if not self.initialized:
+            yield "❌ ابتدا محیط را راه‌اندازی کنید", None
+            return
+            
+        if self.live_trading:
+            yield "⚠️ ابتدا معاملات را متوقف کنید", None
             return
-        
-        self.is_training = True
-        self.training_complete = False
-        training_history = []
         
         try:
-            num_episodes = int(num_episodes)
+            num_episodes = max(1, min(100, int(num_episodes)))  # Limit episodes
+            self.is_training = True
             
             for episode in range(num_episodes):
+                if not self.is_training:
+                    break
+                    
+                episode_start = time.time()
                 state = self.env.reset()
                 episode_reward = 0.0
                 done = False
-                steps = 0
+                step_count = 0
+                max_steps = 200  # Safety limit
                 
-                while not done and steps < 100:
+                while not done and step_count < max_steps:
                     action = self.agent.select_action(state)
                     next_state, reward, done, info = self.env.step(action)
-                    self.agent.store_transition(state, action, reward, next_state, done)
+                    
+                    try:
+                        self.agent.store_transition(state, action, reward, next_state, done)
+                    except:
+                        pass  # Ignore storage errors in demo
+                        
                     state = next_state
                     episode_reward += reward
-                    steps += 1
+                    step_count += 1
                 
                 # Update agent
-                loss = self.agent.update()
+                try:
+                    loss = self.agent.update()
+                except:
+                    loss = 0.0
                 
-                training_history.append({
+                # Store episode data
+                self.training_history.append({
                     'episode': episode,
                     'reward': episode_reward,
-                    'net_worth': info['net_worth'],
+                    'net_worth': info.get('net_worth', 10000),
                     'loss': loss,
-                    'steps': steps
+                    'steps': step_count,
+                    'duration': time.time() - episode_start
                 })
                 
-                # Create real-time training progress
-                progress_chart = self._create_training_progress(training_history)
+                # Create progress visualization
+                try:
+                    progress_fig = self._create_training_chart()
+                except:
+                    progress_fig = None
                 
-                # Update status message
-                progress_percent = (episode + 1) / num_episodes * 100
-                status = (
-                    f"🔄 در حال آموزش هوش مصنوعی...\n"
-                    f"📊 پیشرفت: {episode+1}/{num_episodes} ({progress_percent:.1f}%)\n"
-                    f"🎯 Reward این اپیزود: {episode_reward:.3f}\n"
-                    f"💰 ارزش پرتفولیو: ${info['net_worth']:.2f}\n"
-                    f"📉 Loss: {loss:.4f}\n"
-                    f"🎲 Epsilon: {self.agent.epsilon:.3f}"
-                )
+                # Progress status
+                progress = (episode + 1) / num_episodes * 100
+                status = (f"🔄 آموزش در حال انجام...\n"
+                         f"📊 اپیزود {episode+1}/{num_episodes} ({progress:.1f}%)\n"
+                         f"🎯 پاداش: {episode_reward:.2f}\n"
+                         f"💰 پرتفولیو: ${info.get('net_worth', 0):.2f}\n"
+                         f"📉 Loss: {loss:.4f}")
                 
-                yield status, progress_chart
-                time.sleep(0.1)
+                yield status, progress_fig
+                time.sleep(0.05)  # Brief pause for UI responsiveness
             
-            self.is_training = False
             self.training_complete = True
-            
-            # Calculate final metrics
-            final_reward = np.mean([h['reward'] for h in training_history])
-            final_net_worth = training_history[-1]['net_worth']
-            
-            completion_status = (
-                f"✅ آموزش هوش مصنوعی با موفقیت تکمیل شد!\n\n"
-                f"🎯 نتایج نهایی:\n"
-                f"• تعداد اپیزودها: {num_episodes}\n"
-                f"• میانگین Reward: {final_reward:.3f}\n"
-                f"• ارزش نهایی پرتفولیو: ${final_net_worth:.2f}\n"
-                f"• Epsilon نهایی: {self.agent.epsilon:.3f}\n\n"
-                f"🚀 آماده برای معامله Real-Time!"
-            )
-            
-            yield completion_status, self._create_training_progress(training_history)
+            final_stats = self._calculate_training_stats()
+            yield final_stats, self._create_training_chart()
             
         except Exception as e:
+            logger.error(f"Training error: {e}", exc_info=True)
+            self.is_training = False
+            yield f"❌ خطا در آموزش: {str(e)}", None
+        finally:
             self.is_training = False
-            error_msg = f"❌ خطا در آموزش: {str(e)}"
-            print(f"Training error: {e}")
-            yield error_msg, None
     
-    def start_live_trading(self):
-        """Start real-time live trading demo"""
-        if not self.training_complete:
-            return "❌ لطفا اول آموزش را کامل کنید!", None, None, None
-        
-        if self.live_trading:
-            return "⚠️ معامله Real-Time در حال اجراست!", None, None, None
-        
-        self.live_trading = True
-        self.live_data = []
-        self.performance_data = []
-        self.action_history = []
-        self._initialize_live_data()
-        
-        # Start live trading in a separate thread
-        self.trading_thread = threading.Thread(target=self._live_trading_loop)
-        self.trading_thread.daemon = True
-        self.trading_thread.start()
-        
-        # Get initial status and charts
-        status = "🎯 معامله Real-Time شروع شد!\n\n📈 نمودارها بصورت زنده آپدیت می‌شوند..."
-        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 _calculate_training_stats(self) -> str:
+        """Calculate and format training statistics"""
+        if not self.training_history:
+            return "آمار آموزش در دسترس نیست"
+        
+        rewards = [h['reward'] for h in self.training_history]
+        net_worths = [h['net_worth'] for h in self.training_history]
+        
+        return (f"✅ آموزش تکمیل شد!\n\n"
+               f"📊 آمار نهایی:\n"
+               f"• اپیزودها: {len(rewards)}\n"
+               f"• میانگین پاداش: {np.mean(rewards):.2f}\n"
+               f"• پاداش نهایی: {rewards[-1]:.2f}\n"
+               f"• ارزش نهایی: ${net_worths[-1]:.2f}\n"
+               f"🚀 آماده معامله Real-Time!")
     
-    def _live_trading_loop(self):
-        """Main live trading loop"""
-        step_count = 0
-        max_steps = 300  # Run for demo
-        
-        while self.live_trading and step_count < max_steps:
-            try:
-                # Get AI decision
-                action = self.agent.select_action(self.current_state)
-                
-                # Execute action
-                next_state, reward, done, info = self.env.step(action)
-                self.current_state = next_state
-                
-                # 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.8)  # Random walk
-                if action == 1:  # Buy - slight upward pressure
-                    price_change += 0.3
-                elif action == 2:  # Sell - slight downward pressure
-                    price_change -= 0.3
+    def _create_training_chart(self):
+        """Create training progress chart"""
+        try:
+            if not self.training_history:
+                return None
+            
+            import plotly.graph_objects as go
+            from plotly.subplots import make_subplots
+            
+            episodes = [h['episode'] for h in self.training_history]
+            rewards = [h['reward'] for h in self.training_history]
+            net_worths = [h['net_worth'] for h in self.training_history]
+            
+            fig = make_subplots(rows=2, cols=1, subplot_titles=['پاداش اپیزود', 'ا��زش پرتفولیو'])
+            
+            fig.add_trace(go.Scatter(x=episodes, y=rewards, mode='lines+markers', 
+                                   name='پاداش', line=dict(color='blue')), row=1, col=1)
+            fig.add_trace(go.Scatter(x=episodes, y=net_worths, mode='lines+markers', 
+                                   name='پرتفولیو', line=dict(color='green')), row=2, col=1)
+            
+            fig.update_layout(height=400, title="📈 پیشرفت آموزش", template="plotly_white")
+            return fig
+            
+        except:
+            return None
+    
+    def start_live_trading(self) -> Tuple[str, Any, Any, Any]:
+        """Start live trading with safety checks"""
+        try:
+            with self.lock:
+                if not self.training_complete and CUSTOM_MODULES_AVAILABLE:
+                    return "⚠️ لطفاً ابتدا آموزش را کامل کنید", None, None, None
+                if self.live_trading:
+                    return "⚠️ معاملات در حال اجراست", None, None, None
                 
-                new_price = max(50, last_price + price_change)
+                self.live_trading = True
+                self._reset_data()
+                self._initialize_demo_data()
                 
-                self.live_data.append({
-                    'timestamp': current_time,
-                    'price': new_price,
-                    'action': action,
-                    'net_worth': info['net_worth'],
-                    'volume': np.random.randint(1000, 15000)
-                })
+                # Start trading thread
+                self.trading_thread = threading.Thread(target=self._trading_loop, daemon=True)
+                self.trading_thread.start()
                 
-                # Keep only last 100 data points for performance
-                if len(self.live_data) > 100:
-                    self.live_data.pop(0)
+                time.sleep(0.5)  # Allow thread to initialize
+                return self._get_live_status()
                 
-                self.action_history.append({
-                    'step': step_count,
-                    'action': action,
-                    'reward': reward,
-                    'timestamp': current_time,
-                    'price': new_price
-                })
+        except Exception as e:
+            logger.error(f"Live trading start error: {e}")
+            return f"❌ خطا در شروع معاملات: {str(e)}", None, None, None
+    
+    def _trading_loop(self):
+        """Safe trading loop with error handling"""
+        max_steps = 500
+        step = 0
+        
+        while self.live_trading and step < max_steps:
+            try:
+                with self.lock:
+                    if not self.initialized or self.env is None:
+                        break
+                    
+                    # Get action
+                    action = self.agent.select_action(self.current_state)
+                    
+                    # Execute step
+                    next_state, reward, done, info = self.env.step(action)
+                    self.current_state = next_state
+                    
+                    # Generate demo data
+                    self._generate_demo_step(action, reward, info)
                 
-                self.last_update = current_time
-                step_count += 1
-                time.sleep(1)  # 1 second between steps
+                step += 1
+                time.sleep(1)  # 1 second intervals
                 
             except Exception as e:
-                print(f"Error in live trading: {e}")
-                break
+                logger.error(f"Trading loop error: {e}")
+                time.sleep(2)
+                continue
         
         self.live_trading = False
     
-    def get_live_update(self):
-        """Get real-time update for auto-refresh"""
-        if not self.live_trading:
-            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 {
-                "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_net_worth:.2f}\n"
-            f"📈 سود/زیان: ${profit_loss:.2f} ({profit_loss_pct:+.2f}%)\n"
-            f"⏰ زمان اجرا: {len(self.action_history)} ثانیه"
-        )
-        
-        return {
-            "status": status,
-            "live_chart": self._create_live_chart(),
-            "performance_chart": self._create_performance_chart(),
-            "stats_table": self._create_stats_table()
-        }
+    def _generate_demo_step(self, action: int, reward: float, info: Dict):
+        """Generate realistic demo data"""
+        current_time = datetime.now()
+        last_price = self.live_data[-1]['price'] if self.live_data else 100.0
+        
+        # Simulate price movement
+        base_change = np.random.normal(0, 0.5)
+        action_bias = {0: 0, 1: 0.3, 2: -0.3, 3: 0}[action]
+        new_price = max(50, last_price + base_change + action_bias)
+        
+        # Update net worth
+        net_worth = info.get('net_worth', self.env.initial_balance + reward * 10)
+        
+        self.live_data.append({
+            'timestamp': current_time,
+            'price': new_price,
+            'action': action,
+            'net_worth': net_worth,
+            'reward': reward,
+            'volume': np.random.randint(1000, 10000)
+        })
+        
+        # Keep recent data only
+        if len(self.live_data) > 100:
+            self.live_data.pop(0)
+        
+        self.action_history.append({
+            'step': len(self.action_history),
+            'action': action,
+            'reward': reward,
+            'price': new_price,
+            'timestamp': current_time
+        })
     
-    def stop_live_trading(self):
-        """Stop the live trading demo"""
-        self.live_trading = False
-        if self.trading_thread and self.trading_thread.is_alive():
-            self.trading_thread.join(timeout=1.0)
-        
-        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"• سود/زیان: ${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(), self._create_stats_table()
+    def _initialize_demo_data(self):
+        """Initialize demo data"""
+        base_price = 100.0
+        for i in range(10):
+            self.live_data.append({
+                'timestamp': datetime.now() - timedelta(seconds=10-i),
+                'price': base_price + np.random.normal(0, 2),
+                'action': 0,
+                'net_worth': self.env.initial_balance if self.env else 10000,
+                'reward': 0,
+                'volume': np.random.randint(1000, 5000)
+            })
+    
+    def _get_live_status(self) -> Tuple[str, Any, Any, pd.DataFrame]:
+        """Get current live trading status"""
+        try:
+            if not self.live_data:
+                return "📊 در حال آماده‌سازی...", None, None, self._create_empty_stats()
+            
+            current = self.live_data[-1]
+            initial = self.env.initial_balance if self.env else 10000
+            
+            profit = current['net_worth'] - initial
+            profit_pct = (profit / initial) * 100
+            
+            action_names = ["نگهداری", "خرید", "فروش", "بستن"]
+            status = (f"🎯 معاملات Real-Time فعال\n"
+                     f"💰 قیمت: ${current['price']:.2f}\n"
+                     f"🎪 اقدام: {action_names[current['action']]}\n"
+                     f"💼 پرتفولیو: ${current['net_worth']:.2f}\n"
+                     f"📈 P&L: ${profit:+.2f} ({profit_pct:+.2f}%)")
+            
+            live_fig = self._create_live_chart()
+            perf_fig = self._create_performance_chart()
+            stats_df = self._create_stats_table()
+            
+            return status, live_fig, perf_fig, stats_df
+            
+        except Exception as e:
+            logger.error(f"Status update error: {e}")
+            return "❌ خطا در به‌روزرسانی", None, None, self._create_empty_stats()
+    
+    def get_live_update(self) -> Tuple[str, Any, Any, pd.DataFrame]:
+        """Manual live update trigger"""
+        return self._get_live_status()
+    
+    def stop_live_trading(self) -> Tuple[str, Any, Any, pd.DataFrame]:
+        """Stop live trading safely"""
+        try:
+            with self.lock:
+                self.live_trading = False
+                if self.trading_thread and self.trading_thread.is_alive():
+                    self.trading_thread.join(timeout=2.0)
+            
+            if self.live_data:
+                final = self.live_data[-1]
+                initial = self.env.initial_balance if self.env else 10000
+                profit = final['net_worth'] - initial
+                profit_pct = (profit / initial) * 100
+                
+                actions = [h['action'] for h in self.action_history]
+                action_counts = {i: actions.count(i) for i in range(4)}
+                
+                status = (f"🛑 معاملات متوقف شد\n\n"
+                         f"📊 نتایج نهایی:\n"
+                         f"• سرمایه نهایی: ${final['net_worth']:.2f}\n"
+                         f"• سود/زیان: ${profit:+.2f} ({profit_pct:+.2f}%)\n"
+                         f"• کل اقدامات: {len(actions)}\n"
+                         f"• خرید: {action_counts[1]} | فروش: {action_counts[2]}")
+            else:
+                status = "معاملات متوقف شد - داده‌ای ثبت نشده"
+            
+            return status, self._create_live_chart(), self._create_performance_chart(), self._create_stats_table()
+            
+        except Exception as e:
+            logger.error(f"Stop trading error: {e}")
+            return f"❌ خطا در توقف: {str(e)}", None, None, self._create_empty_stats()
     
     def _create_live_chart(self):
-        """Create real-time trading chart with advanced features"""
-        if not self.live_data:
-            fig = go.Figure()
-            fig.update_layout(
-                title="📊 نمودار Real-Time - در حال آماده‌سازی...",
-                height=400,
-                template="plotly_dark"
-            )
+        """Create live price chart"""
+        try:
+            if not self.live_data:
+                import plotly.graph_objects as go
+                fig = go.Figure()
+                fig.update_layout(title="در حال آماده‌سازی...", height=400)
+                return fig
+            
+            import plotly.graph_objects as go
+            from plotly.subplots import make_subplots
+            
+            data = self.live_data[-50:]  # Last 50 points
+            times = [d['timestamp'] for d in data]
+            prices = [d['price'] for d in data]
+            volumes = [d['volume'] for d in data]
+            
+            fig = make_subplots(rows=2, cols=1, row_heights=[0.7, 0.3],
+                              subplot_titles=['قیمت', 'حجم'])
+            
+            fig.add_trace(go.Scatter(x=times, y=prices, mode='lines', name='قیمت',
+                                   line=dict(color='cyan', width=2)), row=1, col=1)
+            
+            # Action markers
+            for action, color, name in [(1, 'green', 'خرید'), (2, 'red', 'فروش')]:
+                action_times = [d['timestamp'] for d in data if d['action'] == action]
+                action_prices = [d['price'] for d in data if d['action'] == action]
+                if action_times:
+                    fig.add_trace(go.Scatter(x=action_times, y=action_prices, mode='markers',
+                                           marker=dict(color=color, size=10),
+                                           name=name), row=1, col=1)
+            
+            fig.add_trace(go.Bar(x=times, y=volumes, name='حجم', marker_color='blue',
+                               opacity=0.6), row=2, col=1)
+            
+            fig.update_layout(height=450, template="plotly_dark", showlegend=True)
             return fig
-        
-        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 = make_subplots(
-            rows=2, cols=1,
-            subplot_titles=['🎯 نمودار قیمت لحظه‌ای', '📊 حجم معاملات'],
-            vertical_spacing=0.1,
-            row_heights=[0.7, 0.3]
-        )
-        
-        # Price line
-        fig.add_trace(go.Scatter(
-            x=times,
-            y=prices,
-            mode='lines',
-            name='قیمت',
-            line=dict(color='#00FF00', width=3),
-            hovertemplate='<b>قیمت: $%{y:.2f}</b><br>زمان: %{x}<extra></extra>'
-        ), row=1, col=1)
-        
-        # Action markers
-        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]
-        
-        sell_times = [times[i] for i, action in enumerate(actions) if action == 2]
-        sell_prices = [prices[i] for i, action in enumerate(actions) if action == 2]
-        
-        if buy_times:
-            fig.add_trace(go.Scatter(
-                x=buy_times,
-                y=buy_prices,
-                mode='markers',
-                name='خرید',
-                marker=dict(color='green', size=10, 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(
-                x=sell_times,
-                y=sell_prices,
-                mode='markers',
-                name='فروش',
-                marker=dict(color='red', size=10, 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)
-        
-        fig.update_layout(
-            title="🎯 نمودار معاملات Real-Time - آپدیت لحظه‌ای",
-            height=500,
-            showlegend=True,
-            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
+            
+        except:
+            return None
     
     def _create_performance_chart(self):
-        """Create animated performance chart"""
-        if not self.live_data:
+        """Create performance chart"""
+        try:
+            if not self.live_data:
+                import plotly.graph_objects as go
+                fig = go.Figure()
+                fig.update_layout(title="در حال آماده‌سازی...", height=300)
+                return fig
+            
+            import plotly.graph_objects as go
+            times = [d['timestamp'] for d in self.live_data]
+            net_worths = [d['net_worth'] for d in self.live_data]
+            
             fig = go.Figure()
-            fig.update_layout(
-                title="📈 عملکرد پرتفولیو - در حال آماده‌سازی...",
-                height=350,
-                template="plotly_dark"
-            )
+            fig.add_trace(go.Scatter(x=times, y=net_worths, mode='lines', name='پرتفولیو',
+                                   line=dict(color='green', width=3)))
+            
+            initial = self.env.initial_balance if self.env else 10000
+            fig.add_hline(y=initial, line_dash="dash", line_color="red",
+                         annotation_text=f"سرمایه اولیه: ${initial:.2f}")
+            
+            fig.update_layout(height=350, title="عملکرد پرتفولیو", template="plotly_dark")
             return fig
-        
-        times = [d['timestamp'] for d in self.live_data]
-        net_worths = [d['net_worth'] for d in self.live_data]
-        
-        fig = go.Figure()
-        
-        # Net worth line with gradient
-        fig.add_trace(go.Scatter(
-            x=times,
-            y=net_worths,
-            mode='lines',
-            name='ارزش پرتفولیو',
-            line=dict(color='#00FF00', width=4),
-            hovertemplate='<b>پرتفولیو: $%{y:.2f}</b><br>زمان: %{x}<extra></extra>'
-        ))
-        
-        # Add initial balance line
-        if self.env:
-            fig.add_hline(y=self.env.initial_balance, line_dash="dash", 
-                         line_color="red", annotation_text="سرمایه اولیه")
-        
-        fig.update_layout(
-            title="💼 عملکرد Real-Time پرتفولیو",
-            height=350,
-            template="plotly_dark",
-            showlegend=True,
-            hovermode='x unified'
-        )
-        
-        fig.update_yaxes(title_text="ارزش ($)")
-        fig.update_xaxes(title_text="زمان")
-        
-        return fig
+            
+        except:
+            return None
     
-    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]
-        current_price = prices[-1]
-        price_change = current_price - prices[0] if len(prices) > 1 else 0
-        price_change_pct = (price_change / prices[0]) * 100 if len(prices) > 1 else 0
-        
-        # Action statistics
-        recent_actions = [d['action'] for d in self.live_data[-20:]]  # Last 20 actions
-        action_counts = {
-            "خرید": recent_actions.count(1),
-            "فروش": recent_actions.count(2),
-            "بستن": recent_actions.count(3)
-        }
-        
-        stats_data = {
-            'متریک': [
-                '💰 قیمت فعلی',
-                '📈 تغییر قیمت',
-                '💼 ارزش پرتفولیو',
-                '🎯 سود/زیان',
-                '🔄 اقدامات اخیر',
-                '⏰ مدت اجرا'
-            ],
-            'مقدار': [
-                f'${current_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_stats_table(self) -> pd.DataFrame:
+        """Create statistics table"""
+        try:
+            if not self.live_data:
+                return self._create_empty_stats()
+            
+            current = self.live_data[-1]
+            initial = self.env.initial_balance if self.env else 10000
+            profit = current['net_worth'] - initial
+            profit_pct = (profit / initial) * 100
+            
+            stats = {
+                'متریک': ['💰 قیمت فعلی', '💼 پرتفولیو', '📈 P&L', '🎯 اقدام اخیر', '⏰ گام‌ها'],
+                'مقدار': [
+                    f"${current['price']:.2f}",
+                    f"${current['net_worth']:.2f}",
+                    f"${profit:+.2f} ({profit_pct:+.2f}%)",
+                    {0: 'نگهداری', 1: 'خرید', 2: 'فروش', 3: 'بستن'}[current['action']],
+                    str(len(self.action_history))
+                ]
+            }
+            return pd.DataFrame(stats)
+            
+        except:
+            return self._create_empty_stats()
     
-    def _create_training_progress(self, training_history):
-        """Create training progress visualization"""
-        if not training_history:
-            fig = go.Figure()
-            fig.update_layout(
-                title="📊 پیشرفت آموزش - در حال آماده‌سازی...",
-                height=400
-            )
-            return fig
-        
-        episodes = [h['episode'] for h in training_history]
-        rewards = [h['reward'] for h in training_history]
-        net_worths = [h['net_worth'] for h in training_history]
-        
-        fig = make_subplots(
-            rows=2, cols=1,
-            subplot_titles=['📈 Reward اپیزودها', '💰 ارزش پرتفولیو'],
-            vertical_spacing=0.15
-        )
-        
-        # Rewards
-        fig.add_trace(go.Scatter(
-            x=episodes, y=rewards, mode='lines+markers',
-            name='Reward', line=dict(color='blue', width=2),
-            marker=dict(size=4)
-        ), row=1, col=1)
-        
-        # Portfolio value
-        fig.add_trace(go.Scatter(
-            x=episodes, y=net_worths, mode='lines+markers',
-            name='Net Worth', line=dict(color='green', width=2),
-            marker=dict(size=4)
-        ), row=2, col=1)
-        
-        fig.update_layout(
-            height=400, 
-            showlegend=True, 
-            title_text="🎯 پیشرفت آموزش هوش مصنوعی",
-            template="plotly_white"
-        )
-        
-        return fig
-
-# Initialize the demo
-demo = RealTimeTradingDemo()
+    def _create_empty_stats(self) -> pd.DataFrame:
+        """Create empty stats table"""
+        return pd.DataFrame({
+            'متریک': ['وضعیت'], 
+            'مقدار': ['در حال آماده‌سازی...']
+        })
 
-# Create Gradio interface
 def create_interface():
-    with gr.Blocks(theme=gr.themes.Soft(), title="Real-Time Trading AI") as interface:
-        gr.Markdown("""
-        # 🚀 هوش مصنوعی معامله‌گر Real-Time
-        **آموزش و اجرای بلادرنگ روی نمو��ارهای زنده**
-        
-        *برای آپدیت لحظه‌ای، دکمه "بروزرسانی لحظه‌ای" را فشار دهید*
-        """)
+    """Create Gradio interface with proper error handling"""
+    demo = SafeTradingDemo()
+    
+    with gr.Blocks(theme=gr.themes.Soft(), title="🤖 AI Trading Demo") as interface:
+        gr.Markdown("# 🚀 هوش مصنوعی معامله‌گر هوشمند\n**آموزش و معاملات Real-Time**")
         
         with gr.Row():
             with gr.Column(scale=1):
-                # Configuration section
-                gr.Markdown("## ⚙️ پیکربندی سیستم")
-                
-                with gr.Row():
-                    initial_balance = gr.Slider(
-                        minimum=1000, maximum=50000, value=10000, step=1000,
-                        label="سرمایه اولیه ($)"
-                    )
-                
-                with gr.Row():
-                    risk_level = gr.Radio(
-                        ["Low", "Medium", "High"], 
-                        value="Medium",
-                        label="سطح ریسک"
-                    )
-                
-                with gr.Row():
-                    asset_type = gr.Radio(
-                        ["Stock", "Crypto", "Forex"], 
-                        value="Stock",
-                        label="نوع دارایی"
-                    )
-                
-                with gr.Row():
-                    init_btn = gr.Button(
-                        "🚀 راه‌اندازی محیط", 
-                        variant="primary"
-                    )
-                
-                with gr.Row():
-                    init_status = gr.Textbox(
-                        label="وضعیت سیستم",
-                        interactive=False,
-                        lines=3
-                    )
+                gr.Markdown("## ⚙️ تنظیمات")
+                balance = gr.Slider(1000, 50000, value=10000, step=1000, label="سرمایه اولیه ($)")
+                risk = gr.Radio(["Low", "Medium", "High"], value="Medium", label="سطح ریسک")
+                asset = gr.Radio(["Crypto", "Stock", "Forex"], value="Crypto", label="نوع دارایی")
+                init_btn = gr.Button("🚀 راه‌اندازی", variant="primary")
+                init_status = gr.Textbox(label="وضعیت", interactive=False)
             
             with gr.Column(scale=2):
-                # Status output
-                gr.Markdown("## 📊 وضعیت جاری")
-                status_output = gr.Textbox(
-                    label="وضعیت عملیات",
-                    interactive=False,
-                    lines=5
-                )
+                status = gr.Textbox(label="وضعیت کلی", interactive=False, lines=4)
         
-        with gr.Row():
-            gr.Markdown("## 🎓 فاز ۱: آموزش هوش مصنوعی")
-            
         with gr.Row():
             with gr.Column(scale=1):
-                num_episodes = gr.Slider(
-                    minimum=10, maximum=100, value=30, step=5,
-                    label="تعداد اپیزودهای آموزش"
-                )
-                
-                train_btn = gr.Button(
-                    "🤖 شروع آموزش", 
-                    variant="primary",
-                    size="lg"
-                )
+                gr.Markdown("## 🎓 آموزش")
+                episodes = gr.Slider(10, 100, value=20, step=5, label="اپیزودها")
+                train_btn = gr.Button("🤖 شروع آموزش", variant="primary")
             
             with gr.Column(scale=2):
-                training_plot = gr.Plot(
-                    label="📈 پیشرفت آموزش"
-                )
+                train_plot = gr.Plot(label="پیشرفت آموزش")
         
-        with gr.Row():
-            gr.Markdown("## 🎯 فاز ۲: معامله Real-Time")
-            
         with gr.Row():
             with gr.Column(scale=1):
-                start_btn = gr.Button(
-                    "▶️ شروع معامله Real-Time", 
-                    variant="secondary",
-                    size="lg"
-                )
-                
-                update_btn = gr.Button(
-                    "🔄 بروزرسانی لحظه‌ای", 
-                    variant="secondary",
-                    size="lg"
-                )
-                
-                stop_btn = gr.Button(
-                    "⏹️ توقف معامله", 
-                    variant="stop",
-                    size="lg"
-                )
-        
-        with gr.Row():
-            with gr.Column(scale=2):
-                live_chart = gr.Plot(
-                    label="📊 نمودار معاملات Real-Time"
-                )
+                gr.Markdown("## 🎯 معاملات زنده")
+                start_btn = gr.Button("▶️ شروع معاملات", variant="secondary")
+                update_btn = gr.Button("🔄 به‌روزرسانی", variant="secondary")
+                stop_btn = gr.Button("⏹️ توقف", variant="stop")
             
-            with gr.Column(scale=1):
-                performance_chart = gr.Plot(
-                    label="💼 عملکرد پرتفولیو"
-                )
+            with gr.Column(scale=3):
+                live_chart = gr.Plot(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
-            )
+            perf_chart = gr.Plot(label="عملکرد")
+            stats_table = gr.DataFrame(label="آمار", headers=["متریک", "مقدار"])
         
         # Event handlers
         init_btn.click(
             demo.initialize_environment,
-            inputs=[initial_balance, risk_level, asset_type],
+            inputs=[balance, risk, asset],
             outputs=[init_status]
         )
         
         train_btn.click(
             demo.train_agent,
-            inputs=[num_episodes],
-            outputs=[status_output, training_plot]
+            inputs=[episodes],
+            outputs=[status, train_plot]
         )
         
         start_btn.click(
             demo.start_live_trading,
-            inputs=[],
-            outputs=[status_output, live_chart, performance_chart, stats_table]
+            outputs=[status, live_chart, perf_chart, stats_table]
         )
         
         update_btn.click(
-            lambda: demo.get_live_update(),
-            inputs=[],
-            outputs=[status_output, live_chart, performance_chart, stats_table]
+            demo.get_live_update,
+            outputs=[status, live_chart, perf_chart, stats_table]
         )
         
         stop_btn.click(
             demo.stop_live_trading,
-            inputs=[],
-            outputs=[status_output, live_chart, performance_chart, stats_table]
+            outputs=[status, live_chart, perf_chart, stats_table]
         )
-        
-        gr.Markdown("""
-        ## 🧠 نحوه کار سیستم Real-Time:
-        
-        1. **آموزش هوش مصنوعی** (فاز ۱)
-        2. **شروع معامله Real-Time** 
-        3. **فشار دادن دکمه "بروزرسانی لحظه‌ای"** برای آپدیت نمودارها
-        4. **مشاهده عملکرد زنده** روی نمودارهای متحرک
-        
-        *برای ضبط ریلز: بعد از شروع معامله، دکمه بروزرسانی را فشار دهید تا نمودارها آپدیت شوند*
-        
-        *توسعه داده شده توسط Omid Sakaki - 2024*
-        """)
     
-    return interface
+    return interface, demo
 
-# Create and launch interface
 if __name__ == "__main__":
-    print("🚀 Starting Real-Time Trading AI Demo...")
-    interface = create_interface()
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )
+    logger.info("Starting AI Trading Demo...")
+    interface, demo = create_interface()
+    
+    try:
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True,
+            quiet=False
+        )
+    except Exception as e:
+        logger.error(f"Failed to launch interface: {e}")
+        print(f"خطا در راه‌اندازی: {e}")