Update app.py

app.py

@@ -1,3 +1,4 @@
+# app.py - Real-Time Auto-Refresh Trading System
 import gradio as gr
 import pandas as pd
 import numpy as np
@@ -5,7 +6,6 @@ import yfinance as yf
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 from datetime import datetime, timedelta
-import asyncio
 import time
 import warnings
 warnings.filterwarnings('ignore')
@@ -17,116 +17,52 @@ 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"""
-        current_time = datetime.now()
+        # Initialize prices
+        for symbol in symbols:
+            self.last_prices[symbol] = np.random.uniform(150, 250)
+            self.data_history[symbol] = [self.last_prices[symbol]]
         
-        # Always generate new data for demo purposes
-        self.update_counter += 1
-        self.last_update = current_time
+        self.timestamps = [datetime.now().strftime('%H:%M:%S')]
         
-        # Keep only last 15 timestamps for performance
-        if len(self.timestamps) > 15:
-            self.timestamps.pop(0)
+    def generate_live_data(self):
+        """Generate realistic live market data"""
+        self.update_counter += 1
+        current_time = datetime.now()
         
+        # Add new timestamp
         self.timestamps.append(current_time.strftime('%H:%M:%S'))
+        if len(self.timestamps) > 20:
+            self.timestamps.pop(0)
         
         live_data = {}
         
         for symbol in self.symbols:
-            try:
-                # Get actual current price from Yahoo Finance
-                ticker = yf.Ticker(symbol)
-                current_info = ticker.info
-                base_price = current_info.get('currentPrice', 
-                             current_info.get('regularMarketPrice', 
-                             current_info.get('previousClose', 150)))
-                
-                # Add realistic random movement
-                if symbol in self.last_prices:
-                    # 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:
-                    current_price = base_price
-                
-                self.last_prices[symbol] = current_price
-                
-                # Add to history
-                if symbol not in self.data_history:
-                    self.data_history[symbol] = []
-                
-                self.data_history[symbol].append(current_price)
-                
-                # Keep only last 15 prices
-                if len(self.data_history[symbol]) > 15:
-                    self.data_history[symbol].pop(0)
-                
-                # 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*5)).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
-                else:
-                    change = 0
-                
-                live_data[symbol] = {
-                    'prices': self.data_history[symbol].copy(),
-                    'timestamps': current_timestamps,
-                    'current_price': current_price,
-                    'change': change,
-                    'volume': np.random.randint(1000000, 5000000),
-                    'update_count': self.update_counter,
-                    'last_updated': current_time.strftime('%H:%M:%S')
-                }
-                
-            except Exception as e:
-                print(f"Error with {symbol}: {e}")
-                live_data[symbol] = self._generate_simulated_data(symbol)
+            # Generate realistic price movement
+            change_pct = np.random.normal(0, 0.8)  # More volatility
+            new_price = self.last_prices[symbol] * (1 + change_pct/100)
+            self.last_prices[symbol] = new_price
+            
+            # Add to history
+            self.data_history[symbol].append(new_price)
+            if len(self.data_history[symbol]) > 20:
+                self.data_history[symbol].pop(0)
+            
+            # Calculate metrics
+            current_timestamps = self.timestamps[-len(self.data_history[symbol]):]
+            change = ((new_price - self.data_history[symbol][0]) / self.data_history[symbol][0]) * 100
+            
+            live_data[symbol] = {
+                'prices': self.data_history[symbol].copy(),
+                'timestamps': current_timestamps,
+                'current_price': new_price,
+                'change': change,
+                'volume': np.random.randint(1000000, 5000000),
+                'update_count': self.update_counter,
+                'last_updated': current_time.strftime('%H:%M:%S')
+            }
         
         return live_data
-    
-    def _generate_simulated_data(self, symbol):
-        """Generate realistic simulated data"""
-        if symbol not in self.last_prices:
-            self.last_prices[symbol] = np.random.uniform(150, 250)
-        
-        # 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
-        
-        # Add to history
-        if symbol not in self.data_history:
-            self.data_history[symbol] = []
-        
-        self.data_history[symbol].append(new_price)
-        
-        if len(self.data_history[symbol]) > 15:
-            self.data_history[symbol].pop(0)
-        
-        # Generate timestamps
-        current_timestamps = [f"{(datetime.now() - timedelta(seconds=i*5)).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
-        
-        return {
-            'prices': self.data_history[symbol].copy(),
-            'timestamps': current_timestamps,
-            'current_price': new_price,
-            'change': change,
-            'volume': np.random.randint(1000000, 5000000),
-            'update_count': self.update_counter,
-            'last_updated': datetime.now().strftime('%H:%M:%S')
-        }
 
 class AI_TradingAgents:
     def __init__(self):
@@ -136,7 +72,6 @@ class AI_TradingAgents:
             'risk': {'name': 'Risk Agent', 'emoji': '🛡️'},
             'decision': {'name': 'Decision Engine', 'emoji': '🎯'}
         }
-        self.last_analysis = {}
     
     def analyze_market(self, symbol, market_data):
         if symbol not in market_data:
@@ -146,339 +81,249 @@ class AI_TradingAgents:
         current_price = data['current_price']
         change = data['change']
         
-        # Make analysis dynamic based on price changes
         analyses = {}
         
         # 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
+        if change > 2:
+            research_text = f"**Bullish Momentum** 🚀\n• Strong price action\n• **BUY** (85% confidence)"
+            research_conf = 85
+        elif change < -2:
+            research_text = f"**Bearish Pressure** 📉\n• Price weakness\n• **HOLD** (70% confidence)"
+            research_conf = 70
         else:
-            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
+            research_text = f"**Consolidation** ⚖️\n• Sideways movement\n• **HOLD** (75% confidence)"
+            research_conf = 75
         
         analyses['research'] = {
             'emoji': '📊',
-            'title': 'Fundamental Analysis',
+            'title': 'Research',
             '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"
-        
         analyses['technical'] = {
             'emoji': '📈',
-            'title': 'Technical Analysis',
-            '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'}",
+            'title': 'Technical',
+            'analysis': f"**{trend} Trend**\n• Price: ${current_price:.2f}\n• Change: {change:+.2f}%\n• RSI: {60 if change > 0 else 40}",
             'confidence': 75
         }
         
         # 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%"
-        
+        risk_level = "HIGH" if volatility > 3 else "MEDIUM" if volatility > 1.5 else "LOW"
         analyses['risk'] = {
             'emoji': '🛡️',
-            'title': 'Risk Assessment',
-            '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'}",
+            'title': 'Risk',
+            'analysis': f"**{risk_level} RISK**\n• Volatility: {volatility:.1f}%\n• Position: 2-3%\n• Stop: 6-8%",
             'confidence': 80
         }
         
         # Decision Engine
-        if change > 2 and volatility < 4:
+        if change > 2:
             decision = "BUY"
             confidence = 85
-            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"
+            confidence = 75
         else:
             decision = "HOLD"
             confidence = 70
-            reason = "Moderate movement, needs confirmation"
-            action = "Wait for clearer trend establishment"
         
         analyses['decision'] = {
             'emoji': '🎯',
-            'title': 'Trading Decision',
-            '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}",
+            'title': 'Decision',
+            'analysis': f"**{decision}** 🎯\n• Confidence: {confidence}%\n• Price: ${current_price:.2f}",
             'confidence': confidence,
             'decision': decision
         }
         
-        self.last_analysis[symbol] = analyses
         return analyses
     
     def _get_error_analysis(self, symbol):
         return {
-            'research': {'emoji': '📊', 'title': 'Research', 'analysis': 'Data unavailable', 'confidence': 0},
-            'technical': {'emoji': '📈', 'title': 'Technical', 'analysis': 'Data unavailable', 'confidence': 0},
-            'risk': {'emoji': '🛡️', 'title': 'Risk', 'analysis': 'Data unavailable', 'confidence': 0},
-            'decision': {'emoji': '🎯', 'title': 'Decision', 'analysis': 'HOLD - No data', 'confidence': 0, 'decision': 'HOLD'}
+            'research': {'emoji': '📊', 'title': 'Research', 'analysis': 'No data', 'confidence': 0},
+            'technical': {'emoji': '📈', 'title': 'Technical', 'analysis': 'No data', 'confidence': 0},
+            'risk': {'emoji': '🛡️', 'title': 'Risk', 'analysis': 'No data', 'confidence': 0},
+            'decision': {'emoji': '🎯', 'title': 'Decision', 'analysis': 'HOLD', 'confidence': 0, 'decision': 'HOLD'}
         }
 
 # Initialize components
 market_data = RealTimeMarketData()
 trading_agents = AI_TradingAgents()
 
-def create_live_dashboard():
-    """Create auto-updating dashboard"""
+def get_live_dataframe():
+    """Create live updating dataframe"""
     live_data = market_data.generate_live_data()
     
-    fig = make_subplots(
-        rows=2, cols=2,
-        subplot_titles=[
-            '📈 Live Price Movement (Auto-Refresh)',
-            '📊 Real-Time Performance', 
-            '🔄 Recent Price Changes',
-            '🎯 Market Sentiment'
-        ],
-        specs=[
-            [{"type": "scatter"}, {"type": "bar"}],
-            [{"type": "scatter"}, {"type": "pie"}]
-        ],
-        vertical_spacing=0.12
-    )
+    data = []
+    for symbol, info in live_data.items():
+        data.append({
+            'Symbol': symbol,
+            'Price': f"${info['current_price']:.2f}",
+            'Change': f"{info['change']:+.2f}%",
+            'Volume': f"{info['volume']:,}",
+            'Last Update': info['last_updated'],
+            'Update #': info['update_count']
+        })
+    
+    df = pd.DataFrame(data)
+    return df
+
+def get_live_chart():
+    """Create live updating chart"""
+    live_data = market_data.generate_live_data()
+    
+    fig = go.Figure()
     
-    # 1. Live price lines
     colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4']
     for i, (symbol, data) in enumerate(live_data.items()):
-        fig.add_trace(
-            go.Scatter(
-                x=data['timestamps'],
-                y=data['prices'],
-                mode='lines+markers',
-                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}}<br>Change: {data["change"]:+.2f}%<extra></extra>'
-            ),
-            row=1, col=1
-        )
-    
-    # 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.Scatter(
+            x=data['timestamps'],
+            y=data['prices'],
+            mode='lines+markers',
+            name=symbol,
+            line=dict(color=colors[i], width=3),
+            marker=dict(size=6)
+        ))
     
-    fig.add_trace(
-        go.Bar(
-            x=symbols,
-            y=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='Performance'
-        ),
-        row=1, col=2
+    fig.update_layout(
+        title=f"Live Prices - Update #{market_data.update_counter} - {datetime.now().strftime('%H:%M:%S')}",
+        template='plotly_dark',
+        height=400
     )
     
-    # 3. Recent changes
-    if live_data:
-        first_symbol = list(live_data.keys())[0]
-        data = live_data[first_symbol]
-        if len(data['prices']) > 3:
-            recent_changes = []
-            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'][-3:],
-                    y=recent_changes[::-1],
-                    mode='lines+markers+text',
-                    name='Recent Changes',
-                    line=dict(color='#FECA57', width=4),
-                    marker=dict(size=10),
-                    text=[f"{c:+.2f}%" for c in recent_changes[::-1]],
-                    textposition='top center'
-                ),
-                row=2, col=1
-            )
+    return fig
+
+def get_performance_chart():
+    """Create performance chart"""
+    live_data = market_data.generate_live_data()
     
-    # 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])
+    symbols = list(live_data.keys())
+    changes = [live_data[s]['change'] for s in symbols]
     
-    fig.add_trace(
-        go.Pie(
-            labels=['Bullish', 'Bearish', 'Neutral'],
-            values=[bullish, bearish, neutral],
-            hole=0.4,
-            marker_colors=['#00CC96', '#EF553B', '#636EFA'],
-            name='Market Sentiment'
-        ),
-        row=2, col=2
-    )
+    fig = go.Figure()
+    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],
+        textposition='auto'
+    ))
     
     fig.update_layout(
-        height=800,
-        title_text=f"🔄 AUTO-REFRESHING LIVE DASHBOARD • Update #{market_data.update_counter} • {datetime.now().strftime('%H:%M:%S')}",
+        title="Today's Performance",
         template='plotly_dark',
-        showlegend=True,
-        font=dict(size=12)
+        height=300
     )
     
-    return fig, live_data
+    return fig
 
-def generate_analysis(symbol_input, live_data):
-    """Generate dynamic analysis"""
+def get_analysis_report(symbol_input=""):
+    """Get analysis report"""
+    live_data = market_data.generate_live_data()
+    
     if not symbol_input:
         # 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"
+        report = f"# 📊 Market Overview\n\n"
+        report += f"**Last Update:** {datetime.now().strftime('%H:%M:%S')}\n"
+        report += f"**Update Count:** {market_data.update_counter}\n\n"
         
-        for symbol, data in live_data.items():
+        for symbol in live_data.keys():
             analysis = trading_agents.analyze_market(symbol, live_data)
             decision = analysis['decision']
-            
-            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']}% confidence)\n\n"
+            report += f"**{symbol}:** ${live_data[symbol]['current_price']:.2f} ({live_data[symbol]['change']:+.2f}%) - {decision['decision']}\n\n"
         
-        return analysis_text
+        return report
     else:
-        # Specific symbol analysis
-        symbol = symbol_input.upper().strip()
+        # Specific symbol
+        symbol = symbol_input.upper()
         if symbol in live_data:
             analysis = trading_agents.analyze_market(symbol, live_data)
-            
-            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"
+            report = f"# 🎯 {symbol} Analysis\n\n"
+            report += f"**Price:** ${live_data[symbol]['current_price']:.2f}\n"
+            report += f"**Change:** {live_data[symbol]['change']:+.2f}%\n\n"
             
             for agent_type, agent_analysis in analysis.items():
-                analysis_text += f"## {agent_analysis['emoji']} {agent_analysis['title']}\n"
-                analysis_text += f"{agent_analysis['analysis']}\n\n"
+                report += f"### {agent_analysis['emoji']} {agent_analysis['title']}\n"
+                report += f"{agent_analysis['analysis']}\n\n"
             
-            return analysis_text
+            return report
         else:
-            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 automatically"""
-    try:
-        dashboard, live_data = create_live_dashboard()
-        analysis = generate_analysis(symbol_input, live_data)
-        return dashboard, analysis
-    except Exception as e:
-        # Return error state
-        error_fig = go.Figure()
-        error_fig.add_annotation(
-            text="🔄 Updating... Please wait",
-            xref="paper", yref="paper",
-            x=0.5, y=0.5,
-            showarrow=False,
-            font=dict(size=20)
-        )
-        error_fig.update_layout(height=400, template='plotly_dark')
-        return error_fig, "# 🔄 Updating... Please wait"
+            return f"# ❌ Symbol not found: {symbol}"
 
-# Create auto-refreshing interface
-with gr.Blocks(
-    theme=gr.themes.Soft(
-        primary_hue="blue",
-        secondary_hue="slate"
-    ),
-    title="🤖 Auto-Refresh AI Trading System"
-) as demo:
+# Create the interface
+with gr.Blocks(theme=gr.themes.Soft(), title="Live Trading Dashboard") as demo:
     
     gr.Markdown("""
-    # 🤖 Real-Time AI Trading System
-    ## *Auto-Refresh Every 5 Seconds*
+    # 🤖 Real-Time Trading Dashboard
+    ## *Live Auto-Refresh Every 3 Seconds*
     
-    🔄 **Charts and data update automatically - no clicking needed!**
+    🔄 **Data updates automatically every 3 seconds**
     """)
     
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("### 🎯 Stock Selection")
             symbol_input = gr.Textbox(
-                label="Enter Stock Symbol",
-                placeholder="AAPL, TSLA... (empty for market overview)",
+                label="Stock Symbol",
+                placeholder="AAPL, TSLA... (empty for overview)",
                 max_lines=1
             )
             gr.Markdown("""
-            **Tracked Stocks:** AAPL, GOOGL, MSFT, TSLA
-            
-            ⏰ **Auto-Refresh:** Every 5 seconds
-            📊 **Live Data:** Real-time price movements
-            🤖 **AI Analysis:** Dynamic recommendations
+            **Tracked:** AAPL, GOOGL, MSFT, TSLA
+            **Refresh:** Every 3 seconds
             """)
-            
+        
         with gr.Column(scale=2):
-            gr.Markdown("### 📊 Live Auto-Refresh Dashboard")
+            gr.Markdown("### 📈 Live Market Data")
     
-    with gr.Tabs():
-        with gr.TabItem("📈 Live Charts"):
-            chart_output = gr.Plot(
-                label="Auto-Refreshing Market Data"
+    with gr.Row():
+        with gr.Column():
+            # Auto-updating dataframe
+            dataframe = gr.DataFrame(
+                label="Live Stock Prices",
+                every=3,  # Auto-refresh every 3 seconds
+                value=get_live_dataframe
             )
         
-        with gr.TabItem("🤖 AI Analysis"):
-            analysis_output = gr.Markdown()
+        with gr.Column():
+            # Performance chart
+            performance_chart = gr.Plot(
+                label="Performance",
+                every=3,
+                value=get_performance_chart
+            )
+    
+    with gr.Row():
+        # Main price chart
+        price_chart = gr.Plot(
+            label="Live Price Movement",
+            every=3,
+            value=get_live_chart
+        )
+    
+    with gr.Row():
+        # Analysis report
+        analysis_report = gr.Markdown(
+            label="AI Analysis",
+            every=3,
+            value=lambda: get_analysis_report("")
+        )
     
     gr.Markdown(f"""
     ---
-    **🔄 System Status:** Auto-Refresh Active • **📅 Last Refresh:** {datetime.now().strftime('%H:%M:%S')}
-    **💡 Tip:** The page automatically updates every 5 seconds with live data
-    **🎯 Tracking:** {len(market_data.symbols)} stocks with real-time AI analysis
+    **🔄 Live Updates Active** • **Last Data:** {datetime.now().strftime('%H:%M:%S')}
+    *Data refreshes automatically every 3 seconds*
     """)
     
-    # Set up auto-refresh using JavaScript
-    demo.load(
-        fn=update_interface,
+    # Update analysis when symbol input changes
+    symbol_input.change(
+        fn=get_analysis_report,
         inputs=[symbol_input],
-        outputs=[chart_output, analysis_output]
+        outputs=[analysis_report]
     )
-    
-    # Add JavaScript for auto-refresh
-    demo.js = """
-    <script>
-    function autoRefresh() {
-        setTimeout(function() {
-            location.reload();
-        }, 5000); // Refresh every 5 seconds
-    }
-    window.onload = autoRefresh;
-    </script>
-    """
 
-# Launch the application
+# Launch the app
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True
-    )
+    demo.launch(share=True)