Update app.py

app.py

@@ -11,10 +11,11 @@ from plotly.subplots import make_subplots
 import time
 import sys
 import os
-from datetime import datetime
+import threading
+from datetime import datetime, timedelta
 
 # Set matplotlib backend
-plt.switch_backend('Agg')
+plt.switch_backgeround('Agg')
 
 # Create directories and init files
 os.makedirs('src/environments', exist_ok=True)
@@ -31,284 +32,85 @@ for dir_path in ['src', 'src/environments', 'src/agents', 'src/sentiment', 'src/
 sys.path.append('src')
 
 # Import our custom modules
-from src.environments.advanced_trading_env import AdvancedTradingEnvironment
-from src.agents.advanced_agent import AdvancedTradingAgent
-from src.visualizers.chart_renderer import ChartRenderer
-from src.sentiment.twitter_analyzer import AdvancedSentimentAnalyzer
+from src.environments.visual_trading_env import VisualTradingEnvironment
+from src.agents.visual_agent import VisualTradingAgent
 
-class ProfessionalTradingAIDemo:
+class RealTimeTradingDemo:
     def __init__(self):
         self.env = None
         self.agent = None
-        self.sentiment_analyzer = AdvancedSentimentAnalyzer()
         self.current_state = None
         self.is_training = False
-        self.episode_history = []
-        self.sentiment_history = []
-        self.chart_renderer = ChartRenderer()
+        self.training_complete = False
+        self.live_trading = False
+        self.trading_thread = None
+        self.live_data = []
+        self.performance_data = []
+        self.action_history = []
         self.initialized = False
-        self.use_sentiment = True
+        self.start_time = None
         
-    def initialize_environment(self, initial_balance, risk_level, asset_type, use_sentiment, sentiment_influence):
-        """Initialize professional trading environment with sentiment analysis"""
+    def initialize_environment(self, initial_balance, risk_level, asset_type):
+        """Initialize trading environment"""
         try:
-            print(f"Initializing professional trading environment...")
+            print(f"🚀 Initializing Real-Time Trading Environment...")
             
-            self.use_sentiment = use_sentiment
-            self.env = AdvancedTradingEnvironment(
+            self.env = VisualTradingEnvironment(
                 initial_balance=float(initial_balance),
                 risk_level=risk_level,
-                asset_type=asset_type,
-                use_sentiment=use_sentiment,
-                sentiment_influence=float(sentiment_influence)
+                asset_type=asset_type
             )
             
-            # Initialize sentiment analyzer if needed
-            if use_sentiment:
-                sentiment_loaded = self.sentiment_analyzer.initialize_models()
-                if not sentiment_loaded:
-                    return "❌ Failed to load sentiment analysis models. Please check internet connection."
-            
-            # Initialize advanced agent
-            self.agent = AdvancedTradingAgent(
+            self.agent = VisualTradingAgent(
                 state_dim=(84, 84, 4),
-                action_dim=4,
-                use_sentiment=use_sentiment
+                action_dim=4
             )
             
             self.current_state = self.env.reset()
-            self.episode_history = []
-            self.sentiment_history = []
+            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()
             
-            status_msg = "✅ Professional Trading Environment Initialized!"
-            if use_sentiment:
-                status_msg += f"\n🎯 Sentiment Analysis: ACTIVE (Influence: {sentiment_influence})"
-                status_msg += f"\n📊 Influencers: {len(self.sentiment_analyzer.influencers)} accounts monitored"
-            else:
-                status_msg += "\n🎯 Sentiment Analysis: DISABLED"
+            # Initialize live data
+            self._initialize_live_data()
             
-            return status_msg
+            return "✅ محیط معاملاتی Real-Time راه‌اندازی شد!\n\n🎯 آماده برای شروع آموزش هوش مصنوعی..."
             
         except Exception as e:
-            error_msg = f"❌ Error initializing environment: {str(e)}"
+            error_msg = f"❌ خطا در راه‌اندازی محیط: {str(e)}"
             print(error_msg)
             return error_msg
     
-    def run_single_step(self, action_choice):
-        """Run a single step with sentiment analysis"""
-        if not self.initialized or self.env is None or self.agent is None:
-            return None, None, None, None, "⚠️ Please initialize environment first!"
-        
-        try:
-            # Get current sentiment if enabled
-            current_sentiment = 0.5
-            sentiment_confidence = 0.0
-            sentiment_data = None
-            sentiment_analysis = None
-            
-            if self.use_sentiment:
-                sentiment_analysis = self.env.get_sentiment_analysis()
-                current_sentiment = sentiment_analysis.get('current_sentiment', 0.5)
-                sentiment_confidence = sentiment_analysis.get('sentiment_confidence', 0.0)
-                
-                # Update sentiment history
-                self.sentiment_history.append({
-                    'step': len(self.episode_history),
-                    'sentiment': current_sentiment,
-                    'confidence': sentiment_confidence,
-                    'timestamp': datetime.now()
-                })
-                if len(self.sentiment_history) > 50:
-                    self.sentiment_history.pop(0)
-            
-            # Select action with sentiment consideration
-            if action_choice == "AI Decision":
-                action = self.agent.select_action(
-                    self.current_state, 
-                    current_sentiment, 
-                    sentiment_confidence
-                )
-                action_source = "AI"
-            else:
-                action_mapping = {"Hold": 0, "Buy": 1, "Sell": 2, "Close": 3}
-                action = action_mapping[action_choice]
-                action_source = "Manual"
-            
-            print(f"Executing action: {action} ({action_source}) | Sentiment: {current_sentiment:.3f}")
-            
-            # Execute action
-            next_state, reward, done, info = self.env.step(action)
-            self.current_state = next_state
-            
-            # Update history
-            history_entry = {
-                'step': len(self.episode_history),
-                'action': action,
-                'reward': reward,
-                'net_worth': info['net_worth'],
-                'balance': info['balance'],
-                'position': info['position_size'],
-                'price': info['current_price'],
-                'action_source': action_source,
-                'sentiment': current_sentiment,
-                'sentiment_confidence': sentiment_confidence
-            }
-            self.episode_history.append(history_entry)
-            
-            # Create visualizations
-            price_chart = self.create_price_chart(info)
-            performance_chart = self.create_performance_chart()
-            action_chart = self.create_action_chart()
-            sentiment_chart = self.create_sentiment_chart()
-            
-            # Create status message
-            action_names = ["Hold", "Buy", "Sell", "Close"]
-            sentiment_label = "🔴 Bearish" if current_sentiment < 0.4 else "🟡 Neutral" if current_sentiment < 0.6 else "🟢 Bullish"
-            
-            status = (
-                f"✅ Step {info['step']} Completed!\n"
-                f"• Action: {action_names[action]} ({action_source})\n"
-                f"• Reward: {reward:.3f}\n"
-                f"• Net Worth: ${info['net_worth']:.2f}\n"
-                f"• Market Sentiment: {sentiment_label} ({current_sentiment:.3f})\n"
-                f"• Sentiment Confidence: {sentiment_confidence:.1%}"
-            )
-            
-            if done:
-                status += "\n🎯 Episode Completed!"
-            
-            return price_chart, performance_chart, action_chart, sentiment_chart, status
-            
-        except Exception as e:
-            error_msg = f"❌ Error during step execution: {str(e)}"
-            print(error_msg)
-            return None, None, None, None, error_msg
-    
-    def run_episode(self, num_steps=20):
-        """Run a complete episode with sentiment analysis"""
-        if not self.initialized or self.env is None or self.agent is None:
-            return None, None, None, None, "⚠️ Please initialize environment first!"
-        
-        try:
-            # Reset environment for new episode
-            self.current_state = self.env.reset()
-            self.episode_history = []
-            total_reward = 0
-            
-            print(f"Starting episode with {num_steps} steps...")
-            
-            for step in range(num_steps):
-                # Get current sentiment
-                current_sentiment = 0.5
-                sentiment_confidence = 0.0
-                
-                if self.use_sentiment:
-                    sentiment_info = self.env.get_sentiment_analysis()
-                    current_sentiment = sentiment_info.get('current_sentiment', 0.5)
-                    sentiment_confidence = sentiment_info.get('sentiment_confidence', 0.0)
-                
-                # Select action with sentiment
-                action = self.agent.select_action(self.current_state, current_sentiment, sentiment_confidence)
-                next_state, reward, done, info = self.env.step(action)
-                self.current_state = next_state
-                total_reward += reward
-                
-                # Store experience with sentiment data
-                sentiment_data = {
-                    'sentiment': current_sentiment,
-                    'confidence': sentiment_confidence
-                }
-                self.agent.store_transition(self.current_state, action, reward, next_state, done, sentiment_data)
-                
-                self.episode_history.append({
-                    'step': step,
-                    'action': action,
-                    'reward': reward,
-                    'net_worth': info['net_worth'],
-                    'price': info['current_price'],
-                    'sentiment': current_sentiment,
-                    'action_source': 'AI'
-                })
-                
-                # Small delay to make execution visible
-                time.sleep(0.05)
-                
-                if done:
-                    break
-            
-            # Create visualizations
-            price_chart = self.create_price_chart(info)
-            performance_chart = self.create_performance_chart()
-            action_chart = self.create_action_chart()
-            sentiment_chart = self.create_sentiment_chart()
-            
-            # Calculate performance metrics
-            initial_balance = self.env.initial_balance
-            final_net_worth = info['net_worth']
-            total_return = 0.0
-            if initial_balance > 0:
-                total_return = (final_net_worth - initial_balance) / initial_balance * 100
-            
-            # Calculate average sentiment
-            avg_sentiment = np.mean([h['sentiment'] for h in self.episode_history]) if self.episode_history else 0.5
-            
-            summary = (
-                f"🎯 Episode Completed!\n"
-                f"• Total Steps: {len(self.episode_history)}\n"
-                f"• Total Reward: {total_reward:.2f}\n"
-                f"• Final Net Worth: ${final_net_worth:.2f}\n"
-                f"• Total Return: {total_return:.2f}%\n"
-                f"• Average Sentiment: {avg_sentiment:.3f}\n"
-                f"• Total Trades: {info['total_trades']}"
-            )
-            
-            return price_chart, performance_chart, action_chart, sentiment_chart, summary
-            
-        except Exception as e:
-            error_msg = f"❌ Error during episode: {str(e)}"
-            print(error_msg)
-            return None, None, None, None, error_msg
-    
-    def get_sentiment_analysis_report(self):
-        """Get detailed sentiment analysis report"""
-        if not self.use_sentiment or not self.initialized:
-            return "❌ Sentiment analysis is not enabled"
-        
-        try:
-            sentiment_data = self.sentiment_analyzer.get_influencer_sentiment()
-            
-            report = (
-                f"📊 Real-time Market Sentiment Analysis\n"
-                f"• Overall Sentiment: {sentiment_data['market_sentiment']:.3f}\n"
-                f"• Confidence: {sentiment_data['confidence']:.1%}\n"
-                f"• Influencers Analyzed: {sentiment_data['influencer_count']}\n"
-                f"• Total Tweets: {sentiment_data['total_tweets']}\n"
-                f"• Last Update: {sentiment_data['timestamp']}"
-            )
-            
-            # Add top influencers
-            top_influencers = list(sentiment_data['breakdown'].items())[:3]
-            for username, data in top_influencers:
-                sentiment_emoji = "🔴" if data['score'] < 0.4 else "🟡" if data['score'] < 0.6 else "🟢"
-                report += f"\n• {sentiment_emoji} {username}: {data['score']:.3f} (conf: {data['confidence']:.1%})"
-            
-            return report
-            
-        except Exception as e:
-            return f"❌ Error getting sentiment report: {str(e)}"
+    def _initialize_live_data(self):
+        """Initialize live trading data"""
+        # Generate realistic initial data
+        base_price = 100
+        for i in range(50):
+            price = base_price + np.random.normal(0, 2)
+            self.live_data.append({
+                'timestamp': datetime.now() - timedelta(seconds=50-i),
+                'price': price,
+                'action': 0,
+                'net_worth': self.env.initial_balance if self.env else 10000
+            })
     
-    def train_agent(self, num_episodes, learning_rate):
-        """Train the AI agent with sentiment-enhanced learning"""
+    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, None, "⚠️ Please initialize environment first!"
+            yield "❌ لطفا اول محیط را راه‌اندازی کنید!", None
             return
         
         self.is_training = True
+        self.training_complete = False
         training_history = []
         
         try:
             num_episodes = int(num_episodes)
+            
             for episode in range(num_episodes):
                 state = self.env.reset()
                 episode_reward = 0.0
@@ -316,26 +118,9 @@ class ProfessionalTradingAIDemo:
                 steps = 0
                 
                 while not done and steps < 100:
-                    # Get sentiment for this step
-                    current_sentiment = 0.5
-                    sentiment_confidence = 0.0
-                    
-                    if self.use_sentiment:
-                        sentiment_info = self.env.get_sentiment_analysis()
-                        current_sentiment = sentiment_info.get('current_sentiment', 0.5)
-                        sentiment_confidence = sentiment_info.get('sentiment_confidence', 0.0)
-                    
-                    # Select action with sentiment
-                    action = self.agent.select_action(state, current_sentiment, sentiment_confidence)
+                    action = self.agent.select_action(state)
                     next_state, reward, done, info = self.env.step(action)
-                    
-                    # Store experience with sentiment data
-                    sentiment_data = {
-                        'sentiment': current_sentiment,
-                        'confidence': sentiment_confidence
-                    }
-                    self.agent.store_transition(state, action, reward, next_state, done, sentiment_data)
-                    
+                    self.agent.store_transition(state, action, reward, next_state, done)
                     state = next_state
                     episode_reward += reward
                     steps += 1
@@ -351,280 +136,286 @@ class ProfessionalTradingAIDemo:
                     'steps': steps
                 })
                 
-                # Yield progress every 5 episodes or at the end
-                if episode % 5 == 0 or episode == num_episodes - 1:
-                    progress_chart = self.create_training_progress(training_history)
-                    
-                    status = (
-                        f"🔄 Training Progress: {episode+1}/{num_episodes}\n"
-                        f"• Episode Reward: {episode_reward:.2f}\n"
-                        f"• Final Net Worth: ${info['net_worth']:.2f}\n"
-                        f"• Loss: {loss:.4f}\n"
-                        f"• Epsilon: {self.agent.epsilon:.3f}"
-                    )
-                    yield progress_chart, status
+                # Create real-time training progress
+                progress_chart = self._create_training_progress(training_history)
                 
-                time.sleep(0.01)
+                # 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}"
+                )
+                
+                yield status, progress_chart
+                time.sleep(0.1)
             
             self.is_training = False
-            
-            # Calculate average reward
-            rewards = [h['reward'] for h in training_history]
-            avg_reward = np.mean(rewards) if rewards else 0.0
-            
-            final_status = (
-                f"✅ Training Completed!\n"
-                f"• Total Episodes: {num_episodes}\n"
-                f"• Final Epsilon: {self.agent.epsilon:.3f}\n"
-                f"• Average Reward: {avg_reward:.2f}"
+            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 self.create_training_progress(training_history), final_status
+            
+            yield completion_status, self._create_training_progress(training_history)
             
         except Exception as e:
             self.is_training = False
-            error_msg = f"❌ Training error: {str(e)}"
-            print(f"Training error details: {e}")
-            yield None, error_msg
+            error_msg = f"❌ خطا در آموزش: {str(e)}"
+            print(f"Training error: {e}")
+            yield error_msg, None
     
-    def create_price_chart(self, info):
-        """Create price chart with actions and sentiment markers"""
-        if not self.episode_history:
-            fig = go.Figure()
-            fig.update_layout(
-                title="Price Chart - No Data Available",
-                xaxis_title="Time Step",
-                yaxis_title="Price",
-                height=300,
-                template="plotly_white"
-            )
-            return fig
-        
-        prices = [h['price'] for h in self.episode_history]
-        actions = [h['action'] for h in self.episode_history]
-        sentiments = [h.get('sentiment', 0.5) for h in self.episode_history]
-        
-        fig = go.Figure()
-        
-        # Price line
-        fig.add_trace(go.Scatter(
-            x=list(range(len(prices))),
-            y=prices,
-            mode='lines',
-            name='Price',
-            line=dict(color='blue', width=3)
-        ))
+    def start_live_trading(self):
+        """Start real-time live trading demo"""
+        if not self.training_complete:
+            return "❌ لطفا اول آموزش را کامل کنید!", None, None
+        
+        if self.live_trading:
+            return "⚠️ معامله Real-Time در حال اجراست!", 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()
+        
+        return "🎯 معامله Real-Time شروع شد!", self._create_live_chart(), self._create_performance_chart()
+    
+    def _live_trading_loop(self):
+        """Main live trading loop"""
+        step_count = 0
+        max_steps = 200  # Stop after 200 steps 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
+                current_time = datetime.now()
+                self.live_data.append({
+                    'timestamp': current_time,
+                    'price': info['current_price'],
+                    'action': action,
+                    'net_worth': info['net_worth']
+                })
+                
+                # Keep only last 100 data points
+                if len(self.live_data) > 100:
+                    self.live_data.pop(0)
+                
+                self.action_history.append({
+                    'step': step_count,
+                    'action': action,
+                    'reward': reward,
+                    'timestamp': current_time
+                })
+                
+                step_count += 1
+                time.sleep(1)  # 1 second between steps
+                
+            except Exception as e:
+                print(f"Error in live trading: {e}")
+                break
         
-        # Action markers with sentiment coloring
-        for i, (action, sentiment) in enumerate(zip(actions, sentiments)):
-            if action == 1:  # Buy
-                color = 'green' if sentiment > 0.6 else 'lightgreen' if sentiment > 0.4 else 'darkgreen'
-                fig.add_trace(go.Scatter(
-                    x=[i], y=[prices[i]],
-                    mode='markers',
-                    name='Buy' if i == 1 else '',
-                    marker=dict(color=color, size=12, symbol='triangle-up', 
-                              line=dict(width=2, color='darkgreen')),
-                    showlegend=False
-                ))
-            elif action == 2:  # Sell
-                color = 'red' if sentiment < 0.4 else 'lightcoral' if sentiment < 0.6 else 'darkred'
-                fig.add_trace(go.Scatter(
-                    x=[i], y=[prices[i]],
-                    mode='markers',
-                    name='Sell' if i == 2 else '',
-                    marker=dict(color=color, size=12, symbol='triangle-down', 
-                              line=dict(width=2, color='darkred')),
-                    showlegend=False
-                ))
-            elif action == 3:  # Close
-                fig.add_trace(go.Scatter(
-                    x=[i], y=[prices[i]],
-                    mode='markers',
-                    name='Close' if i == 3 else '',
-                    marker=dict(color='orange', size=10, symbol='x', 
-                              line=dict(width=2, color='darkorange')),
-                    showlegend=False
-                ))
+        self.live_trading = False
+    
+    def get_live_update(self):
+        """Get real-time update for the interface"""
+        if not self.live_trading:
+            return "🛑 معامله Real-Time متوقف شده", None, None
+        
+        current_data = self.live_data[-1] if self.live_data else None
+        if not current_data:
+            return "📊 در حال آماده‌سازی داده...", None, None
+        
+        action_names = ["نگهداری", "خرید", "فروش", "بستن"]
+        action = current_data['action']
+        action_text = action_names[action]
+        
+        status = (
+            f"🎯 معامله Real-Time در حال اجرا...\n"
+            f"💰 قیمت فعلی: ${current_data['price']:.2f}\n"
+            f"🎪 اقدام: {action_text}\n"
+            f"💼 ارزش پرتفولیو: ${current_data['net_worth']:.2f}\n"
+            f"⏰ آخرین بروزرسانی: {datetime.now().strftime('%H:%M:%S')}"
+        )
         
-        fig.update_layout(
-            title="Price Chart with Trading Actions (Colored by Sentiment)",
-            xaxis_title="Step",
-            yaxis_title="Price",
-            height=350,
-            showlegend=True,
-            template="plotly_white"
+        return status, self._create_live_chart(), self._create_performance_chart()
+    
+    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
+        
+        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)}"
         )
         
-        return fig
+        return performance, self._create_live_chart(), self._create_performance_chart()
     
-    def create_performance_chart(self):
-        """Create portfolio performance chart"""
-        if not self.episode_history:
+    def _create_live_chart(self):
+        """Create real-time trading chart"""
+        if not self.live_data:
             fig = go.Figure()
             fig.update_layout(
-                title="Portfolio Performance - No Data Available",
+                title="📊 نمودار Real-Time - در حال آماده‌سازی...",
                 height=400
             )
             return fig
         
-        net_worth = [h['net_worth'] for h in self.episode_history]
-        rewards = [h['reward'] for h in self.episode_history]
+        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]
         
-        fig = make_subplots(
-            rows=2, cols=1,
-            subplot_titles=['Portfolio Value Over Time', 'Step Rewards'],
-            vertical_spacing=0.15
-        )
+        fig = go.Figure()
         
-        # Portfolio value
+        # Price line
         fig.add_trace(go.Scatter(
-            x=list(range(len(net_worth))),
-            y=net_worth,
-            mode='lines+markers',
-            name='Net Worth',
-            line=dict(color='green', width=3),
-            marker=dict(size=4)
-        ), row=1, col=1)
-        
-        # Add initial balance reference line
-        if self.env:
-            fig.add_hline(y=self.env.initial_balance, line_dash="dash", 
-                         line_color="red", annotation_text="Initial Balance",
-                         row=1, col=1)
-        
-        # Rewards as bar chart
-        if rewards:
-            fig.add_trace(go.Bar(
-                x=list(range(len(rewards))),
-                y=rewards,
-                name='Reward',
-                marker_color=['green' if r >= 0 else 'red' for r in rewards],
-                opacity=0.7
-            ), row=2, col=1)
-        
-        fig.update_layout(height=500, showlegend=False, template="plotly_white")
-        fig.update_yaxes(title_text="Value ($)", row=1, col=1)
-        fig.update_yaxes(title_text="Reward", row=2, col=1)
-        fig.update_xaxes(title_text="Step", row=2, col=1)
+            x=times,
+            y=prices,
+            mode='lines',
+            name='قیمت',
+            line=dict(color='blue', width=3)
+        ))
         
-        return fig
-    
-    def create_action_chart(self):
-        """Create action distribution chart"""
-        if not self.episode_history:
-            fig = go.Figure()
-            fig.update_layout(
-                title="Action Distribution - No Data Available",
-                height=300
-            )
-            return fig
+        # 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]
         
-        actions = [h['action'] for h in self.episode_history]
-        action_names = ['Hold', 'Buy', 'Sell', 'Close']
-        action_counts = [actions.count(i) for i in range(4)]
+        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]
         
-        colors = ['blue', 'green', 'red', 'orange']
+        close_times = [times[i] for i, action in enumerate(actions) if action == 3]
+        close_prices = [prices[i] for i, action in enumerate(actions) if action == 3]
         
-        fig = go.Figure(data=[go.Pie(
-            labels=action_names,
-            values=action_counts,
-            hole=.4,
-            marker_colors=colors,
-            textinfo='label+percent+value',
-            hoverinfo='label+percent+value'
-        )])
+        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')
+            ))
+        
+        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')
+            ))
+        
+        if close_times:
+            fig.add_trace(go.Scatter(
+                x=close_times,
+                y=close_prices,
+                mode='markers',
+                name='بستن',
+                marker=dict(color='orange', size=8, symbol='x')
+            ))
         
         fig.update_layout(
-            title="Action Distribution",
-            height=350,
-            annotations=[dict(text='Actions', x=0.5, y=0.5, font_size=16, showarrow=False)],
+            title="🎯 نمودار معاملات Real-Time",
+            xaxis_title="زمان",
+            yaxis_title="قیمت",
+            height=400,
+            showlegend=True,
             template="plotly_white"
         )
         
         return fig
     
-    def create_sentiment_chart(self):
-        """Create sentiment analysis chart"""
-        if not self.sentiment_history:
+    def _create_performance_chart(self):
+        """Create performance chart"""
+        if not self.live_data:
             fig = go.Figure()
             fig.update_layout(
-                title="Sentiment Analysis - No Data Available",
+                title="📈 عملکرد پرتفولیو - در حال آماده‌سازی...",
                 height=300
             )
             return fig
         
-        steps = [h['step'] for h in self.sentiment_history]
-        sentiments = [h['sentiment'] for h in self.sentiment_history]
-        confidences = [h['confidence'] for h in self.sentiment_history]
+        times = [d['timestamp'] for d in self.live_data]
+        net_worths = [d['net_worth'] for d in self.live_data]
         
         fig = go.Figure()
         
-        # Sentiment line
         fig.add_trace(go.Scatter(
-            x=steps,
-            y=sentiments,
+            x=times,
+            y=net_worths,
             mode='lines+markers',
-            name='Market Sentiment',
-            line=dict(color='purple', width=3),
-            marker=dict(size=6)
-        ))
-        
-        # Confidence as shaded area
-        fig.add_trace(go.Scatter(
-            x=steps,
-            y=[s + c/2 for s, c in zip(sentiments, confidences)],
-            mode='lines',
-            name='Confidence Upper',
-            line=dict(width=0),
-            showlegend=False
-        ))
-        
-        fig.add_trace(go.Scatter(
-            x=steps,
-            y=[s - c/2 for s, c in zip(sentiments, confidences)],
-            mode='lines',
-            name='Confidence Lower',
-            fill='tonexty',
-            fillcolor='rgba(128, 0, 128, 0.2)',
-            line=dict(width=0),
-            showlegend=False
+            name='ارزش پرتفولیو',
+            line=dict(color='green', width=3),
+            marker=dict(size=4)
         ))
         
-        # Add sentiment level lines
-        fig.add_hline(y=0.6, line_dash="dash", line_color="green", annotation_text="Bullish Threshold")
-        fig.add_hline(y=0.4, line_dash="dash", line_color="red", annotation_text="Bearish Threshold")
+        # 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="Market Sentiment Analysis Over Time",
-            xaxis_title="Step",
-            yaxis_title="Sentiment Score",
-            height=350,
-            yaxis=dict(range=[0, 1]),
+            title="💼 عملکرد پرتف��لیو در زمان واقعی",
+            xaxis_title="زمان",
+            yaxis_title="ارزش ($)",
+            height=300,
             template="plotly_white"
         )
         
         return fig
     
-    def create_training_progress(self, training_history):
+    def _create_training_progress(self, training_history):
         """Create training progress visualization"""
         if not training_history:
             fig = go.Figure()
             fig.update_layout(
-                title="Training Progress - No Data Available",
-                height=500
+                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]
-        losses = [h.get('loss', 0) for h in training_history]
         
         fig = make_subplots(
-            rows=2, cols=2,
-            subplot_titles=['Episode Rewards', 'Portfolio Value',
-                          'Training Loss', 'Moving Average Reward (5)'],
-            specs=[[{}, {}], [{}, {}]]
+            rows=2, cols=1,
+            subplot_titles=['📈 Reward اپیزودها', '💰 ارزش پرتفولیو'],
+            vertical_spacing=0.15
         )
         
         # Rewards
@@ -639,60 +430,39 @@ class ProfessionalTradingAIDemo:
             x=episodes, y=net_worths, mode='lines+markers',
             name='Net Worth', line=dict(color='green', width=2),
             marker=dict(size=4)
-        ), row=1, col=2)
-        
-        # Loss
-        if any(loss > 0 for loss in losses):
-            fig.add_trace(go.Scatter(
-                x=episodes, y=losses, mode='lines+markers',
-                name='Loss', line=dict(color='red', width=2),
-                marker=dict(size=4)
-            ), row=2, col=1)
-        
-        # Moving average reward
-        if len(rewards) > 5:
-            ma_rewards = []
-            for i in range(len(rewards)):
-                start_idx = max(0, i - 4)
-                ma = np.mean(rewards[start_idx:i+1])
-                ma_rewards.append(ma)
-            
-            fig.add_trace(go.Scatter(
-                x=episodes, y=ma_rewards, mode='lines',
-                name='MA Reward (5)', line=dict(color='orange', width=3, dash='dash')
-            ), row=2, col=2)
+        ), row=2, col=1)
         
         fig.update_layout(
-            height=600, 
+            height=400, 
             showlegend=True, 
-            title_text="Training Progress Over Episodes",
+            title_text="🎯 پیشرفت آموزش هوش مصنوعی",
             template="plotly_white"
         )
         
         return fig
 
 # Initialize the demo
-demo = ProfessionalTradingAIDemo()
+demo = RealTimeTradingDemo()
 
 # Create Gradio interface
 def create_interface():
-    with gr.Blocks(theme=gr.themes.Soft(), title="Professional Trading AI") as interface:
+    with gr.Blocks(theme=gr.themes.Soft(), title="Real-Time Trading AI") as interface:
         gr.Markdown("""
-        # 🚀 Professional Trading AI
-        **ترکیب هوش مصنوعی پیشرفته: تحلیل توئییت + CNN + یادگیری تقویتی**
+        # 🚀 هوش مصنوعی معامله‌گر Real-Time
+        **آموزش و اجرای بلادرنگ روی نمودارهای زنده**
         
-        *این سیستم از **تحلیل احساسات توئییت‌های افراد تاثیرگذار**، **پردازش بصری نمودارها با CNN** و **یادگیری تقویتی** برای تصمیم‌گیری هوشمند استفاده می‌کند.*
+        *این سیستم ابتدا هوش مصنوعی را آموزش می‌دهد، سپس به صورت Real-Time روی بازار معامله می‌کند*
         """)
         
         with gr.Row():
             with gr.Column(scale=1):
                 # Configuration section
-                gr.Markdown("## ⚙️ پیکربندی حرفه‌ای")
+                gr.Markdown("## ⚙️ پیکربندی سیستم")
                 
                 with gr.Row():
                     initial_balance = gr.Slider(
                         minimum=1000, maximum=50000, value=10000, step=1000,
-                        label="موجودی اولیه ($)", info="میزان سرمایه اولیه"
+                        label="سرمایه اولیه ($)"
                     )
                 
                 with gr.Row():
@@ -705,240 +475,138 @@ def create_interface():
                 with gr.Row():
                     asset_type = gr.Radio(
                         ["Stock", "Crypto", "Forex"], 
-                        value="Crypto",
+                        value="Stock",
                         label="نوع دارایی"
                     )
                 
-                with gr.Row():
-                    use_sentiment = gr.Checkbox(
-                        value=True,
-                        label="فعال‌سازی تحلیل احساسات توئییت",
-                        info="آنالیز توئییت‌های افراد تاثیرگذار"
-                    )
-                
-                with gr.Row():
-                    sentiment_influence = gr.Slider(
-                        minimum=0.1, maximum=0.8, value=0.3, step=0.1,
-                        label="تاثیر تحلیل احساسات",
-                        info="میزان تاثیرگذاری تحلیل توئییت‌ها بر تصمیم‌ها"
-                    )
-                
                 with gr.Row():
                     init_btn = gr.Button(
-                        "🚀 راه‌اندازی سیستم حرفه‌ای", 
-                        variant="primary",
-                        size="lg"
+                        "🚀 راه‌اندازی محیط", 
+                        variant="primary"
                     )
                 
                 with gr.Row():
                     init_status = gr.Textbox(
-                        label="وضعیت راه‌اندازی",
+                        label="وضعیت سیستم",
                         interactive=False,
                         lines=3
                     )
             
             with gr.Column(scale=2):
                 # Status output
-                gr.Markdown("## 📊 وضعیت معاملات")
+                gr.Markdown("## 📊 وضعیت جاری")
                 status_output = gr.Textbox(
-                    label="وضعیت اجرا",
+                    label="وضعیت عملیات",
                     interactive=False,
-                    lines=5
+                    lines=4
                 )
         
         with gr.Row():
-            gr.Markdown("## 🎮 کنترل معاملات")
-            
-        with gr.Row():
-            # Action controls
-            action_choice = gr.Radio(
-                ["AI Decision", "Buy", "Sell", "Hold", "Close"],
-                value="AI Decision",
-                label="انتخاب اقدام",
-                info="AI Decision: ترکیب CNN + RL + تحلیل احساسات"
-            )
+            gr.Markdown("## 🎓 فاز ۱: آموزش هوش مصنوعی")
             
         with gr.Row():
             with gr.Column(scale=1):
-                step_btn = gr.Button(
-                    "▶️ اجرای یک قدم", 
-                    variant="secondary",
-                    size="lg"
-                )
-            
-            with gr.Column(scale=1):
-                episode_btn = gr.Button(
-                    "🎯 اجرای یک اپیزود (20 قدم)", 
-                    variant="secondary",
-                    size="lg"
+                num_episodes = gr.Slider(
+                    minimum=10, maximum=100, value=30, step=5,
+                    label="تعداد اپیزودهای آموزش"
                 )
-            
-            with gr.Column(scale=1):
-                sentiment_btn = gr.Button(
-                    "📊 گزارش تحلیل احساسات", 
-                    variant="secondary",
+                
+                train_btn = gr.Button(
+                    "🤖 شروع آموزش", 
+                    variant="primary",
                     size="lg"
                 )
-        
-        with gr.Row():
-            # Visualization outputs
-            with gr.Column(scale=1):
-                price_chart = gr.Plot(
-                    label="📈 نمودار قیمت و اقدامات"
-                )
-            
-            with gr.Column(scale=1):
-                performance_chart = gr.Plot(
-                    label="💰 عملکرد پرتفولیو"
-                )
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                action_chart = gr.Plot(
-                    label="🎯 توزیع اقدامات"
-                )
             
-            with gr.Column(scale=1):
-                sentiment_chart = gr.Plot(
-                    label="😊 تحلیل احساسات بازار"
+            with gr.Column(scale=2):
+                training_plot = gr.Plot(
+                    label="📈 پیشرفت آموزش"
                 )
         
         with gr.Row():
-            gr.Markdown("## 🎓 آموزش هوش مصنوعی")
+            gr.Markdown("## 🎯 فاز ۲: معامله Real-Time")
             
         with gr.Row():
             with gr.Column(scale=1):
-                num_episodes = gr.Slider(
-                    minimum=10, maximum=200, value=50, step=10,
-                    label="تعداد اپیزودهای آموزش"
-                )
-                
-                learning_rate = gr.Slider(
-                    minimum=0.0001, maximum=0.01, value=0.001, step=0.0001,
-                    label="نرخ یادگیری"
+                start_btn = gr.Button(
+                    "▶️ شروع معامله Real-Time", 
+                    variant="secondary",
+                    size="lg"
                 )
                 
-                train_btn = gr.Button(
-                    "🤖 شروع آموزش پیشرفته", 
-                    variant="primary",
+                stop_btn = gr.Button(
+                    "⏹️ توقف معامله", 
+                    variant="stop",
                     size="lg"
                 )
             
-            with gr.Column(scale=2):
-                training_plot = gr.Plot(
-                    label="📊 پیشرفت آموزش"
-                )
-                
-                training_status = gr.Textbox(
-                    label="وضعیت آموزش",
-                    interactive=False,
-                    lines=3
+            with gr.Column(scale=1):
+                update_btn = gr.Button(
+                    "🔄 بروزرسانی لحظه‌ای", 
+                    variant="secondary",
+                    size="lg"
                 )
         
-        with gr.Row():
-            gr.Markdown("## 🧠 معماری هوش مصنوعی پیشرفته")
-            
         with gr.Row():
             with gr.Column(scale=1):
-                gr.Markdown("""
-                **🎯 تحلیل احساسات توئییت:**
-                - آنالیز توئییت‌های ۸ فرد تاثیرگذار
-                - استفاده از ۵ مدل مختلف sentiment analysis
-                - تشخیص فوریت و کلمات کلیدی
-                - وزن‌دهی بر اساس اعتبار افراد
-                
-                **🖼️ CNN (پردازش بصری):**
-                - تحلیل تصاویر نمودارهای قیمت
-                - تشخیص الگوهای تکنیکال
-                - استخراج ویژگی‌های بصری
-                - ورودی: تصاویر 84x84 پیکسل
-                """)
+                live_chart = gr.Plot(
+                    label="📊 نمودار معاملات Real-Time"
+                )
             
             with gr.Column(scale=1):
-                gr.Markdown("""
-                **🤖 Reinforcement Learning:**
-                - الگوریتم Deep Q-Network پیشرفته
-                - ترکیب داده‌های بصری و احساساتی
-                - یادگیری از طریق تعامل با محیط
-                - تجربه replay برای یادگیری پایدار
-                
-                **📊 افراد تاثیرگذار تحت نظر:**
-                - Elon Musk, CZ Binance, Michael Saylor
-                - Peter Brandt, Nic Carter, Andreas Antonopoulos
-                - و سایر متخصصان بازار
-                """)
+                performance_chart = gr.Plot(
+                    label="💼 عملکرد پرتفولیو"
+                )
         
         # Event handlers
         init_btn.click(
             demo.initialize_environment,
-            inputs=[initial_balance, risk_level, asset_type, use_sentiment, sentiment_influence],
+            inputs=[initial_balance, risk_level, asset_type],
             outputs=[init_status]
         )
         
-        step_btn.click(
-            demo.run_single_step,
-            inputs=[action_choice],
-            outputs=[price_chart, performance_chart, action_chart, sentiment_chart, status_output]
+        train_btn.click(
+            demo.train_agent,
+            inputs=[num_episodes],
+            outputs=[status_output, training_plot]
         )
         
-        episode_btn.click(
-            demo.run_episode,
+        start_btn.click(
+            demo.start_live_trading,
             inputs=[],
-            outputs=[price_chart, performance_chart, action_chart, sentiment_chart, status_output]
+            outputs=[status_output, live_chart, performance_chart]
         )
         
-        sentiment_btn.click(
-            demo.get_sentiment_analysis_report,
+        update_btn.click(
+            demo.get_live_update,
             inputs=[],
-            outputs=[status_output]
+            outputs=[status_output, live_chart, performance_chart]
         )
         
-        train_btn.click(
-            demo.train_agent,
-            inputs=[num_episodes, learning_rate],
-            outputs=[training_plot, training_status]
+        stop_btn.click(
+            demo.stop_live_trading,
+            inputs=[],
+            outputs=[status_output, live_chart, performance_chart]
         )
         
         gr.Markdown("""
-        ## 🏗 جزئیات فنی پیشرفته
-        
-        **🎯 ترکیب سه تکنولوژی:**
-        - **تحلیل احساسات**: ۵ مدل مختلف + VADER + TextBlob
-        - **پردازش بصری**: CNN با ۳ لایه کانولوشن
-        - **یادگیری تقویتی**: DQN پیشرفته با تجربه replay
-        
-        **🛠 فناوری‌های به کار رفته:**
-        - **Transformers**: Hugging Face برای تحلیل ا��ساسات
-        - **PyTorch**: پیاده‌سازی CNN و RL
-        - **Gradio**: رابط کاربری پیشرفته
-        - **Plotly**: ویژوالیزیشن حرفه‌ای
-        
-        **📊 افراد تاثیرگذار تحت نظر:**
-        - Elon Musk (تاثیر: ۹۰٪) - همه بازارها
-        - CZ Binance (تاثیر: ۸۰٪) - بازار کریپتو
-        - Michael Saylor (تاثیر: ۷۰٪) - بیت‌کوین
-        - و ۵ فرد تاثیرگذار دیگر
-        
-        *سیستم حرفه‌ای توسعه داده شده توسط Omid Sakaki - 2024*
+        ## 🧠 نحوه کار سیستم:
+        
+        1. **راه‌اندازی محیط**: تنظیم پارامترهای اولیه
+        2. **آموزش هوش مصنوعی**: آموزش مدل با ۳۰ اپیزود
+        3. **معامله Real-Time**: اجرای بلادرنگ روی نمودار زنده
+        4. **مانیتورینگ**: مشاهده عملکرد لحظه‌ای
+        
+        *توسعه داده شده توسط Omid Sakaki - 2024*
         """)
     
     return interface
 
 # Create and launch interface
 if __name__ == "__main__":
-    print("🚀 Starting Professional Trading AI Application...")
-    print("🧠 Loading: Sentiment Analysis + CNN + Reinforcement Learning...")
-    
+    print("🚀 Starting Real-Time Trading AI Demo...")
     interface = create_interface()
-    
-    print("✅ All components initialized successfully!")
-    print("🌐 Starting server on http://0.0.0.0:7860")
-    print("📱 Access the professional trading AI in your browser")
-    
     interface.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
-        show_error=True,
-        debug=True
+        share=False
     )