Update app.py

app.py

@@ -16,14 +16,21 @@ class RealTimeMarketData:
         self.data_history = {symbol: [] for symbol in symbols}
         self.timestamps = []
         self.update_counter = 0
+        self.last_update = datetime.now()
         
     def generate_live_data(self):
         """Generate realistic live market data with actual changes"""
-        self.update_counter += 1
         current_time = datetime.now()
         
-        # Keep only last 20 timestamps for performance
-        if len(self.timestamps) > 20:
+        # Update every 10 seconds
+        if (current_time - self.last_update).seconds < 10 and self.update_counter > 0:
+            return self.get_current_data()
+            
+        self.update_counter += 1
+        self.last_update = current_time
+        
+        # Keep only last 15 timestamps for performance
+        if len(self.timestamps) > 15:
             self.timestamps.pop(0)
         
         self.timestamps.append(current_time.strftime('%H:%M:%S'))
@@ -35,18 +42,17 @@ class RealTimeMarketData:
                 # Get actual current price from Yahoo Finance
                 ticker = yf.Ticker(symbol)
                 current_info = ticker.info
-                current_price = current_info.get('currentPrice', 
-                               current_info.get('regularMarketPrice', 
-                               current_info.get('previousClose', 150)))
+                base_price = current_info.get('currentPrice', 
+                             current_info.get('regularMarketPrice', 
+                             current_info.get('previousClose', 150)))
                 
-                # Add some realistic random movement
+                # Add realistic random movement
                 if symbol in self.last_prices:
-                    # Realistic price change based on previous price
-                    change_pct = np.random.normal(0, 0.5)  # 0.5% std dev
+                    # More visible changes for demo (1-3%)
+                    change_pct = np.random.uniform(-2, 2)
                     current_price = self.last_prices[symbol] * (1 + change_pct/100)
                 else:
-                    # First time - use actual price with small variation
-                    current_price = current_price * (1 + np.random.uniform(-0.01, 0.01))
+                    current_price = base_price
                 
                 self.last_prices[symbol] = current_price
                 
@@ -56,11 +62,17 @@ class RealTimeMarketData:
                 
                 self.data_history[symbol].append(current_price)
                 
-                # Keep only last 20 prices
-                if len(self.data_history[symbol]) > 20:
+                # Keep only last 15 prices
+                if len(self.data_history[symbol]) > 15:
                     self.data_history[symbol].pop(0)
                 
-                # Calculate change from first point in current session
+                # Ensure timestamps match
+                current_timestamps = self.timestamps[-len(self.data_history[symbol]):]
+                if len(current_timestamps) != len(self.data_history[symbol]):
+                    current_timestamps = [f"{(datetime.now() - timedelta(seconds=i*10)).strftime('%H:%M:%S')}" 
+                                        for i in range(len(self.data_history[symbol])-1, -1, -1)]
+                
+                # Calculate change
                 if len(self.data_history[symbol]) > 1:
                     change = ((current_price - self.data_history[symbol][0]) / 
                              self.data_history[symbol][0]) * 100
@@ -69,27 +81,27 @@ class RealTimeMarketData:
                 
                 live_data[symbol] = {
                     'prices': self.data_history[symbol].copy(),
-                    'timestamps': self.timestamps[-len(self.data_history[symbol]):],
+                    'timestamps': current_timestamps,
                     'current_price': current_price,
                     'change': change,
                     'volume': np.random.randint(1000000, 5000000),
-                    'update_count': self.update_counter
+                    'update_count': self.update_counter,
+                    'last_updated': current_time.strftime('%H:%M:%S')
                 }
                 
             except Exception as e:
-                # Fallback to simulated data
                 print(f"Error with {symbol}: {e}")
                 live_data[symbol] = self._generate_simulated_data(symbol)
         
         return live_data
     
     def _generate_simulated_data(self, symbol):
-        """Generate realistic simulated data with actual movement"""
+        """Generate realistic simulated data"""
         if symbol not in self.last_prices:
             self.last_prices[symbol] = np.random.uniform(150, 250)
         
-        # Realistic price movement
-        change_pct = np.random.normal(0, 0.8)  # More volatility for visibility
+        # Visible price movement for demo
+        change_pct = np.random.uniform(-2.5, 2.5)
         new_price = self.last_prices[symbol] * (1 + change_pct/100)
         self.last_prices[symbol] = new_price
         
@@ -99,15 +111,12 @@ class RealTimeMarketData:
         
         self.data_history[symbol].append(new_price)
         
-        # Keep history manageable
-        if len(self.data_history[symbol]) > 20:
+        if len(self.data_history[symbol]) > 15:
             self.data_history[symbol].pop(0)
         
-        # Ensure timestamps match prices length
-        current_timestamps = self.timestamps[-len(self.data_history[symbol]):]
-        if len(current_timestamps) != len(self.data_history[symbol]):
-            current_timestamps = [f"{(datetime.now() - timedelta(seconds=i)).strftime('%H:%M:%S')}" 
-                                for i in range(len(self.data_history[symbol])-1, -1, -1)]
+        # Generate timestamps
+        current_timestamps = [f"{(datetime.now() - timedelta(seconds=i*10)).strftime('%H:%M:%S')}" 
+                            for i in range(len(self.data_history[symbol])-1, -1, -1)]
         
         change = ((new_price - self.data_history[symbol][0]) / self.data_history[symbol][0]) * 100
         
@@ -117,8 +126,26 @@ class RealTimeMarketData:
             'current_price': new_price,
             'change': change,
             'volume': np.random.randint(1000000, 5000000),
-            'update_count': self.update_counter
+            'update_count': self.update_counter,
+            'last_updated': datetime.now().strftime('%H:%M:%S')
         }
+    
+    def get_current_data(self):
+        """Return current data without updating"""
+        live_data = {}
+        for symbol in self.symbols:
+            if symbol in self.data_history and self.data_history[symbol]:
+                live_data[symbol] = {
+                    'prices': self.data_history[symbol].copy(),
+                    'timestamps': self.timestamps[-len(self.data_history[symbol]):],
+                    'current_price': self.last_prices.get(symbol, 150),
+                    'change': ((self.last_prices.get(symbol, 150) - self.data_history[symbol][0]) / 
+                             self.data_history[symbol][0] * 100) if self.data_history[symbol] else 0,
+                    'volume': np.random.randint(1000000, 5000000),
+                    'update_count': self.update_counter,
+                    'last_updated': self.last_update.strftime('%H:%M:%S')
+                }
+        return live_data
 
 class AI_TradingAgents:
     def __init__(self):
@@ -128,7 +155,7 @@ class AI_TradingAgents:
             'risk': {'name': 'Risk Agent', 'emoji': '🛡️'},
             'decision': {'name': 'Decision Engine', 'emoji': '🎯'}
         }
-        self.analysis_history = {}
+        self.last_analysis = {}
     
     def analyze_market(self, symbol, market_data):
         if symbol not in market_data:
@@ -136,71 +163,93 @@ class AI_TradingAgents:
         
         data = market_data[symbol]
         current_price = data['current_price']
+        change = data['change']
         
-        # Make analysis change with price movements
-        price_trend = "Bullish" if data['change'] > 0 else "Bearish"
-        volatility = abs(data['change'])
-        
+        # Make analysis dynamic based on price changes
         analyses = {}
         
-        # Research Agent - changes based on trend
-        if price_trend == "Bullish":
-            analyses['research'] = {
-                'emoji': '📊',
-                'title': 'Fundamental Analysis',
-                'analysis': f"**Bullish Fundamentals** 📈\n\n• Strong earnings growth\n• Positive market sentiment\n• Institutional buying\n• **Recommendation: BUY** (85% confidence)\n• Target: ${current_price * 1.15:.2f}",
-                'confidence': 85
-            }
+        # Research Agent
+        if change > 1.5:
+            research_text = f"**Bullish Momentum** 🚀\n\n• Strong price action\n• Positive market sentiment\n• Institutional interest growing\n• **Recommendation: BUY** (88% confidence)\n• Target: ${current_price * 1.12:.2f}"
+            research_conf = 88
+        elif change < -1.5:
+            research_text = f"**Bearish Pressure** 📉\n\n• Price weakness evident\n• Consider waiting for stabilization\n• Support at ${current_price * 0.95:.2f}\n• **Recommendation: HOLD** (72% confidence)"
+            research_conf = 72
         else:
-            analyses['research'] = {
-                'emoji': '📊',
-                'title': 'Fundamental Analysis', 
-                'analysis': f"**Caution Advised** ⚠️\n\n• Mixed fundamentals\n• Wait for confirmation\n• **Recommendation: HOLD** (70% confidence)\n• Support: ${current_price * 0.95:.2f}",
-                'confidence': 70
-            }
+            research_text = f"**Consolidation Phase** ⚖️\n\n• Sideways movement\n• Awaiting catalyst\n• Good risk-reward setup\n• **Recommendation: HOLD** (78% confidence)"
+            research_conf = 78
+        
+        analyses['research'] = {
+            'emoji': '📊',
+            'title': 'Fundamental Analysis',
+            'analysis': research_text,
+            'confidence': research_conf
+        }
+        
+        # Technical Agent
+        rsi_level = "Overbought" if change > 2 else "Oversold" if change < -2 else "Neutral"
+        trend = "Bullish" if change > 0 else "Bearish"
         
-        # Technical Agent - dynamic analysis
-        rsi = "Oversold" if data['change'] < -2 else "Overbought" if data['change'] > 2 else "Neutral"
         analyses['technical'] = {
             'emoji': '📈',
             'title': 'Technical Analysis',
-            'analysis': f"**{rsi} Conditions**\n\n• Current: ${current_price:.2f}\n• Change: {data['change']:+.2f}%\n• Trend: {price_trend}\n• RSI: {60 if data['change'] > 0 else 40}\n• Volume: {data['volume']:,}",
+            'analysis': f"**{rsi_level} - {trend} Trend**\n\n• Price: ${current_price:.2f}\n• Change: {change:+.2f}%\n• RSI: {65 if change > 0 else 35}\n• Volume: {data['volume']:,}\n• Momentum: {'Positive' if change > 0 else 'Negative'}",
             'confidence': 75
         }
         
-        # Risk Agent - volatility based
-        risk_level = "High" if volatility > 3 else "Medium" if volatility > 1 else "Low"
+        # Risk Agent
+        volatility = abs(change)
+        if volatility > 3:
+            risk_level = "HIGH"
+            position_size = "1-2%"
+            stop_loss = "10%"
+        elif volatility > 1.5:
+            risk_level = "MEDIUM"
+            position_size = "2-3%"
+            stop_loss = "8%"
+        else:
+            risk_level = "LOW"
+            position_size = "3-4%"
+            stop_loss = "6%"
+        
         analyses['risk'] = {
             'emoji': '🛡️',
             'title': 'Risk Assessment',
-            'analysis': f"**{risk_level} Risk**\n\n• Volatility: {volatility:.1f}%\n• Position: {3 if risk_level == 'Low' else 2}%\n• Stop-loss: {8 if risk_level == 'High' else 6}%\n• Risk-Reward: 1:{2.5 if risk_level == 'Low' else 2.0}",
+            'analysis': f"**{risk_level} RISK**\n\n• Volatility: {volatility:.1f}%\n• Position Size: {position_size}\n• Stop-Loss: {stop_loss}\n• Risk-Reward: 1:{3 if risk_level == 'LOW' else 2}\n• Monitoring: {'Intensive' if risk_level == 'HIGH' else 'Standard'}",
             'confidence': 80
         }
         
-        # Decision Engine - dynamic decision
-        if data['change'] > 2 and volatility < 4:
+        # Decision Engine
+        if change > 2 and volatility < 4:
             decision = "BUY"
             confidence = 85
-            reason = "Strong bullish momentum with controlled risk"
-        elif data['change'] < -1:
-            decision = "SELL" 
-            confidence = 75
-            reason = "Bearish pressure building"
+            reason = "Strong uptrend with controlled risk"
+            action = "Enter long position with trailing stop"
+        elif change < -2:
+            decision = "SELL"
+            confidence = 78
+            reason = "Significant downward pressure"
+            action = "Consider short opportunities or wait"
+        elif abs(change) < 0.5:
+            decision = "HOLD"
+            confidence = 65
+            reason = "Minimal movement, awaiting direction"
+            action = "Monitor for breakout signals"
         else:
             decision = "HOLD"
             confidence = 70
-            reason = "Waiting for clearer signals"
+            reason = "Moderate movement, needs confirmation"
+            action = "Wait for clearer trend establishment"
         
         analyses['decision'] = {
             'emoji': '🎯',
             'title': 'Trading Decision',
-            'analysis': f"**{decision}** 🎯\n\nConfidence: {confidence}%\nPrice: ${current_price:.2f}\nReason: {reason}\n\nAction: {'Enter position' if decision == 'BUY' else 'Wait for setup'}",
+            'analysis': f"**{decision}** 🎯\n\n**Confidence:** {confidence}%\n**Current Price:** ${current_price:.2f}\n**Price Change:** {change:+.2f}%\n**Reason:** {reason}\n\n**Action:** {action}",
             'confidence': confidence,
             'decision': decision
         }
         
-        # Store analysis for tracking changes
-        self.analysis_history[symbol] = analyses
+        self.last_analysis[symbol] = analyses
         return analyses
     
     def _get_error_analysis(self, symbol):
@@ -216,25 +265,25 @@ market_data = RealTimeMarketData()
 trading_agents = AI_TradingAgents()
 
 def create_live_dashboard():
-    """Create dashboard with genuinely live data"""
-    # Get fresh data every call
+    """Create auto-updating dashboard"""
     live_data = market_data.generate_live_data()
     
     fig = make_subplots(
         rows=2, cols=2,
         subplot_titles=[
-            '📈 Live Price Movement',
+            '📈 Live Price Movement (Auto-Refresh)',
             '📊 Real-Time Performance', 
             '🔄 Minute-by-Minute Changes',
-            '🎯 Market Overview'
+            '🎯 Market Sentiment'
         ],
         specs=[
             [{"type": "scatter"}, {"type": "bar"}],
             [{"type": "scatter"}, {"type": "pie"}]
-        ]
+        ],
+        vertical_spacing=0.12
     )
     
-    # 1. Live price lines with actual movement
+    # 1. Live price lines
     colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4']
     for i, (symbol, data) in enumerate(live_data.items()):
         fig.add_trace(
@@ -242,103 +291,111 @@ def create_live_dashboard():
                 x=data['timestamps'],
                 y=data['prices'],
                 mode='lines+markers',
-                name=symbol,
-                line=dict(color=colors[i], width=3),
+                name=f'{symbol}',
+                line=dict(color=colors[i % len(colors)], width=3),
                 marker=dict(size=6),
-                hovertemplate=f'<b>{symbol}</b><br>%{{x}}<br>$%{{y:.2f}}<extra></extra>'
+                hovertemplate=f'<b>{symbol}</b><br>%{{x}}<br>$%{{y:.2f}}<br>Change: {data["change"]:+.2f}%<extra></extra>'
             ),
             row=1, col=1
         )
     
-    # 2. Performance bars that actually change
+    # 2. Performance bars
     symbols = list(live_data.keys())
     changes = [live_data[s]['change'] for s in symbols]
+    current_prices = [live_data[s]['current_price'] for s in symbols]
     
     fig.add_trace(
         go.Bar(
             x=symbols,
             y=changes,
-            marker_color=['green' if c > 0 else 'red' for c in changes],
-            text=[f"{c:+.2f}%" for c in changes],
+            marker_color=['#00CC96' if c > 0 else '#EF553B' for c in changes],
+            text=[f"${p:.2f}\n({c:+.2f}%)" for p, c in zip(current_prices, changes)],
             textposition='auto',
-            name='Change %'
+            name='Performance'
         ),
         row=1, col=2
     )
     
-    # 3. Price changes in last few minutes
+    # 3. Recent changes
     if live_data:
         first_symbol = list(live_data.keys())[0]
         data = live_data[first_symbol]
-        if len(data['prices']) > 5:
+        if len(data['prices']) > 3:
             recent_changes = []
-            for i in range(1, min(6, len(data['prices']))):
+            for i in range(1, min(4, len(data['prices']))):
                 change = ((data['prices'][-i] - data['prices'][-i-1]) / data['prices'][-i-1]) * 100
                 recent_changes.append(change)
             
             fig.add_trace(
                 go.Scatter(
-                    x=data['timestamps'][-5:],
+                    x=data['timestamps'][-3:],
                     y=recent_changes[::-1],
                     mode='lines+markers+text',
                     name='Recent Changes',
                     line=dict(color='#FECA57', width=4),
-                    marker=dict(size=8),
+                    marker=dict(size=10),
                     text=[f"{c:+.2f}%" for c in recent_changes[::-1]],
                     textposition='top center'
                 ),
                 row=2, col=1
             )
     
-    # 4. Market sentiment that updates
+    # 4. Market sentiment
     bullish = len([d for d in live_data.values() if d['change'] > 0])
     bearish = len([d for d in live_data.values() if d['change'] < 0])
+    neutral = len([d for d in live_data.values() if d['change'] == 0])
     
     fig.add_trace(
         go.Pie(
-            labels=['Bullish', 'Bearish'],
-            values=[bullish, bearish],
+            labels=['Bullish', 'Bearish', 'Neutral'],
+            values=[bullish, bearish, neutral],
             hole=0.4,
-            marker_colors=['#00CC96', '#EF553B'],
-            name='Sentiment'
+            marker_colors=['#00CC96', '#EF553B', '#636EFA'],
+            name='Market Sentiment'
         ),
         row=2, col=2
     )
     
     fig.update_layout(
         height=800,
-        title_text=f"🔄 LIVE TRADING DASHBOARD - Update #{market_data.update_counter}",
+        title_text=f"🔄 AUTO-REFRESHING LIVE DASHBOARD • Update #{market_data.update_counter} • {datetime.now().strftime('%H:%M:%S')}",
         template='plotly_dark',
-        showlegend=True
+        showlegend=True,
+        font=dict(size=12)
     )
     
     return fig, live_data
 
 def generate_analysis(symbol_input, live_data):
-    """Generate analysis that changes with market data"""
+    """Generate dynamic analysis"""
     if not symbol_input:
-        # Show overview
-        analysis_text = "# 📊 Market Overview\n\n"
+        # Market overview
+        analysis_text = f"# 📊 Live Market Overview\n\n"
+        analysis_text += f"**Last Update:** {datetime.now().strftime('%H:%M:%S')}\n"
+        analysis_text += f"**Total Updates:** {market_data.update_counter}\n\n"
+        
         for symbol, data in live_data.items():
             analysis = trading_agents.analyze_market(symbol, live_data)
             decision = analysis['decision']
             
-            analysis_text += f"## {symbol}\n"
+            trend_emoji = "🟢" if data['change'] > 0 else "🔴" if data['change'] < 0 else "🟡"
+            analysis_text += f"## {trend_emoji} {symbol}\n"
             analysis_text += f"**Price:** ${data['current_price']:.2f} | "
             analysis_text += f"**Change:** {data['change']:+.2f}%\n"
-            analysis_text += f"**Decision:** {decision['decision']} ({decision['confidence']}%)\n\n"
+            analysis_text += f"**Decision:** {decision['decision']} ({decision['confidence']}% confidence)\n\n"
         
         return analysis_text
     else:
         # Specific symbol analysis
-        symbol = symbol_input.upper()
+        symbol = symbol_input.upper().strip()
         if symbol in live_data:
             analysis = trading_agents.analyze_market(symbol, live_data)
             
-            analysis_text = f"# 🎯 {symbol} Analysis\n\n"
-            analysis_text += f"**Live Price:** ${live_data[symbol]['current_price']:.2f}\n"
-            analysis_text += f"**Change:** {live_data[symbol]['change']:+.2f}%\n"
-            analysis_text += f"**Last Update:** {datetime.now().strftime('%H:%M:%S')}\n\n"
+            analysis_text = f"# 🎯 {symbol} Live Analysis\n\n"
+            analysis_text += f"**Current Price:** ${live_data[symbol]['current_price']:.2f}\n"
+            analysis_text += f"**24h Change:** {live_data[symbol]['change']:+.2f}%\n"
+            analysis_text += f"**Last Updated:** {datetime.now().strftime('%H:%M:%S')}\n"
+            analysis_text += f"**Update Count:** #{market_data.update_counter}\n\n"
             
             for agent_type, agent_analysis in analysis.items():
                 analysis_text += f"## {agent_analysis['emoji']} {agent_analysis['title']}\n"
@@ -346,57 +403,80 @@ def generate_analysis(symbol_input, live_data):
             
             return analysis_text
         else:
-            return f"# ❌ Symbol not found: {symbol}"
+            return f"# ❌ Symbol Not Found\n\n'{symbol}' is not in our tracked symbols. Try: {', '.join(market_data.symbols)}"
 
 def update_interface(symbol_input=""):
-    """Main update function - called every time"""
+    """Main update function called automatically"""
     dashboard, live_data = create_live_dashboard()
     analysis = generate_analysis(symbol_input, live_data)
     return dashboard, analysis
 
-# Create the interface
-with gr.Blocks(theme=gr.themes.Soft(), title="Live AI Trading") as demo:
+# Create auto-refreshing interface
+with gr.Blocks(
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="slate"
+    ),
+    title="🤖 Auto-Refresh AI Trading System",
+    refresh_interval=10  # Auto-refresh every 10 seconds
+) as demo:
     
     gr.Markdown("""
     # 🤖 Real-Time AI Trading System
-    ## *Live Market Data & Dynamic Analysis*
+    ## *Auto-Refresh Every 10 Seconds*
     
-    **Charts update with genuine price movements on every click**
+    🔄 **Charts and data update automatically - no clicking needed!**
     """)
     
     with gr.Row():
-        symbol_input = gr.Textbox(
-            label="Stock Symbol", 
-            placeholder="AAPL, TSLA... (empty for all)",
-            max_lines=1
-        )
-        refresh_btn = gr.Button("🔄 Refresh Live Data", variant="primary")
+        with gr.Column(scale=1):
+            gr.Markdown("### 🎯 Stock Selection")
+            symbol_input = gr.Textbox(
+                label="Enter Stock Symbol",
+                placeholder="AAPL, TSLA... (empty for market overview)",
+                max_lines=1
+            )
+            gr.Markdown("""
+            **Tracked Stocks:** AAPL, GOOGL, MSFT, TSLA
+            
+            ⏰ **Auto-Refresh:** Every 10 seconds
+            📊 **Live Data:** Real-time price movements
+            🤖 **AI Analysis:** Dynamic recommendations
+            """)
+            
+        with gr.Column(scale=2):
+            gr.Markdown("### 📊 Live Auto-Refresh Dashboard")
     
     with gr.Tabs():
-        with gr.TabItem("📈 Live Dashboard"):
-            chart_output = gr.Plot(label="Live Market Data")
+        with gr.TabItem("📈 Live Charts"):
+            chart_output = gr.Plot(
+                label="Auto-Refreshing Market Data",
+                every=10  # Auto-refresh every 10 seconds
+            )
         
         with gr.TabItem("🤖 AI Analysis"):
-            analysis_output = gr.Markdown()
+            analysis_output = gr.Markdown(
+                every=10  # Auto-refresh every 10 seconds
+            )
     
     gr.Markdown(f"""
     ---
-    **💡 Tip:** Click "Refresh Live Data" to see genuine price movements
-    **⏰ Last Update:** {datetime.now().strftime('%H:%M:%S')}
+    **🔄 System Status:** Auto-Refresh Active • **📅 Last Refresh:** {datetime.now().strftime('%H:%M:%S')}
+    **💡 Tip:** The page automatically updates every 10 seconds with live data
+    **🎯 Tracking:** {len(market_data.symbols)} stocks with real-time AI analysis
     """)
     
-    # Connect the refresh button
-    refresh_btn.click(
+    # Set up auto-refresh
+    demo.load(
         fn=update_interface,
         inputs=[symbol_input],
         outputs=[chart_output, analysis_output]
     )
-    
-    # Load initial data
-    demo.load(
-        fn=lambda: update_interface(""),
-        outputs=[chart_output, analysis_output]
-    )
 
+# Launch the application
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )