Create app.py

app.py

@@ -0,0 +1,142 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import plotly.express as px
+import scipy.optimize as sco
+from datetime import datetime, timedelta
+import requests
+import random
+
+# Predefined S&P 500 Stock List (Example Tickers, replace with real ones if needed)
+SP500_TICKERS = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 'BRK-B', 'NVDA', 'JPM', 'JNJ', 'V', 'PG', 'UNH', 'HD', 'MA', 'DIS', 'PYPL', 'NFLX', 'KO', 'XOM', 'PFE']
+
+def fetch_stock_data(tickers, start_date, end_date):
+    url = "https://yahoo-finance166.p.rapidapi.com/api/news/list-by-symbol"
+    querystring = {"s": ",".join(tickers), "region": "US", "snippetCount": "500"}
+    headers = {
+        "x-rapidapi-key": "YOUR_RAPIDAPI_KEY",
+        "x-rapidapi-host": "yahoo-finance166.p.rapidapi.com"
+    }
+    try:
+        response = requests.get(url, headers=headers, params=querystring)
+        data = response.json()
+        if not data:
+            raise ValueError("No stock data returned. Please check the API response.")
+        return pd.DataFrame(data)
+    except Exception as e:
+        return f"Error fetching stock data: {str(e)}"
+
+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)))}  # Volatility constraint
+    )
+    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
+    num_assets = len(returns.columns)
+    args = (returns,)
+    constraints = (
+        {'type': 'eq', 'fun': lambda x: np.sum(x) - 1},  # Sum of weights must be 1
+    )
+    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=1000):
+    projected_return = np.dot(weights, mu) * years
+    return initial_investment * (1 + projected_return)
+
+def output_results(risk_level):
+    try:
+        start_date = (datetime.now() - timedelta(days=365 * 5)).strftime('%Y-%m-%d')
+        end_date = datetime.now().strftime('%Y-%m-%d')
+        selected_tickers = random.sample(SP500_TICKERS, 15)
+
+        stocks_df = fetch_stock_data(selected_tickers, start_date, end_date)
+        if isinstance(stocks_df, str):
+            return stocks_df, None, None, "Error", "Error", "Error", None, None, None
+
+        returns = stocks_df.pct_change().dropna()
+        risk_thresholds = {"Low": 0.10, "Medium": 0.20, "High": 0.30}
+        max_volatility = risk_thresholds.get(risk_level, 0.20)
+        optimized_weights = optimize_portfolio(returns, max_volatility)
+        mu = returns.mean() * 252
+        portfolio_return, portfolio_volatility, sharpe_ratio = calculate_portfolio_metrics(optimized_weights, returns)
+
+        expected_annual_return = f'{(portfolio_return * 100):.2f}%'
+        annual_volatility = f'{(portfolio_volatility * 100):.2f}%'
+        sharpe_ratio_str = f'{sharpe_ratio:.2f}'
+
+        weights_df = pd.DataFrame({'Ticker': selected_tickers, 'Weight': optimized_weights})
+        correlation_matrix = stocks_df.corr()
+        fig_corr = px.imshow(correlation_matrix, text_auto=True, title='Stock Correlation Matrix')
+        cumulative_returns = (returns + 1).cumprod()
+        fig_cum_returns = px.line(cumulative_returns, title='Cumulative Returns of Individual Stocks')
+
+        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 Investment Growth')
+
+        return fig_cum_returns, weights_df, fig_corr, expected_annual_return, annual_volatility, sharpe_ratio_str, fig_simulation
+    except Exception as e:
+        return f"Unexpected error: {str(e)}", None, None, "Error", "Error", "Error", None, None, None
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue='yellow')) as app:
+    gr.Markdown("## Beginner-Friendly Investment Portfolio Generator")
+    gr.Markdown("Select your risk level and let the app generate a balanced portfolio based on the S&P 500.")
+    
+    risk_level = gr.Radio(["Low", "Medium", "High"], label="Select Your Risk Level")
+    btn = gr.Button("Generate Portfolio", elem_id='highlighted-button')
+    
+    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 of Individual Stocks")
+        weights_df = gr.DataFrame(label="Optimized Weights")
+    
+    with gr.Row():
+        fig_corr = gr.Plot(label="Stock Correlation Matrix")
+        fig_simulation = gr.Plot(label="Projected Investment Growth")
+    
+    btn.click(output_results, inputs=[risk_level], outputs=[
+        fig_cum_returns, weights_df, fig_corr, expected_annual_return, 
+        annual_volatility, sharpe_ratio, fig_simulation
+    ])
+
+app.css = """
+    #highlighted-button {
+        background-color: yellow !important;
+        font-weight: bold;
+        border: 2px solid black;
+        padding: 10px;
+        font-size: 16px;
+        cursor: pointer;
+    }
+"""
+
+app.launch()