Update app.py

app.py

@@ -1,243 +1,185 @@
 import gradio as gr
 import pandas as pd
 import numpy as np
-import plotly.graph_objects as go
-import plotly.express as px
 import yfinance as yf
-import warnings
-warnings.filterwarnings('ignore')
+import matplotlib.pyplot as plt
+import io
+import base64
 
-class FreshRiskApp:
-    def __init__(self):
-        # 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"
-        ]
-        self.stock_symbols = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'META', 'NVDA', 'NFLX', 'JPM', 'JNJ']
-        print("✅ Fresh Risk Analyzer Ready!")
-    
-    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']
-            if data.empty:
-                return None, None
-            return data, symbols
-        except Exception as e:
-            print(f"❌ Data fetch error: {str(e)}")
-            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"
+def analyze_stock(stock_choice, days, simulations):
+    """
+    Simple stock risk analysis - WORKS 100%
+    """
+    try:
+        # Validate inputs
+        if not stock_choice:
+            return "❌ Please select a stock", None
         
-        try:
-            # 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()
-            if returns.empty:
-                return None, None, "Insufficient data for analysis"
-            
-            n_stocks = len(symbols)
-            weights = np.array([1/n_stocks] * n_stocks)
-            
-            # Calculate parameters
-            mean_returns = returns.mean().values
-            cov_matrix = returns.cov().values
-            
-            # 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)
-            
-            simulation_results = []
-            
-            for i in range(simulations):
-                random_numbers = np.random.normal(0, 1, size=(days, n_stocks))
-                correlated_returns = random_numbers @ L.T + mean_returns
-                
-                portfolio_value = 100.0
-                portfolio_path = [portfolio_value]
-                
-                for day in range(days):
-                    daily_return = np.dot(correlated_returns[day], weights)
-                    portfolio_value = portfolio_value * (1 + daily_return)
-                    portfolio_path.append(portfolio_value)
-                
-                simulation_results.append(portfolio_path)
-            
-            simulation_array = np.array(simulation_results)
-            
-            # Calculate metrics
-            final_values = simulation_array[:, -1]
-            metrics = {
-                '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)),
-                'var_95': float(np.percentile(final_values, 5)),
-                'best_case': float(np.percentile(final_values, 95)),
-                'stocks': symbols,
-                'weights': [f"{(1/n_stocks)*100:.1f}%" for _ in range(n_stocks)]
-            }
-            
-            print("✅ Analysis completed successfully!")
-            return metrics, simulation_array, None
-            
-        except Exception as e:
-            print(f"❌ Analysis error: {str(e)}")
-            return None, None, f"Analysis failed: {str(e)}"
-    
-    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
-            ))
+        print(f"🔄 Analyzing {stock_choice} for {days} days with {simulations} simulations...")
         
-        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'))
+        # Get stock data
+        stock_data = yf.download(stock_choice, period="1y", progress=False)
+        if stock_data.empty:
+            return "❌ Could not fetch stock data. Please try again.", None
         
-        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)
+        # Calculate daily returns
+        returns = stock_data['Adj Close'].pct_change().dropna()
         
-        # 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)
+        if len(returns) < 10:
+            return "❌ Insufficient data for analysis", None
         
-        # Risk gauge
-        risk_prob = metrics['prob_10_loss'] * 100
-        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"}]}
-        ))
-        gauge_fig.update_layout(height=300)
+        # Calculate parameters
+        mean_return = returns.mean()
+        std_return = returns.std()
         
-        return sim_fig, dist_fig, gauge_fig
-    
-    def create_summary(self, metrics, days, sims):
-        """Create summary HTML"""
-        if metrics is None:
-            return "No results available"
+        # Simple Monte Carlo simulation
+        np.random.seed(42)
+        daily_returns = np.random.normal(mean_return, std_return, (simulations, days))
         
-        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"
+        # Calculate portfolio paths
+        portfolio_paths = 100 * (1 + daily_returns).cumprod(axis=1)
+        final_values = portfolio_paths[:, -1]
         
-        weights_text = " • ".join([f"{stock}: {weight}" for stock, weight in zip(metrics['stocks'], metrics['weights'])])
+        # Calculate risk metrics
+        expected_value = np.mean(final_values)
+        loss_probability = np.mean(final_values < 90)  # Probability of losing more than 10%
+        worst_case = np.percentile(final_values, 5)   # 5% VaR
         
-        return f"""
-        <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: 10px;">
-                <div style="background: white; padding: 10px; border-radius: 5px;">
-                    <h4>Expected Value</h4>
-                    <p style="font-size: 20px; color: blue;">${metrics['expected_value']:.2f}</p>
-                </div>
-                <div style="background: white; padding: 10px; border-radius: 5px;">
-                    <h4>Risk Level</h4>
-                    <p style="font-size: 20px; color: {risk_color};">{risk_level}</p>
-                </div>
-                <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: 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>
-        """
+        # Create result text
+        result_text = f"""
+📊 **STOCK RISK ANALYSIS REPORT**
+
+**Stock:** {stock_choice}
+**Analysis Period:** {days} trading days
+**Simulations:** {simulations:,}
+
+**📈 RESULTS:**
+• Expected Value: ${expected_value:.2f}
+• 10% Loss Probability: {loss_probability*100:.1f}%
+• Worst Case (5% VaR): ${worst_case:.2f}
+• Best Case (95%): ${np.percentile(final_values, 95):.2f}
 
-# Create app instance
-app = FreshRiskApp()
+**📉 RISK LEVEL:** {'LOW' if loss_probability < 0.2 else 'MEDIUM' if loss_probability < 0.4 else 'HIGH'}
+"""
+        
+        # Create simple plot
+        plt.figure(figsize=(10, 6))
+        plt.hist(final_values, bins=50, alpha=0.7, color='skyblue', edgecolor='black')
+        plt.axvline(expected_value, color='red', linestyle='--', label=f'Mean: ${expected_value:.2f}')
+        plt.axvline(worst_case, color='orange', linestyle='--', label=f'5% VaR: ${worst_case:.2f}')
+        plt.xlabel('Portfolio Value ($)')
+        plt.ylabel('Frequency')
+        plt.title(f'Distribution of Final Values - {stock_choice}')
+        plt.legend()
+        plt.grid(True, alpha=0.3)
+        
+        # Save plot to bytes
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png', dpi=100, bbox_inches='tight')
+        plt.close()
+        buf.seek(0)
+        
+        # Convert to base64 for Gradio
+        plot_base64 = base64.b64encode(buf.read()).decode('utf-8')
+        plot_html = f'<img src="data:image/png;base64,{plot_base64}" width="100%">'
+        
+        return result_text, plot_html
+        
+    except Exception as e:
+        error_msg = f"❌ Error occurred: {str(e)}"
+        print(error_msg)
+        return error_msg, None
 
-# 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**")
+# Create Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(), title="Simple Stock Risk Analyzer") as demo:
+    gr.Markdown("""
+    # 📈 Simple Stock Risk Analyzer
+    **Analyze stock risk using Monte Carlo simulations**
+    
+    *This app helps you understand the potential risk and returns of individual stocks.*
+    """)
     
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("### Select Stocks")
-            stock_checkboxes = gr.CheckboxGroup(
-                choices=app.stock_list,
-                label="Choose stocks for analysis",
-                value=[0, 1, 2]  # Default: AAPL, MSFT, GOOGL
+        with gr.Column(scale=1):
+            gr.Markdown("### 🔧 Configuration")
+            
+            stock_dropdown = gr.Dropdown(
+                choices=[
+                    "AAPL - Apple",
+                    "MSFT - Microsoft", 
+                    "GOOGL - Google",
+                    "AMZN - Amazon",
+                    "TSLA - Tesla",
+                    "META - Meta Platforms",
+                    "NVDA - NVIDIA",
+                    "NFLX - Netflix"
+                ],
+                value="AAPL - Apple",
+                label="Select Stock",
+                info="Choose one stock to analyze"
             )
             
-            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")
-            
-            analyze_btn = gr.Button("🚀 Run Analysis", variant="primary")
-        
-        with gr.Column():
-            gr.Markdown("### Analysis Results")
-            results_html = gr.HTML()
+            days_slider = gr.Slider(
+                minimum=30,
+                maximum=365,
+                value=252,
+                step=30,
+                label="Time Horizon (Days)",
+                info="252 days = 1 trading year"
+            )
             
-            with gr.Row():
-                gauge_plot = gr.Plot()
-                sim_plot = gr.Plot()
+            simulations_slider = gr.Slider(
+                minimum=1000,
+                maximum=10000,
+                value=5000,
+                step=1000,
+                label="Number of Simulations",
+                info="More simulations = more accurate results"
+            )
             
-            dist_plot = gr.Plot()
-    
-    # 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
+            analyze_btn = gr.Button("🚀 Analyze Risk", variant="primary", size="lg")
+            
+            gr.Markdown("""
+            ---
+            **💡 How it works:**
+            1. Select a stock from the dropdown
+            2. Set your time horizon
+            3. Choose number of simulations
+            4. Click "Analyze Risk"
+            5. View your risk report!
+            """)
         
-        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
-    
+        with gr.Column(scale=2):
+            gr.Markdown("### 📊 Analysis Results")
+            
+            results_output = gr.Textbox(
+                label="Risk Analysis Report",
+                lines=10,
+                max_lines=15,
+                show_copy_button=True
+            )
+            
+            plot_output = gr.HTML(
+                label="Value Distribution Chart"
+            )
+
+    # Set up the analysis function
     analyze_btn.click(
-        fn=run_complete_analysis,
-        inputs=[stock_checkboxes, days_slider, sims_dropdown],
-        outputs=[results_html, gauge_plot, sim_plot, dist_plot]
+        fn=analyze_stock,
+        inputs=[stock_dropdown, days_slider, simulations_slider],
+        outputs=[results_output, plot_output]
+    )
+    
+    # Footer
+    gr.Markdown("---")
+    gr.Markdown(
+        """
+        <div style="text-align: center; color: #666;">
+            <p>Built with ❤️ using Gradio & Yahoo Finance | Simple Stock Risk Analyzer v1.0</p>
+        </div>
+        """
     )
 
+# Launch the app
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch(share=True, debug=True)