Update app.py

app.py

@@ -7,53 +7,68 @@ import yfinance as yf
 import warnings
 warnings.filterwarnings('ignore')
 
-class SimpleRiskApp:
+class FreshRiskApp:
     def __init__(self):
-        # Only 10 reliable stocks with correct names
-        self.available_stocks = [
-            'AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA',
-            'META', 'NVDA', 'NFLX', 'JPM', 'JNJ'
+        # Hardcoded stock names to avoid encoding issues
+        self.stock_list = [
+            "AAPL - Apple",
+            "MSFT - Microsoft", 
+            "GOOGL - Google",
+            "AMZN - Amazon",
+            "TSLA - Tesla",
+            "META - Meta",
+            "NVDA - NVIDIA",
+            "NFLX - Netflix",
+            "JPM - JPMorgan",
+            "JNJ - Johnson & Johnson"
         ]
-        print("🎯 Simple Portfolio Risk Analyzer Ready!")
+        self.stock_symbols = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'META', 'NVDA', 'NFLX', 'JPM', 'JNJ']
+        print("✅ Fresh Risk Analyzer Ready!")
     
-    def get_stock_data(self, symbols, period='2y'):
-        """Get stock data with error handling"""
+    def get_stock_data(self, selected_indices, period='2y'):
+        """Get data for selected stock indices"""
         try:
+            symbols = [self.stock_symbols[i] for i in selected_indices]
+            print(f"📊 Fetching data for: {symbols}")
+            
             data = yf.download(symbols, period=period, progress=False)['Adj Close']
-            return data
+            if data.empty:
+                return None, None
+            return data, symbols
         except Exception as e:
             print(f"❌ Data fetch error: {str(e)}")
-            return None
-    
-    def calculate_portfolio_metrics(self, selected_stocks, days=252, simulations=5000):
-        """Calculate metrics for selected stocks"""
-        if not selected_stocks:
             return None, None
+    
+    def run_analysis(self, selected_indices, days=252, simulations=5000):
+        """Run complete risk analysis"""
+        if not selected_indices:
+            return None, None, "Please select at least one stock"
         
         try:
-            print(f"📊 Analyzing: {selected_stocks}")
-            
-            # Get fresh data
-            data = self.get_stock_data(selected_stocks)
-            if data is None or data.empty:
-                return None, None
+            # Get data
+            data, symbols = self.get_stock_data(selected_indices)
+            if data is None:
+                return None, None, "Failed to fetch stock data"
             
             # Calculate returns
             returns = data.pct_change().dropna()
-            n_stocks = len(selected_stocks)
+            if returns.empty:
+                return None, None, "Insufficient data for analysis"
             
-            # Equal weights
+            n_stocks = len(symbols)
             weights = np.array([1/n_stocks] * n_stocks)
             
             # Calculate parameters
             mean_returns = returns.mean().values
             cov_matrix = returns.cov().values
             
-            # Ensure covariance matrix is positive definite
+            # Make covariance matrix positive definite
             min_eig = np.min(np.real(np.linalg.eigvals(cov_matrix)))
             if min_eig < 0:
                 cov_matrix -= 10 * min_eig * np.eye(*cov_matrix.shape)
             
+            print(f"🎯 Running {simulations} simulations for {symbols}...")
+            
             # Generate simulation
             np.random.seed(42)
             L = np.linalg.cholesky(cov_matrix)
@@ -61,11 +76,9 @@ class SimpleRiskApp:
             simulation_results = []
             
             for i in range(simulations):
-                # Generate correlated returns
                 random_numbers = np.random.normal(0, 1, size=(days, n_stocks))
                 correlated_returns = random_numbers @ L.T + mean_returns
                 
-                # Calculate portfolio path
                 portfolio_value = 100.0
                 portfolio_path = [portfolio_value]
                 
@@ -84,264 +97,147 @@ class SimpleRiskApp:
                 'expected_value': float(np.mean(final_values)),
                 'prob_10_loss': float(np.mean(final_values < 90)),
                 'prob_20_loss': float(np.mean(final_values < 80)),
-                'prob_30_loss': float(np.mean(final_values < 70)),
                 'var_95': float(np.percentile(final_values, 5)),
                 'best_case': float(np.percentile(final_values, 95)),
-                'num_stocks': n_stocks,
+                'stocks': symbols,
                 'weights': [f"{(1/n_stocks)*100:.1f}%" for _ in range(n_stocks)]
             }
             
-            print(f"✅ Analysis completed for {selected_stocks}")
-            return metrics, simulation_array
+            print("✅ Analysis completed successfully!")
+            return metrics, simulation_array, None
             
         except Exception as e:
             print(f"❌ Analysis error: {str(e)}")
-            return None, None
+            return None, None, f"Analysis failed: {str(e)}"
     
-    def create_simulation_plot(self, simulation_results, stock_names):
-        """Create simulation plot"""
-        if simulation_results is None:
-            return None
-        
-        fig = go.Figure()
-        
-        # Sample paths
-        for i in range(min(30, len(simulation_results))):
-            fig.add_trace(go.Scatter(
-                y=simulation_results[i],
-                mode='lines',
-                line=dict(width=1, color='lightblue'),
-                opacity=0.2,
-                showlegend=False
+    def create_plots(self, metrics, simulations):
+        """Create all visualization plots"""
+        if metrics is None or simulations is None:
+            return None, None, None
+        
+        # Simulation plot
+        sim_fig = go.Figure()
+        for i in range(min(20, len(simulations))):
+            sim_fig.add_trace(go.Scatter(
+                y=simulations[i], mode='lines', line=dict(width=1, color='blue'), opacity=0.1, showlegend=False
             ))
         
-        # Mean path
-        mean_path = np.mean(simulation_results, axis=0)
-        fig.add_trace(go.Scatter(
-            y=mean_path,
-            mode='lines',
-            line=dict(width=3, color='red'),
-            name='Average Path'
-        ))
-        
-        stock_label = stock_names[0] if len(stock_names) == 1 else f"{len(stock_names)}-Stock Portfolio"
-        fig.update_layout(
-            title=f"📈 Monte Carlo Simulation - {stock_label}",
-            xaxis_title="Trading Days",
-            yaxis_title="Portfolio Value ($)",
-            height=400
-        )
-        
-        return fig
-    
-    def create_distribution_plot(self, simulation_results, metrics, stock_names):
-        """Create distribution plot"""
-        if simulation_results is None or metrics is None:
-            return None
-        
-        final_values = simulation_results[:, -1]
+        mean_path = np.mean(simulations, axis=0)
+        sim_fig.add_trace(go.Scatter(y=mean_path, mode='lines', line=dict(width=3, color='red'), name='Average'))
         
-        stock_label = stock_names[0] if len(stock_names) == 1 else f"{len(stock_names)}-Stock Portfolio"
-        fig = px.histogram(
-            x=final_values,
-            nbins=50,
-            title=f"📊 Final Value Distribution - {stock_label}",
-            color_discrete_sequence=['#667eea']
-        )
+        stock_label = metrics['stocks'][0] if len(metrics['stocks']) == 1 else f"{len(metrics['stocks'])} Stocks"
+        sim_fig.update_layout(title=f"Monte Carlo Simulation - {stock_label}", height=400)
         
-        fig.add_vline(x=metrics['expected_value'], line_dash="dash", 
-                     line_color="red", annotation_text=f"Mean: ${metrics['expected_value']:.2f}")
-        fig.add_vline(x=metrics['var_95'], line_dash="dash", 
-                     line_color="orange", annotation_text=f"5% VaR: ${metrics['var_95']:.2f}")
-        fig.update_layout(height=400, showlegend=False)
-        
-        return fig
-    
-    def create_risk_gauge(self, metrics):
-        """Create risk gauge"""
-        if metrics is None:
-            return None
+        # Distribution plot
+        final_values = simulations[:, -1]
+        dist_fig = px.histogram(x=final_values, nbins=50, title="Portfolio Value Distribution")
+        dist_fig.add_vline(x=metrics['expected_value'], line_dash="dash", line_color="red")
+        dist_fig.add_vline(x=metrics['var_95'], line_dash="dash", line_color="orange")
+        dist_fig.update_layout(height=400)
         
+        # Risk gauge
         risk_prob = metrics['prob_10_loss'] * 100
-        
-        fig = go.Figure(go.Indicator(
-            mode="gauge+number",
-            value=risk_prob,
-            domain={'x': [0, 1], 'y': [0, 1]},
-            title={'text': "Probability of >10% Loss"},
-            gauge={
-                'axis': {'range': [0, 50]},
-                'bar': {'color': "darkblue"},
-                'steps': [
-                    {'range': [0, 15], 'color': "lightgreen"},
-                    {'range': [15, 30], 'color': "yellow"},
-                    {'range': [30, 50], 'color': "red"}
-                ]
-            }
+        gauge_fig = go.Figure(go.Indicator(
+            mode="gauge+number", value=risk_prob, title={'text': "10% Loss Probability"},
+            gauge={'axis': {'range': [0, 50]}, 'bar': {'color': "darkblue"},
+                   'steps': [{'range': [0, 15], 'color': "green"},
+                           {'range': [15, 30], 'color': "yellow"},
+                           {'range': [30, 50], 'color': "red"}]}
         ))
-        fig.update_layout(height=300)
-        return fig
-    
-    def analyze_portfolio(self, selected_stocks, simulation_days, num_simulations):
-        """Main analysis function"""
-        print(f"🔍 Analyzing: {selected_stocks}")
-        
-        if not selected_stocks:
-            return self.create_error_html("Please select at least one stock"), None, None, None
+        gauge_fig.update_layout(height=300)
         
-        try:
-            metrics, simulations = self.calculate_portfolio_metrics(
-                selected_stocks, simulation_days, int(num_simulations)
-            )
-            
-            if metrics is None:
-                return self.create_error_html("Analysis failed. Please try different stocks."), None, None, None
-            
-            sim_plot = self.create_simulation_plot(simulations, selected_stocks)
-            dist_plot = self.create_distribution_plot(simulations, metrics, selected_stocks)
-            gauge_plot = self.create_risk_gauge(metrics)
-            summary = self.create_summary_html(metrics, selected_stocks, simulation_days, num_simulations)
-            
-            return summary, sim_plot, dist_plot, gauge_plot
-            
-        except Exception as e:
-            return self.create_error_html(f"Error: {str(e)}"), None, None, None
+        return sim_fig, dist_fig, gauge_fig
     
-    def create_error_html(self, message):
-        return f"""
-        <div style='text-align: center; padding: 40px; background: #f8d7da; border-radius: 10px;'>
-            <h3 style='color: #721c24;'>❌ Error</h3>
-            <p>{message}</p>
-        </div>
-        """
-    
-    def create_summary_html(self, metrics, stocks, days, sims):
-        risk_level = "LOW" if metrics['prob_10_loss'] < 0.1 else "MEDIUM" if metrics['prob_10_loss'] < 0.2 else "HIGH"
-        risk_color = "#28a745" if risk_level == "LOW" else "#ffc107" if risk_level == "MEDIUM" else "#dc3545"
+    def create_summary(self, metrics, days, sims):
+        """Create summary HTML"""
+        if metrics is None:
+            return "No results available"
         
-        # Create weights display
-        weights_html = " • ".join([f"{stock}: {weight}" for stock, weight in zip(stocks, metrics['weights'])])
+        risk_level = "LOW" if metrics['prob_10_loss'] < 0.1 else "MEDIUM" if metrics['prob_10_loss'] < 0.2 else "HIGH"
+        risk_color = "green" if risk_level == "LOW" else "orange" if risk_level == "MEDIUM" else "red"
         
-        portfolio_type = "Single Stock" if len(stocks) == 1 else f"{len(stocks)}-Stock Portfolio"
+        weights_text = " • ".join([f"{stock}: {weight}" for stock, weight in zip(metrics['stocks'], metrics['weights'])])
         
         return f"""
-        <div style="padding: 25px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 15px; color: white;">
-            <h2 style="text-align: center;">📊 {portfolio_type} Risk Analysis</h2>
-            
-            <div style="background: rgba(255,255,255,0.1); padding: 20px; border-radius: 10px; margin: 15px 0;">
-                <h3>Portfolio: {', '.join(stocks)}</h3>
-                <p>Weights: {weights_html} | Period: {days} days | Simulations: {sims}</p>
+        <div style="padding: 20px; background: #f0f8ff; border-radius: 10px;">
+            <h2>📊 Risk Analysis Report</h2>
+            <div style="background: white; padding: 15px; border-radius: 8px; margin: 10px 0;">
+                <h3>Portfolio: {', '.join(metrics['stocks'])}</h3>
+                <p><strong>Weights:</strong> {weights_text}</p>
+                <p><strong>Period:</strong> {days} days | <strong>Simulations:</strong> {sims}</p>
             </div>
             
-            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 15px;">
-                <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px;">
+            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 10px;">
+                <div style="background: white; padding: 10px; border-radius: 5px;">
                     <h4>Expected Value</h4>
-                    <p style="font-size: 24px; font-weight: bold;">${metrics['expected_value']:.2f}</p>
+                    <p style="font-size: 20px; color: blue;">${metrics['expected_value']:.2f}</p>
                 </div>
-                
-                <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px;">
+                <div style="background: white; padding: 10px; border-radius: 5px;">
                     <h4>Risk Level</h4>
-                    <p style="font-size: 24px; font-weight: bold; color: {risk_color};">{risk_level}</p>
+                    <p style="font-size: 20px; color: {risk_color};">{risk_level}</p>
                 </div>
-                
-                <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px;">
-                    <h4>10% Loss Probability</h4>
-                    <p style="font-size: 24px; font-weight: bold;">{metrics['prob_10_loss']*100:.1f}%</p>
+                <div style="background: white; padding: 10px; border-radius: 5px;">
+                    <h4>10% Loss Chance</h4>
+                    <p style="font-size: 20px; color: orange;">{metrics['prob_10_loss']*100:.1f}%</p>
                 </div>
-                
-                <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px;">
-                    <h4>Worst Case (5%)</h4>
-                    <p style="font-size: 24px; font-weight: bold;">${metrics['var_95']:.2f}</p>
+                <div style="background: white; padding: 10px; border-radius: 5px;">
+                    <h4>Worst Case</h4>
+                    <p style="font-size: 20px; color: red;">${metrics['var_95']:.2f}</p>
                 </div>
             </div>
-            
-            <div style="margin-top: 15px; background: rgba(255,255,255,0.1); padding: 15px; border-radius: 8px;">
-                <h4>Additional Risk Metrics</h4>
-                <p>20% Loss: <strong>{metrics['prob_20_loss']*100:.1f}%</strong> | 
-                30% Loss: <strong>{metrics['prob_30_loss']*100:.1f}%</strong> | 
-                Best Case: <strong>${metrics['best_case']:.2f}</strong></p>
-            </div>
         </div>
         """
 
-# Create and launch app
-app = SimpleRiskApp()
+# Create app instance
+app = FreshRiskApp()
 
-with gr.Blocks(theme=gr.themes.Soft(), title="QuantRisk Pro") as demo:
-    gr.Markdown("# 📊 QuantRisk Pro - Portfolio Risk Analyzer")
-    gr.Markdown("**Analyze single stocks or multi-stock portfolios with real-time risk assessment**")
+# Build Gradio interface
+with gr.Blocks(title="Stock Risk Analyzer") as demo:
+    gr.Markdown("# 📈 Stock Portfolio Risk Analyzer")
+    gr.Markdown("**Analyze risk for single stocks or portfolios using Monte Carlo simulations**")
     
     with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### 🔧 Portfolio Configuration")
-            
+        with gr.Column():
+            gr.Markdown("### Select Stocks")
             stock_checkboxes = gr.CheckboxGroup(
-                choices=app.available_stocks,
-                value=['AAPL', 'MSFT', 'GOOGL'],  # Default selection
-                label="**Select Stocks (Choose 1 or more)**",
-                info="Single stock or portfolio analysis"
+                choices=app.stock_list,
+                label="Choose stocks for analysis",
+                value=[0, 1, 2]  # Default: AAPL, MSFT, GOOGL
             )
             
-            simulation_days = gr.Slider(
-                minimum=30,
-                maximum=500,
-                value=252,
-                step=30,
-                label="**Time Horizon (Days)**",
-                info="252 days = 1 trading year"
-            )
-            
-            num_simulations = gr.Dropdown(
-                choices=[1000, 2500, 5000, 10000],
-                value=5000,
-                label="**Number of Simulations**"
-            )
-            
-            analyze_btn = gr.Button("🚀 Run Risk Analysis", variant="primary", size="lg")
+            gr.Markdown("### Simulation Settings")
+            days_slider = gr.Slider(30, 500, 252, label="Time Horizon (Days)")
+            sims_dropdown = gr.Dropdown([1000, 5000, 10000], value=5000, label="Number of Simulations")
             
-            gr.Markdown("---")
-            gr.Markdown("""
-            **💡 How to Use:**
-            - Select 1 stock for individual analysis
-            - Select 2+ stocks for portfolio analysis  
-            - Weights automatically calculated as equal
-            - Uses real market data from Yahoo Finance
-            """)
+            analyze_btn = gr.Button("🚀 Run Analysis", variant="primary")
         
-        with gr.Column(scale=2):
-            gr.Markdown("### 📈 Analysis Results")
-            
-            summary_html = gr.HTML(
-                value="""
-                <div style='text-align: center; padding: 50px; background: #f8f9fa; border-radius: 10px;'>
-                    <h3 style='color: #6c757d;'>🚀 Ready to Analyze!</h3>
-                    <p>Select stocks and click 'Run Risk Analysis' to see your risk report.</p>
-                </div>
-                """
-            )
+        with gr.Column():
+            gr.Markdown("### Analysis Results")
+            results_html = gr.HTML()
             
             with gr.Row():
-                risk_gauge = gr.Plot(label="**Risk Probability Gauge**")
-                simulation_plot = gr.Plot(label="**Monte Carlo Simulation**")
+                gauge_plot = gr.Plot()
+                sim_plot = gr.Plot()
             
-            distribution_plot = gr.Plot(label="**Portfolio Value Distribution**")
+            dist_plot = gr.Plot()
     
-    # Footer
-    gr.Markdown("---")
-    gr.Markdown(
-        """
-        <div style="text-align: center; color: #666;">
-            <p>Built with ❤️ using Gradio | QuantRisk Pro | Real-time market data</p>
-        </div>
-        """
-    )
+    # Handle analysis
+    def run_complete_analysis(stock_indices, days, sims):
+        metrics, simulations, error = app.run_analysis(stock_indices, days, sims)
+        
+        if error:
+            return f"<div style='color: red; padding: 20px;'><h3>❌ Error</h3><p>{error}</p></div>", None, None, None
+        
+        summary = app.create_summary(metrics, days, sims)
+        sim_fig, dist_fig, gauge_fig = app.create_plots(metrics, simulations)
+        
+        return summary, gauge_fig, sim_fig, dist_fig
     
-    # Set up event handling
     analyze_btn.click(
-        fn=app.analyze_portfolio,
-        inputs=[stock_checkboxes, simulation_days, num_simulations],
-        outputs=[summary_html, simulation_plot, distribution_plot, risk_gauge]
+        fn=run_complete_analysis,
+        inputs=[stock_checkboxes, days_slider, sims_dropdown],
+        outputs=[results_html, gauge_plot, sim_plot, dist_plot]
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(share=True)