Update app.py

app.py

@@ -1,95 +1,159 @@
 import gradio as gr
+import yfinance as yf
+import requests
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
 
-# Define stocks with their events and impacts
-stocks = {
-    "AAPL": {
-        "events": [
-            {"name": "New iPhone release", "impact_if_happens": 0.10, "impact_if_not": -0.05},
-            {"name": "Positive earnings report", "impact_if_happens": 0.08, "impact_if_not": -0.03},
-        ]
-    },
-    "TSLA": {
-        "events": [
-            {"name": "Achieves production target", "impact_if_happens": 0.15, "impact_if_not": -0.10},
-            {"name": "New model announcement", "impact_if_happens": 0.12, "impact_if_not": -0.02},
-        ]
-    },
-    "GOOG": {
-        "events": [
-            {"name": "AI breakthrough", "impact_if_happens": 0.20, "impact_if_not": -0.05},
-            {"name": "Regulatory approval", "impact_if_happens": 0.05, "impact_if_not": -0.15},
-        ]
-    },
-}
+# Polymarket GraphQL API endpoint
+POLYMARKET_API = "https://api.polymarket.com/graphql"
 
-def calculate_portfolio(selected_stocks, total_investment, 
-                        aapl_event1_prob, aapl_event2_prob,
-                        tsla_event1_prob, tsla_event2_prob,
-                        goog_event1_prob, goog_event2_prob):
-    # Check if any stocks are selected
-    if not selected_stocks:
-        return "Please select at least one stock."
-    
-    # Map user-input probabilities to stocks (convert from percentage to decimal)
-    probs = {
-        "AAPL": [aapl_event1_prob / 100, aapl_event2_prob / 100],
-        "TSLA": [tsla_event1_prob / 100, tsla_event2_prob / 100],
-        "GOOG": [goog_event1_prob / 100, goog_event2_prob / 100],
+# Function to fetch Polymarket data
+def fetch_polymarket_data(search_term="S&P"):
+    query = """
+    query {
+      markets(first: 5, searchTerm: "%s") {
+        edges {
+          node {
+            id
+            question
+            outcomes {
+              name
+              price
+            }
+          }
+        }
+      }
     }
+    """ % search_term
+    response = requests.post(POLYMARKET_API, json={"query": query})
+    if response.status_code != 200:
+        return None
+    data = response.json()
+    markets = data["data"]["markets"]["edges"]
+    if not markets:
+        return None
     
-    # Calculate expected return for each selected stock
-    expected_returns = {}
-    for stock in selected_stocks:
-        events = stocks[stock]["events"]
-        exp_return = 0
-        for i, event in enumerate(events):
-            p = probs[stock][i]
-            impact_happens = event["impact_if_happens"]
-            impact_not = event["impact_if_not"]
-            exp_return += p * impact_happens + (1 - p) * impact_not
-        expected_returns[stock] = exp_return
-    
-    # Calculate portfolio metrics assuming equal investment
-    num_stocks = len(selected_stocks)
-    investment_per_stock = total_investment / num_stocks
-    portfolio_expected_return = sum(expected_returns[stock] for stock in selected_stocks) / num_stocks
-    expected_future_value = sum(investment_per_stock * (1 + expected_returns[stock]) for stock in selected_stocks)
-    
-    # Format the output
-    output = "Expected Returns:\n"
-    for stock in selected_stocks:
-        output += f"{stock}: {expected_returns[stock]*100:.2f}%\n"
-    output += f"\nPortfolio Expected Return: {portfolio_expected_return*100:.2f}%\n"
-    output += f"Expected Future Value: ${expected_future_value:.2f}"
-    return output
+    # Parse the first relevant market
+    for market in markets:
+        node = market["node"]
+        outcomes = node["outcomes"]
+        if len(outcomes) >= 2:  # Ensure there's at least Yes/No or similar
+            return {
+                "question": node["question"],
+                "outcomes": {outcome["name"]: float(outcome["price"]) for outcome in outcomes}
+            }
+    return None
+
+# Function to fetch Yahoo Finance data and calculate drift/volatility
+def fetch_yahoo_data(ticker):
+    try:
+        stock = yf.download(ticker, period="1y", progress=False)
+        if stock.empty:
+            return None, None, None
+        daily_returns = stock["Adj Close"].pct_change().dropna()
+        mu = daily_returns.mean() * 252  # Annualized drift
+        sigma = daily_returns.std() * np.sqrt(252)  # Annualized volatility
+        last_price = stock["Adj Close"][-1]
+        return mu, sigma, last_price
+    except Exception:
+        return None, None, None
 
-# Define Gradio inputs
-selected_stocks = gr.CheckboxGroup(choices=["AAPL", "TSLA", "GOOG"], label="Select Stocks")
-total_investment = gr.Number(label="Total Investment ($)", value=10000)
+# Monte Carlo Simulation with GBM
+def monte_carlo_simulation(S0, mu, sigma, T, N, sims, risk_factor, pm_data):
+    dt = 1 / 252  # Daily time step
+    steps = int(T * 252)
+    sim_paths = np.zeros((sims, steps + 1))
+    sim_paths[:, 0] = S0
 
-# Probability sliders for each event
-aapl_event1_prob = gr.Slider(0, 100, label="AAPL: Probability of New iPhone release (%)", value=50)
-aapl_event2_prob = gr.Slider(0, 100, label="AAPL: Probability of Positive earnings report (%)", value=50)
-tsla_event1_prob = gr.Slider(0, 100, label="TSLA: Probability of Achieving production target (%)", value=50)
-tsla_event2_prob = gr.Slider(0, 100, label="TSLA: Probability of New model announcement (%)", value=50)
-goog_event1_prob = gr.Slider(0, 100, label="GOOG: Probability of AI breakthrough (%)", value=50)
-goog_event2_prob = gr.Slider(0, 100, label="GOOG: Probability of Regulatory approval (%)", value=50)
+    # Adjust drift based on Polymarket probabilities
+    if pm_data and "outcomes" in pm_data:
+        outcomes = pm_data["outcomes"]
+        bullish_prob = outcomes.get("Yes", 0.5) if "Yes" in outcomes else 0.5
+        bearish_prob = 1 - bullish_prob
+        mu_bull = mu * 1.2 * risk_factor
+        mu_bear = mu * -0.5 * risk_factor
+        mu_adjusted = bullish_prob * mu_bull + bearish_prob * mu_bear
+    else:
+        mu_adjusted = mu * risk_factor
 
-# Define output
-output = gr.Textbox(label="Results")
+    for t in range(1, steps + 1):
+        Z = np.random.standard_normal(sims)
+        sim_paths[:, t] = sim_paths[:, t-1] * np.exp(
+            (mu_adjusted - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z
+        )
+    
+    return sim_paths
+
+# Main simulation function
+def run_simulation(investment, ticker, horizon, num_sims, risk_factor):
+    # Fetch data
+    mu, sigma, S0 = fetch_yahoo_data(ticker)
+    if mu is None:
+        return None, "Invalid ticker or no data available from Yahoo Finance."
+    
+    pm_data = fetch_polymarket_data("S&P")  # Search for S&P-related markets
+    
+    # Run Monte Carlo simulation
+    sim_paths = monte_carlo_simulation(S0, mu, sigma, horizon, num_sims, num_sims, risk_factor, pm_data)
+    final_values = sim_paths[:, -1] * (investment / S0)  # Scale to investment amount
+    
+    # Create histogram
+    fig, ax = plt.subplots(figsize=(8, 6))
+    ax.hist(final_values, bins=50, color="skyblue", edgecolor="black")
+    ax.set_title(f"Distribution of Final Investment Value ({ticker})")
+    ax.set_xlabel("Final Value ($)")
+    ax.set_ylabel("Frequency")
+    plt.tight_layout()
+    
+    # Calculate stats
+    mean_val = np.mean(final_values)
+    min_val = np.min(final_values)
+    max_val = np.max(final_values)
+    std_val = np.std(final_values)
+    
+    # Prepare summary text
+    summary = f"Market Data (Yahoo Finance):\n"
+    summary += f"- Drift (μ): {mu:.4f}\n"
+    summary += f"- Volatility (σ): {sigma:.4f}\n\n"
+    if pm_data:
+        summary += f"Polymarket Data:\n- Question: {pm_data['question']}\n"
+        for outcome, prob in pm_data["outcomes"].items():
+            summary += f"- {outcome}: {prob*100:.1f}%\n"
+    else:
+        summary += "Polymarket Data: No relevant market found.\n"
+    summary += f"\nSimulation Results:\n"
+    summary += f"- Mean Final Value: ${mean_val:.2f}\n"
+    summary += f"- Min Final Value: ${min_val:.2f}\n"
+    summary += f"- Max Final Value: ${max_val:.2f}\n"
+    summary += f"- Std Dev: ${std_val:.2f}"
+    
+    return fig, summary
 
-# Create Gradio interface
-iface = gr.Interface(
-    fn=calculate_portfolio,
-    inputs=[selected_stocks, total_investment, 
-            aapl_event1_prob, aapl_event2_prob,
-            tsla_event1_prob, tsla_event2_prob,
-            goog_event1_prob, goog_event2_prob],
-    outputs=output,
-    title="Investment Decision Analysis POC",
-    description="Select stocks and adjust event probabilities to analyze expected returns based on simulated prediction market data. Event impacts are predefined. Click 'Submit' to see results."
-)
+# Gradio UI
+with gr.Blocks(title="Investment Simulation Platform") as demo:
+    gr.Markdown("# Investment Decision Simulation Platform")
+    gr.Markdown("Simulate investment outcomes using Yahoo Finance data and Polymarket probabilities.")
+    
+    with gr.Row():
+        with gr.Column():
+            investment = gr.Number(label="Investment Amount ($)", value=10000)
+            ticker = gr.Textbox(label="Ticker Symbol (e.g., AAPL, ^GSPC)", value="AAPL")
+            horizon = gr.Number(label="Investment Horizon (Years)", value=1)
+            num_sims = gr.Number(label="Number of Simulations", value=1000)
+            risk_factor = gr.Slider(0.5, 2.0, value=1.0, label="Risk Factor")
+            submit_btn = gr.Button("Run Simulation")
+        
+        with gr.Column():
+            plot_output = gr.Plot(label="Final Value Distribution")
+            text_output = gr.Textbox(label="Simulation Summary", lines=10)
+    
+    submit_btn.click(
+        fn=run_simulation,
+        inputs=[investment, ticker, horizon, num_sims, risk_factor],
+        outputs=[plot_output, text_output]
+    )
 
-# Launch the app
 if __name__ == "__main__":
-    iface.launch()
+    demo.launch()