Upload 4 files

app.py

@@ -0,0 +1,172 @@
+# ---------------- APP ----------------
+# This is the main file to run the Gradio application.
+# It imports logic from logic.py and configuration from config.py
+
+import gradio as gr
+
+# Import constants needed for the UI
+from config import CRISIS_PERIODS, EXAMPLE_PORTFOLIOS, CRISIS_SUMMARY
+
+# Import the main simulation function
+from logic import run_crisis_simulation
+
+# --- UI Helper Functions ---
+
+def load_example(example_name):
+    """Updates ticker and weight textboxes based on selection."""
+    portfolio = EXAMPLE_PORTFOLIOS.get(example_name, {"tickers": "", "weights": ""})
+    return gr.update(value=portfolio["tickers"]), gr.update(value=portfolio["weights"])
+
+def update_crisis_summary(crisis_name):
+    """Updates the crisis summary text when a crisis is selected."""
+    summary = CRISIS_SUMMARY.get(crisis_name, "")
+    if summary:
+        return f"**Crisis summary:** _{summary}_"
+    return ""
+
+# ---------------- UI DEFINITION ----------------
+
+with gr.Blocks(theme=gr.themes.Soft(), title="Crisis Lens (India)") as demo:
+    gr.Markdown(
+        """
+        # 🇮🇳 Crisis Lens — Indian Stock Stress Simulator
+        How would your portfolio have performed during a major market crisis? 
+        Select a historical crisis and your portfolio to find out.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            crisis_dd = gr.Dropdown(
+                list(CRISIS_PERIODS.keys()),
+                label="Select Crisis",
+                value="COVID-19 Crash (India)",
+            )
+            crisis_info = gr.Markdown(
+                f"**Crisis summary:** _{CRISIS_SUMMARY['COVID-19 Crash (India)']}_",
+                elem_classes="crisis-summary",
+            )
+        with gr.Column(scale=1):
+            example_loader_dd = gr.Dropdown(
+                list(EXAMPLE_PORTFOLIOS.keys()), 
+                label="Load Example Portfolio", 
+                value="Select Example...",  # will be overridden by .load()
+            )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 1. Define Your Portfolio")
+            upload_csv = gr.File(
+                label="Upload Portfolio CSV (Ticker,Weight)",
+                file_types=[".csv"]
+            )
+            gr.Markdown("...or enter manually below:")
+            
+            # Set default values to blank, they will be filled by the load_example function
+            tickers_input = gr.Textbox(
+                label="Tickers (comma separated)",
+                value=""
+            )
+            weights_input = gr.Textbox(
+                label="Weights (comma separated)",
+                value=""
+            )
+            
+            add_etf_cb = gr.Checkbox(
+                label="Add 5% NIFTYBEES.NS to portfolio (diversify)",
+                value=False
+            )
+
+            gr.Markdown("---")
+            gr.Markdown("### 🤖 2. AI Insights (Optional)")
+            gemini_api_key_in = gr.Textbox(
+                label="Gemini API Key (optional, not stored)",
+                placeholder="Paste your Gemini API key here to get AI-generated insights",
+                type="password",
+            )
+            gemini_extra_prompt_in = gr.Textbox(
+                label="Extra instructions for AI (optional)",
+                placeholder="e.g., Focus more on risk, or write in simple language, etc.",
+                lines=2,
+            )
+
+            gr.Markdown("---")
+            run_btn = gr.Button("Run Simulation", variant="primary")
+            logs_txt = gr.Textbox(label="Status / Logs", interactive=False)
+
+        with gr.Column(scale=3):
+            gr.Markdown("### 3. Analyze the Results")
+            plot_performance = gr.Plot()
+            with gr.Row():
+                metrics_output = gr.Markdown()
+                pie_chart = gr.Plot()
+            with gr.Row():
+                sector_plot_output = gr.Plot()
+                insights_output = gr.Markdown()
+
+            gr.Markdown("### 🤖 AI-Generated Insights")
+            gemini_insights_md = gr.Markdown(
+                value="*AI insights will appear here after running simulation with a Gemini API key.*"
+            )
+
+    # ---------------- EVENT HANDLERS ----------------
+    
+    # Update crisis summary when crisis selection changes
+    crisis_dd.change(
+        fn=update_crisis_summary,
+        inputs=[crisis_dd],
+        outputs=[crisis_info],
+    )
+    
+    # Connect the example loader dropdown to the textboxes
+    example_loader_dd.change(
+        fn=load_example,
+        inputs=[example_loader_dd],
+        outputs=[tickers_input, weights_input],
+    )
+
+    # Connect the "Run" button to the main simulation function
+    run_btn.click(
+        run_crisis_simulation,
+        inputs=[
+            crisis_dd,
+            upload_csv,
+            tickers_input,
+            weights_input,
+            add_etf_cb,
+            gemini_api_key_in,
+            gemini_extra_prompt_in,
+        ],
+        outputs=[
+            plot_performance,
+            metrics_output,
+            sector_plot_output,
+            insights_output,
+            pie_chart,
+            logs_txt,
+            gemini_insights_md,
+        ],
+    )
+    
+    def load_default_example():
+        default_name = "Large-Cap (Default)"
+        portfolio = EXAMPLE_PORTFOLIOS.get(default_name, {"tickers": "", "weights": ""})
+        summary = CRISIS_SUMMARY.get("COVID-19 Crash (India)", "")
+        return (
+            gr.update(value=default_name),
+            gr.update(value=portfolio["tickers"]),
+            gr.update(value=portfolio["weights"]),
+            f"**Crisis summary:** _{summary}_",
+        )
+
+    demo.load(
+        fn=load_default_example,
+        inputs=None,
+        outputs=[example_loader_dd, tickers_input, weights_input, crisis_info],
+    )
+
+
+# ---------------- LAUNCH ----------------
+
+if __name__ == "__main__":
+    demo.launch(share=True, debug=True)

config.py

@@ -0,0 +1,106 @@
+# ---------------- CONFIG ----------------
+# This file contains all static configuration data for the application.
+
+CRISIS_PERIODS = {
+    "2008 Global Financial Crisis (India)": ("2008-01-01", "2009-03-31"),
+    "COVID-19 Crash (India)": ("2020-02-01", "2020-11-30"),
+    "Demonetization Shock (2016)": ("2016-11-01", "2017-02-28"),
+    "IL&FS Debt Crisis (2018)": ("2018-08-01", "2018-12-31"),
+    "Ketan Parekh / Dot-com Burst (India)": ("2000-03-01", "2001-09-30"),
+}
+
+BENCHMARK_TICKER = "^NSEI"
+BENCHMARK_NAME = "NIFTY 50"
+RECOVERY_DAYS = 90
+
+CRISIS_SUMMARY = {
+    "2008 Global Financial Crisis (India)": "Global credit and liquidity crisis; banks and financials hit hard; heavy foreign outflows.",
+    "COVID-19 Crash (India)": "Rapid market fall in Mar 2020 due to pandemic lockdowns; tech & pharma were more resilient.",
+    "Demonetization Shock (2016)": "Policy shock in Nov 2016 causing short-term consumption & liquidity effects.",
+    "IL&FS Debt Crisis (2018)": "Infrastructure debt/default scare leading to liquidity risk concerns for NBFCs and financials.",
+    "Ketan Parekh / Dot-com Burst (India)": "Late 1990s / early 2000s Indian IT/tech boom and subsequent bust after financial irregularities.",
+}
+
+CRISIS_INSIGHTS = {
+    "COVID-19 Crash (India)": {
+        "Information Technology": "IT companies showed resilience as global digital adoption rose; services exports continued.",
+        "Banks": "Banks faced short-term credit stress and moratoriums; credit growth slowed.",
+        "Energy": "Lower demand due to lockdowns hit energy & fuel consumption.",
+        "Pharmaceuticals": "Pharma and healthcare often outperformed due to demand for medical supplies.",
+    },
+    "2008 Global Financial Crisis (India)": {
+        "Finance": "Banks and NBFCs suffered due to global liquidity freeze and foreign capital outflows.",
+        "Metals & Mining": "Commodity demand slump affected exporters and metal companies.",
+    },
+    "Demonetization Shock (2016)": {
+        "Consumer Discretionary": "Spending fell short-term; small businesses faced cash shortages.",
+        "Banking": "Short-term spike in deposits but transactional disruption.",
+    },
+    "IL&FS Debt Crisis (2018)": {
+        "Financial Services": "NBFCs and related sectors were directly impacted due to counterparty risk.",
+    },
+    "Ketan Parekh / Dot-com Burst (India)": {
+        "Information Technology": "Large re-rating and correction after speculative run-up in tech/IT names.",
+    },
+}
+
+EXAMPLE_PORTFOLIOS = {
+    "Large-Cap (Default)": {
+        "tickers": "RELIANCE.NS, TCS.NS, HDFCBANK.NS",
+        "weights": "0.4, 0.3, 0.3",
+    },
+    "IT / Tech Focus": {
+        "tickers": "TCS.NS, INFY.NS, WIPRO.NS, HCLTECH.NS",
+        "weights": "0.3, 0.3, 0.2, 0.2",
+    },
+    "Banking Focus": {
+        "tickers": "HDFCBANK.NS, ICICIBANK.NS, SBIN.NS, KOTAKBANK.NS",
+        "weights": "0.3, 0.3, 0.2, 0.2",
+    },
+    "Diversified (Mock)": {
+        "tickers": "RELIANCE.NS, HDFCBANK.NS, INFY.NS, HINDUNILVR.NS, ITC.NS",
+        "weights": "0.2, 0.2, 0.2, 0.2, 0.2",
+    },
+    "Pharma Focus": {
+        "tickers": "SUNPHARMA.NS, DRREDDY.NS, CIPLA.NS, DIVISLAB.NS",
+        "weights": "0.25, 0.25, 0.25, 0.25",
+    },
+    "Select Example...": {"tickers": "", "weights": ""},  # Placeholder
+}
+
+# -------------------------
+# Gemini / LLM Config
+# -------------------------
+GEMINI_MODEL_NAME = "gemini-2.0-flash-lite-001"
+
+GEMINI_SYSTEM_PROMPT = """
+You are a senior Indian equity and portfolio analyst.
+You explain historical crisis behaviour of portfolios in short, clear bullet-point insights.
+
+Guidelines:
+- Focus on Indian equity context and the specific crisis mentioned.
+- Use simple language but keep it financially accurate.
+- Use only the metrics scorecard provided (no assumptions about individual sectors or stocks).
+- Be concise: 5–7 bullet points, maximum ~200 words.
+- Avoid giving investment advice; stay descriptive and educational.
+"""
+
+GEMINI_USER_PROMPT_TEMPLATE = """
+You are analysing how an investor's portfolio behaved during the historical crisis: {crisis_name}.
+
+Here is a scorecard comparing their portfolio vs NIFTY during that crisis window:
+
+{metrics_text}
+
+TASK:
+- Write 5–7 short bullet points.
+- Explain:
+  - How the portfolio did vs NIFTY overall.
+  - What the volatility and max drawdown imply.
+  - Whether the portfolio looked relatively resilient or vulnerable in that period.
+- Keep it under 200 words.
+- Do NOT mention that you are an AI model or talk about prompts.
+
+Extra style/emphasis from the user (if any):
+{extra_instructions}
+"""

logic.py

@@ -0,0 +1,458 @@
+# ---------------- LOGIC ----------------
+# This file contains all the data processing and simulation logic.
+
+import pandas as pd
+import numpy as np
+import yfinance as yf
+import plotly.express as px
+import plotly.graph_objects as go
+import matplotlib.pyplot as plt
+import warnings
+from datetime import timedelta
+
+# Import configuration variables
+from config import (
+    CRISIS_PERIODS,
+    BENCHMARK_TICKER,
+    BENCHMARK_NAME,
+    RECOVERY_DAYS,
+    CRISIS_SUMMARY,
+    CRISIS_INSIGHTS,
+    GEMINI_MODEL_NAME,
+    GEMINI_SYSTEM_PROMPT,
+    GEMINI_USER_PROMPT_TEMPLATE,
+)
+
+warnings.filterwarnings("ignore")
+
+try:
+    import google.generativeai as genai
+except ImportError:
+    genai = None
+
+# ---------------- UTILS ----------------
+
+def _ensure_ns_suffix(t):
+    """Ensures a ticker has the .NS suffix for Indian stocks."""
+    t = t.strip().upper()
+    if t.startswith("^") or "." in t:
+        return t
+    return t + ".NS"
+
+def _fetch_prices(tickers, start, end):
+    """Fetches historical price data from yfinance."""
+    raw = yf.download(tickers, start=start, end=end, progress=False, auto_adjust=True)
+    if "Adj Close" in raw:
+        df = raw["Adj Close"]
+    elif "Close" in raw:
+        df = raw["Close"]
+    else:
+        df = raw
+    if isinstance(df, pd.Series):
+        df = df.to_frame()
+    # Handle single ticker download which doesn't have multi-index cols
+    if not isinstance(df.columns, pd.MultiIndex):
+        df.columns = [c.upper() for c in df.columns]
+    return df
+
+def calc_metrics(series, benchmark_returns=None):
+    """Calculates key performance metrics for a time series."""
+    returns = series.pct_change().dropna()
+    if returns.empty:
+        return {
+            "total_return": 0,
+            "volatility": 0,
+            "VaR_95": 0,
+            "CAGR": 0,
+            "max_drawdown": 0,
+            "beta": None,
+        }
+    
+    total_return = (series.iloc[-1] / series.iloc[0]) - 1
+    vol = returns.std() * np.sqrt(252)
+    VaR_95 = returns.quantile(0.05)
+    days = (series.index[-1] - series.index[0]).days
+    years = max(days / 365.25, 1 / 365.25)
+    CAGR = (series.iloc[-1] / series.iloc[0]) ** (1 / years) - 1
+    drawdown = (series / series.cummax()) - 1
+    max_dd = drawdown.min()
+    beta = None
+    if benchmark_returns is not None:
+        rr, br = returns.align(benchmark_returns, join="inner")
+        if len(rr) > 10:
+            cov = np.cov(rr, br)[0, 1]
+            varb = np.var(br)
+            beta = cov / varb if varb != 0 else np.nan
+    return {
+        "total_return": total_return,
+        "volatility": vol,
+        "VaR_95": VaR_95,
+        "CAGR": CAGR,
+        "max_drawdown": max_dd,
+        "beta": beta,
+    }
+
+def sector_from_ticker(t):
+    """Fetches sector and industry info for a ticker."""
+    try:
+        info = yf.Ticker(t).info
+        return info.get("sector", "Unknown"), info.get("industry", "Unknown")
+    except Exception:
+        return "Unknown", "Unknown"
+
+def format_pct(x):
+    """Formats a float as a percentage string."""
+    if x is None or (isinstance(x, float) and np.isnan(x)):
+        return "N/A"
+    return f"{x * 100:.2f}%"
+
+# ---------------- GEMINI AI HELPER ----------------
+
+def generate_gemini_insights(
+    api_key: str,
+    crisis_name: str,
+    metrics_md: str,
+    extra_instructions: str = "",
+) -> str:
+    """Call Gemini to get AI-generated insights based on metrics."""
+    if not api_key:
+        return "ℹ️ To see AI-generated insights, please paste a valid Gemini API key."
+    
+    if genai is None:
+        return "⚠️ google-generativeai is not installed. Run `pip install google-generativeai` and retry."
+    
+    user_prompt = GEMINI_USER_PROMPT_TEMPLATE.format(
+        crisis_name=crisis_name,
+        metrics_text=metrics_md,
+        extra_instructions=extra_instructions or "None.",
+    )
+    
+    try:
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel(
+            GEMINI_MODEL_NAME,
+            system_instruction=GEMINI_SYSTEM_PROMPT.strip(),
+            generation_config={"max_output_tokens": 256},
+        )
+        response = model.generate_content(user_prompt)
+        text = getattr(response, "text", "") or ""
+        if not text.strip():
+            return "⚠️ Gemini did not return any text. Please check your API key, quota, or try again."
+        return text.strip()
+    except Exception as e:
+        return f"⚠️ Gemini call failed: {e}"
+
+# ---------------- SIMULATION ----------------
+
+def run_crisis_simulation(
+    crisis,
+    uploaded,
+    tickers_str,
+    weights_str,
+    include_etf,
+    gemini_api_key="",
+    gemini_extra_prompt="",
+):
+    """
+    The main simulation function.
+    Takes user inputs, processes the portfolio, fetches data,
+    and returns all outputs for the Gradio interface.
+    """
+    
+    # --- 1. Parse Portfolio ---
+    if uploaded is not None:
+        try:
+            df = pd.read_csv(uploaded.name if hasattr(uploaded, "name") else uploaded)
+        except Exception as e:
+            return (
+                None,
+                f"Error reading CSV: {e}",
+                None,
+                None,
+                None,
+                "",
+                "No AI insights (CSV error).",
+            )
+    else:
+        try:
+            tickers = [t.strip() for t in tickers_str.split(",") if t.strip()]
+            weights = [float(w) for w in weights_str.split(",") if w.strip()]
+            if not tickers or not weights or len(tickers) != len(weights):
+                return (
+                    None,
+                    "Error: Mismatch between tickers and weights, or fields are empty.",
+                    None,
+                    None,
+                    None,
+                    "",
+                    "No AI insights (input mismatch).",
+                )
+            df = pd.DataFrame({"Ticker": tickers, "Weight": weights})
+        except ValueError:
+            return (
+                None,
+                "Error: Weights must be numbers.",
+                None,
+                None,
+                None,
+                "",
+                "No AI insights (weights error).",
+            )
+
+    if df.empty or "Ticker" not in df or "Weight" not in df:
+        return (
+            None,
+            "Error: Invalid portfolio. Check inputs.",
+            None,
+            None,
+            None,
+            "",
+            "No AI insights (invalid portfolio).",
+        )
+
+    df["Ticker"] = df["Ticker"].apply(_ensure_ns_suffix)
+    
+    # --- 2. Normalize Weights (with ETF logic) ---
+    try:
+        if include_etf:
+            # Scale user's portfolio to 95%
+            df["Weight"] = (
+                df["Weight"].astype(float) / df["Weight"].astype(float).sum()
+            ) * 0.95
+            # Add the 5% ETF
+            etf_row = pd.DataFrame([{"Ticker": "NIFTYBEES.NS", "Weight": 0.05}])
+            df = pd.concat([df, etf_row], ignore_index=True)
+        else:
+            # Normalize user's portfolio to 100%
+            df["Weight"] = df["Weight"].astype(float) / df["Weight"].astype(float).sum()
+    except ZeroDivisionError:
+        return (
+            None,
+            "Error: Portfolio weights sum to zero.",
+            None,
+            None,
+            None,
+            "",
+            "No AI insights (weights zero).",
+        )
+
+    # --- 3. Fetch Data ---
+    start, end = CRISIS_PERIODS[crisis]
+    recovery_end = pd.to_datetime(end) + pd.Timedelta(days=RECOVERY_DAYS)
+    
+    tickers = list(df["Ticker"].unique()) + [BENCHMARK_TICKER]
+    
+    prices = _fetch_prices(tickers, start, recovery_end)
+    if prices.empty:
+        return (
+            None,
+            "No data found. Some tickers may not exist historically.",
+            None,
+            None,
+            None,
+            "",
+            "No AI insights (no data).",
+        )
+    
+    # Ensure all required tickers were fetched
+    fetched_tickers = [c.upper() for c in prices.columns]
+    required_tickers = [t.upper() for t in df["Ticker"]] + [BENCHMARK_TICKER.upper()]
+    
+    missing = [t for t in required_tickers if t not in fetched_tickers]
+    if missing:
+        return (
+            None,
+            f"Error: Could not fetch data for: {', '.join(missing)}",
+            None,
+            None,
+            None,
+            "",
+            "No AI insights (missing tickers).",
+        )
+
+    prices.ffill(inplace=True)
+    crisis_window = prices.loc[start:end]
+    
+    if BENCHMARK_TICKER not in crisis_window.columns:
+        return (
+            None,
+            f"Error: Could not fetch benchmark {BENCHMARK_NAME} data for this period.",
+            None,
+            None,
+            None,
+            "",
+            "No AI insights (benchmark error).",
+        )
+    
+    bench = crisis_window[BENCHMARK_TICKER]
+    
+    # --- 4. Calculate Portfolio Performance ---
+    df_aligned = df.set_index("Ticker")
+    df_aligned.index = df_aligned.index.str.upper()
+    
+    # Filter price columns to only those in our portfolio
+    portfolio_prices = crisis_window[df_aligned.index]
+    
+    norm = (portfolio_prices / portfolio_prices.iloc[0]) * 100
+    weighted = (norm * df_aligned["Weight"]).sum(axis=1)
+    weighted.name = "Portfolio"
+    bench_norm = (bench / bench.iloc[0]) * 100
+
+    port_m = calc_metrics(weighted, bench.pct_change())
+    bench_m = calc_metrics(bench_norm)
+
+    # --- 5. Generate Outputs (Metrics Table) ---
+    beta_val = port_m["beta"]
+    if beta_val is None or (isinstance(beta_val, float) and np.isnan(beta_val)):
+        beta_str = "N/A"
+    else:
+        beta_str = f"{beta_val:.2f}"
+
+    metrics_md = f"""### Simulation: {crisis}
+| Metric | Portfolio | {BENCHMARK_NAME} |
+|:---|---:|---:|
+| **Total Return** | **{format_pct(port_m['total_return'])}** | **{format_pct(bench_m['total_return'])}** |
+| Max Drawdown | {format_pct(port_m['max_drawdown'])} | {format_pct(bench_m['max_drawdown'])} |
+| Volatility (Ann.) | {format_pct(port_m['volatility'])} | {format_pct(bench_m['volatility'])} |
+| CAGR | {format_pct(port_m['CAGR'])} | {format_pct(bench_m['CAGR'])} |
+| Beta | {beta_str} | - |
+| VaR (95%, Daily) | {format_pct(port_m['VaR_95'])} | {format_pct(bench_m['VaR_95'])} |
+"""
+
+    # --- 6. Generate Outputs (Performance Plot) ---
+    fig = go.Figure()
+    fig.add_trace(
+        go.Scatter(
+            x=weighted.index,
+            y=weighted.values,
+            name="Portfolio",
+            mode="lines",
+            line=dict(width=3, color="#1E88E5"),
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=bench_norm.index,
+            y=bench_norm.values,
+            name=BENCHMARK_NAME,
+            mode="lines",
+            line=dict(width=2, color="#FFC107", dash="dot"),
+        )
+    )
+    fig.update_layout(
+        title=f"<b>{crisis}</b>: Portfolio vs Benchmark Performance",
+        template="plotly_white",
+        xaxis_title="Date",
+        yaxis_title="Normalized Value (Base 100)",
+        height=450,
+        legend=dict(yanchor="top", y=0.99, xanchor="left", x=0.01),
+    )
+
+    # --- 7. Generate Outputs (Sector Analysis) ---
+    df["Sector"], df["Industry"] = zip(*df["Ticker"].map(sector_from_ticker))
+    sector_dd = []
+    for t in df.Ticker:
+        if t.upper() in crisis_window.columns:
+            ser = crisis_window[t.upper()]
+            dd = (ser / ser.cummax() - 1).min()
+            sector_dd.append(dd)
+        else:
+            sector_dd.append(0)  # Ticker wasn't in crisis window
+            
+    df["Drawdown"] = sector_dd
+    
+    # Aggregate weighted drawdown by sector
+    sec_agg = df.groupby("Sector").apply(
+        lambda d: np.average(d["Drawdown"], weights=d["Weight"] / d["Weight"].sum())
+    )
+    sec_agg = sec_agg.sort_values()
+
+    sec_fig = px.bar(
+        sec_agg * 100,
+        y=sec_agg.index,
+        x=sec_agg.values,
+        orientation="h",
+        title="Weighted Max Drawdown by Sector",
+        labels={"x": "Max Drawdown (%)", "y": "Sector"},
+    )
+    sec_fig.update_layout(
+        template="plotly_white",
+        yaxis={"categoryorder": "total ascending"},
+    )
+
+    # --- 8. Generate Outputs (Insights & Pie Chart) ---
+    ins = [
+        f"### Insights for: {crisis}",
+        f"_{CRISIS_SUMMARY.get(crisis, 'No summary available.')}_",
+    ]
+    if crisis in CRISIS_INSIGHTS:
+        for s, txt in CRISIS_INSIGHTS[crisis].items():
+            ins.append(f"- **{s}**: {txt}")
+    insights_md = "\n".join(ins)
+    
+    # --- 8. Generate Outputs (Insights & Pie Chart) ---
+    ins = [
+        f"### Insights for: {crisis}",
+        f"_{CRISIS_SUMMARY.get(crisis, 'No summary available.')}_",
+    ]
+    if crisis in CRISIS_INSIGHTS:
+        for s, txt in CRISIS_INSIGHTS[crisis].items():
+            ins.append(f"- **{s}**: {txt}")
+    insights_md = "\n".join(ins)
+
+    # --- 8. Generate Outputs (Insights & Pie Chart) ---
+    ins = [
+        f"### Insights for: {crisis}",
+        f"_{CRISIS_SUMMARY.get(crisis, 'No summary available.')}_",
+    ]
+    if crisis in CRISIS_INSIGHTS:
+        for s, txt in CRISIS_INSIGHTS[crisis].items():
+            ins.append(f"- **{s}**: {txt}")
+    insights_md = "\n".join(ins)
+
+    # --- 8. Generate Outputs (Insights & Pie Chart) ---
+    ins = [
+        f"### Insights for: {crisis}",
+        f"_{CRISIS_SUMMARY.get(crisis, 'No summary available.')}_",
+    ]
+    if crisis in CRISIS_INSIGHTS:
+        for s, txt in CRISIS_INSIGHTS[crisis].items():
+            ins.append(f"- **{s}**: {txt}")
+    insights_md = "\n".join(ins)
+
+    # --- Pie chart: final portfolio weights (including ETF if added) ---
+    pie_df = df[["Ticker", "Weight"]].copy()
+    pie_df["Ticker"] = pie_df["Ticker"].astype(str)
+    pie_df["Weight"] = pd.to_numeric(pie_df["Weight"], errors="raise")
+
+    wsum = pie_df["Weight"].sum()
+    if wsum <= 0:
+        raise ValueError(f"Pie chart error: portfolio weights sum to {wsum}.")
+    pie_df["Weight"] = pie_df["Weight"] / wsum
+
+    print("DEBUG pie_df for pie chart:\n", pie_df)
+    print("DEBUG weight sum:", pie_df["Weight"].sum())
+
+    # Matplotlib pie chart
+    fig_pie, ax = plt.subplots(figsize=(4, 4))
+    ax.pie(
+        pie_df["Weight"].values,
+        labels=pie_df["Ticker"].values,
+        autopct="%1.1f%%", 
+        startangle=90,
+    )
+    ax.set_title("Final Portfolio Allocation")
+    ax.axis("equal")
+
+    # --- 9. Logs & AI Insights ---
+    log_message = f"✅ Simulation Complete. Received weights: '{weights_str}'"
+
+    gemini_insights = generate_gemini_insights(
+        api_key=gemini_api_key or "",
+        crisis_name=crisis,
+        metrics_md=metrics_md,
+        extra_instructions=gemini_extra_prompt or "",
+    )
+
+    return fig, metrics_md, sec_fig, insights_md, fig_pie, log_message, gemini_insights
+

requirements.txt

@@ -0,0 +1,7 @@
+pandas
+numpy
+yfinance
+plotly
+gradio
+matplotlib
+google-generativeai