Update app.py

app.py

@@ -62,8 +62,158 @@ def generate_sample_data(tickers):
         
     return pd.DataFrame(data, index=dates)
 
-# Rest of the code remains the same...
-[Previous code from calculate_portfolio_metrics through the Gradio interface remains unchanged]
+# Predefined S&P 500 Stock List (Sample tickers)
+SP500_TICKERS = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'BRK-B', 'NVDA', 'JPM', 'JNJ', 'V']
+
+def calculate_portfolio_metrics(weights, returns):
+    portfolio_return = np.sum(returns.mean() * weights) * 252
+    portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(returns.cov() * 252, weights)))
+    sharpe_ratio = portfolio_return / portfolio_volatility
+    return portfolio_return, portfolio_volatility, sharpe_ratio
+
+def optimize_portfolio(returns, max_volatility):
+    num_assets = len(returns.columns)
+    args = (returns,)
+    constraints = (
+        {'type': 'eq', 'fun': lambda x: np.sum(x) - 1},  # Sum of weights must be 1
+        {'type': 'ineq', 'fun': lambda x: max_volatility - np.sqrt(np.dot(x.T, np.dot(returns.cov() * 252, x)))}
+    )
+    bounds = tuple((0, 1) for _ in range(num_assets))
+    
+    result = sco.minimize(
+        lambda weights, returns: -calculate_portfolio_metrics(weights, returns)[2],
+        num_assets * [1. / num_assets,],
+        args=args,
+        method='SLSQP',
+        bounds=bounds,
+        constraints=constraints
+    )
+    return result.x
+
+def simulate_investment(weights, mu, years, initial_investment=10000):
+    projected_return = np.dot(weights, mu) * years
+    return initial_investment * (1 + projected_return)
+
+def output_results(risk_level):
+    try:
+        # Select random tickers
+        selected_tickers = random.sample(SP500_TICKERS, min(len(SP500_TICKERS), 5))
+        
+        # Fetch real stock data
+        stocks_df = fetch_stock_data(selected_tickers)
+        
+        if stocks_df.empty:
+            raise ValueError("No stock data received")
+        
+        returns = stocks_df.pct_change().dropna()
+        
+        # Set risk thresholds
+        risk_thresholds = {"Low": 0.15, "Medium": 0.25, "High": 0.35}
+        max_volatility = risk_thresholds.get(risk_level, 0.25)
+        
+        # Calculate optimal portfolio
+        optimized_weights = optimize_portfolio(returns, max_volatility)
+        mu = returns.mean() * 252
+        portfolio_return, portfolio_volatility, sharpe_ratio = calculate_portfolio_metrics(optimized_weights, returns)
+        
+        # Format metrics
+        expected_annual_return = f'{(portfolio_return * 100):.2f}%'
+        annual_volatility = f'{(portfolio_volatility * 100):.2f}%'
+        sharpe_ratio_str = f'{sharpe_ratio:.2f}'
+        
+        # Create visualizations
+        weights_df = pd.DataFrame({
+            'Ticker': selected_tickers,
+            'Weight': [f'{w:.2%}' for w in optimized_weights]
+        })
+        
+        # Correlation matrix
+        correlation_matrix = returns.corr()
+        fig_corr = px.imshow(
+            correlation_matrix,
+            text_auto=True,
+            title='Stock Correlation Matrix',
+            color_continuous_scale='RdBu'
+        )
+        
+        # Cumulative returns
+        cumulative_returns = (1 + returns).cumprod()
+        fig_cum_returns = px.line(
+            cumulative_returns,
+            title='Cumulative Returns of Individual Stocks'
+        )
+        
+        # Investment projection
+        projected_1yr = simulate_investment(optimized_weights, mu, 1)
+        projected_5yr = simulate_investment(optimized_weights, mu, 5)
+        projected_10yr = simulate_investment(optimized_weights, mu, 10)
+        
+        projection_df = pd.DataFrame({
+            "Years": [1, 5, 10],
+            "Projected Value": [projected_1yr, projected_5yr, projected_10yr]
+        })
+        
+        fig_simulation = px.line(
+            projection_df,
+            x='Years',
+            y='Projected Value',
+            title='Projected $10,000 Investment Growth'
+        )
+        
+        return (
+            fig_cum_returns,
+            weights_df,
+            fig_corr,
+            expected_annual_return,
+            annual_volatility,
+            sharpe_ratio_str,
+            fig_simulation
+        )
+        
+    except Exception as e:
+        print(f"Error in output_results: {str(e)}")
+        return None, None, None, f"Error: {str(e)}", "Error", "Error", None
+
+# Create Gradio interface
+with gr.Blocks(theme=gr.themes.Soft()) as app:
+    gr.Markdown("## Investment Portfolio Generator")
+    gr.Markdown("Select your risk level to generate a balanced portfolio based on S&P 500 stocks.")
+    
+    with gr.Row():
+        risk_level = gr.Radio(
+            ["Low", "Medium", "High"],
+            label="Select Your Risk Level",
+            value="Medium"
+        )
+    
+    btn = gr.Button("Generate Portfolio")
+    
+    with gr.Row():
+        expected_annual_return = gr.Textbox(label="Expected Annual Return")
+        annual_volatility = gr.Textbox(label="Annual Volatility")
+        sharpe_ratio = gr.Textbox(label="Sharpe Ratio")
+    
+    with gr.Row():
+        fig_cum_returns = gr.Plot(label="Cumulative Returns")
+        weights_df = gr.DataFrame(label="Portfolio Weights")
+    
+    with gr.Row():
+        fig_corr = gr.Plot(label="Correlation Matrix")
+        fig_simulation = gr.Plot(label="Investment Projection")
+    
+    btn.click(
+        output_results,
+        inputs=[risk_level],
+        outputs=[
+            fig_cum_returns,
+            weights_df,
+            fig_corr,
+            expected_annual_return,
+            annual_volatility,
+            sharpe_ratio,
+            fig_simulation
+        ]
+    )
 
 if __name__ == "__main__":
     app.launch()