Create app.py

app.py

@@ -0,0 +1,456 @@
+# app.py — Volatility Mean-Reversion
+import io
+from datetime import datetime, timedelta
+
+import numpy as np
+import pandas as pd
+import streamlit as st
+import yfinance as yf
+import statsmodels.api as sm
+from statsmodels.tsa.stattools import adfuller
+from statsmodels.tsa.regime_switching.markov_regression import MarkovRegression
+from plotly.subplots import make_subplots
+import plotly.graph_objects as go
+
+
+# ============================== Page config ===============================
+st.set_page_config(page_title="Volatility Mean-Reversion", layout="wide")
+st.title("Volatility Mean-Reversion")
+
+st.markdown(
+    "Compare **implied** volatility (VIX) with **realized** volatility of the S&P 500, "
+    "test for stationarity, estimate mean-reversion speeds (AR(1) and OU), and detect "
+    "high/low-volatility regimes with a 2-state Markov model."
+)
+
+# ================================ Sidebar ================================
+with st.sidebar:
+    st.header("Controls")
+
+    # Data window
+    with st.expander("Data Window", expanded=False):
+        default_start = datetime(2015, 1, 1).date()
+        default_end = (datetime.today().date() + timedelta(days=1))
+        start_date = st.date_input(
+            "Start date",
+            value=default_start,
+            min_value=datetime(2000, 1, 1).date(),
+            max_value=default_end,
+            help="Earlier start = more history. Later start = faster."
+        )
+        end_date = st.date_input(
+            "End date",
+            value=default_end,
+            min_value=default_start,
+            max_value=default_end,
+            help="Default is today + 1 to include latest close."
+        )
+
+    # Realized vol settings
+    with st.expander("Realized Volatility", expanded=False):
+        rv_window = st.number_input(
+            "Realized-vol window (days)",
+            value=21, min_value=5, max_value=63, step=1,
+            help="Rolling window for realized volatility (annualized)."
+        )
+        scale_mode = st.selectbox(
+            "Scaling of realized vol vs VIX",
+            options=["Auto (match means)", "Manual factor"],
+            index=0,
+            help="Aligns realized vol to VIX scale for the gap chart."
+        )
+        scale_factor = 1.0
+        if scale_mode == "Manual factor":
+            scale_factor = st.number_input(
+                "Manual scaling factor",
+                value=1.0, min_value=0.1, max_value=10.0, step=0.1,
+                help="Multiply realized vol by this factor before comparing to VIX."
+            )
+
+    # AR(1) & OU
+    with st.expander("Mean-Reversion", expanded=False):
+        ou_roll_window = st.number_input(
+            "OU rolling window (days)",
+            value=252, min_value=63, max_value=756, step=21,
+            help="Lookback for rolling OU half-life estimates."
+        )
+
+    # Markov switching
+    with st.expander("Regime Model", expanded=False):
+        ms_states = st.number_input(
+            "Regimes (fixed at 2)",
+            value=2, min_value=2, max_value=2, step=0,
+            help="Two regimes: low volatility and high volatility."
+        )
+
+    run_btn = st.button("Run Analysis", type="primary")
+
+
+# ================================ Caching ================================
+@st.cache_data(show_spinner=False)
+def fetch_yf_close(tickers: list[str], start: str, end: str) -> pd.DataFrame:
+    """
+    Cached Yahoo Finance close prices for the requested tickers/date range.
+    """
+    data = yf.download(
+        tickers, start=start, end=end, progress=False, auto_adjust=False
+    )
+    # Flatten potential MultiIndex columns (['Close']['^VIX'])
+    if isinstance(data.columns, pd.MultiIndex):
+        data.columns = [" ".join([str(c) for c in tup]).strip() for tup in data.columns]
+    # Keep closes only
+    cols = [c for c in data.columns if "Close" in c]
+    out = data[cols].copy()
+    # rename standard tickers
+    rename = {}
+    for c in out.columns:
+        if "^VIX" in c: rename[c] = "VIX"
+        if "^GSPC" in c: rename[c] = "SPX"
+    out = out.rename(columns=rename)
+    return out.sort_index().ffill()
+
+
+# =============== Small helpers ===============
+def _date_str(d): return pd.to_datetime(d).strftime("%Y-%m-%d")
+
+def _tickformatstops():
+    # dynamic, granular date ticks on zoom
+    day   = 24*3600*1000
+    week  = 7*day
+    return [
+        dict(dtickrange=[None, day],   value="%b %d\n%Y"),
+        dict(dtickrange=[day, week],   value="%b %d"),
+        dict(dtickrange=[week, "M1"],  value="%b %d\n%Y"),
+        dict(dtickrange=["M1", "M6"],  value="%b %Y"),
+        dict(dtickrange=["M6", None],  value="%Y"),
+    ]
+
+def _white_axes(fig):
+    fig.update_layout(template="plotly_dark", font=dict(color="white"))
+    if hasattr(fig.layout, "annotations"):
+        for a in fig.layout.annotations:
+            a.font = dict(color="white", size=12)
+    fig.update_xaxes(
+        ticklabelmode="period",
+        tickformatstops=_tickformatstops(),
+        tickangle=0,
+        tickfont=dict(color="white"),
+        title_font=dict(color="white"),
+        showgrid=True, gridcolor="rgba(160,160,160,0.2)",
+        showline=True, linecolor="rgba(255,255,255,0.4)"
+    )
+    fig.update_yaxes(
+        tickfont=dict(color="white"),
+        title_font=dict(color="white"),
+        showgrid=True, gridcolor="rgba(160,160,160,0.2)",
+        showline=True, linecolor="rgba(255,255,255,0.4)"
+    )
+    return fig
+
+
+# =============================== Run =====================================
+if run_btn:
+    # ---------- Data ----------
+    start_str, end_str = _date_str(start_date), _date_str(end_date)
+    with st.spinner("Fetching VIX & SPX…"):
+        px = fetch_yf_close(["^VIX", "^GSPC"], start_str, end_str)
+    if px.empty or "VIX" not in px or "SPX" not in px:
+        st.error("Couldn’t fetch VIX/SPX. Adjust dates and try again.")
+        st.stop()
+
+    vix = px["VIX"].copy()
+    spx = px["SPX"].copy()
+
+    # Realized vol from SPX log returns
+    log_ret = np.log(spx).diff()
+    rv = log_ret.rolling(int(rv_window)).std() * np.sqrt(252)
+    rv = rv.dropna()
+
+    # Align VIX to realized-vol index
+    vix = vix.reindex(rv.index).ffill()
+
+    # Scaling
+    if scale_mode.startswith("Auto"):
+        sf = float(vix.mean() / rv.mean()) if rv.mean() != 0 else 1.0
+    else:
+        sf = float(scale_factor)
+    rv_scaled = rv * sf
+    diff = vix - rv_scaled
+
+    # ===================== SECTION 1 — Gap: VIX vs Realized Vol =====================
+    st.header("1) Implied vs Realized Volatility")
+    with st.expander("Methodology", expanded=False):
+        st.write("**Goal:** Compare implied volatility (VIX) to realized volatility of the S&P 500 and track their gap.")
+        st.write("**Realized volatility** (annualized) from log returns over window \(w\):")
+        st.latex(r"r_t=\ln\frac{P_t}{P_{t-1}},\qquad \sigma^{(w)}_t=\sqrt{252}\cdot \operatorname{stdev}\!\big(r_{t-w+1},\dots,r_t\big)")
+        st.write("**Scaling** aligns magnitudes for comparison:")
+        st.latex(r"\tilde{\sigma}_t = s \cdot \sigma^{(w)}_t,\quad s=\frac{\overline{\text{VIX}}}{\overline{\sigma^{(w)}}}\ \ \text{(auto, or manual factor)}")
+        st.write("**Gap (VIX – scaled realized)**:")
+        st.latex(r"\Delta_t=\text{VIX}_t-\tilde{\sigma}_t")
+        st.write(
+            "- **Δ > 0**: implied > realized → options rich / risk premium elevated.\n"
+            "- **Δ < 0**: realized ≥ implied → options cheap vs recent movement."
+        )
+
+    fig1 = make_subplots(rows=2, cols=1, shared_xaxes=True,
+                         subplot_titles=("VIX vs Scaled Realized Vol", "Gap: VIX – Scaled Realized Vol"))
+    fig1.add_trace(go.Scatter(x=vix.index, y=vix, name="VIX"), row=1, col=1)
+    fig1.add_trace(go.Scatter(x=rv_scaled.index, y=rv_scaled, name=f"Realized Vol × {sf:.2f}"), row=1, col=1)
+    fig1.add_trace(go.Scatter(x=diff.index, y=diff, name="Gap Δ"), row=2, col=1)
+    fig1.add_hline(y=0, line_dash="dash", line_color="rgba(180,180,180,0.8)", row=2, col=1)
+    fig1.update_yaxes(title_text="Vol level", row=1, col=1)
+    fig1.update_yaxes(title_text="Δ (points)", row=2, col=1)
+    fig1.update_xaxes(title_text="Date", row=2, col=1)
+    fig1.update_layout(height=600, legend=dict(orientation="h", y=1.05, x=0))
+    _white_axes(fig1)
+    st.plotly_chart(fig1, use_container_width=True)
+
+    # Short read
+    with st.expander("Quick Read (current)", expanded=False):
+        last_dt = rv.index[-1].date()
+        st.write(
+            f"As of **{last_dt}**: VIX = **{float(vix.iloc[-1]):.2f}**, "
+            f"scaled realized = **{float(rv_scaled.iloc[-1]):.2f}**, gap Δ = **{float(diff.iloc[-1]):+.2f}**."
+        )
+
+    # ===================== SECTION 2 — Stationarity (ADF) & Rolling Diagnostics =====================
+    st.header("2) Stationarity & Rolling Diagnostics (log-vol)")
+    with st.expander("Methodology", expanded=False):
+        st.write("Test whether log-vol processes are stationary (mean-reverting) and show rolling mean/std.")
+        st.write("**Log transform:**")
+        st.latex(r"x_t=\ln(\text{VIX}_t),\qquad y_t=\ln(\sigma^{(w)}_t)")
+        st.write("**ADF test** (null: unit root / non-stationary):")
+        st.latex(r"\Delta z_t=\alpha+\beta t+\gamma z_{t-1}+\sum_{i=1}^{p}\phi_i \Delta z_{t-i}+\varepsilon_t\quad\text{(test } \gamma=0\text{)}")
+        st.write("Rejecting the null suggests stationarity (mean-reversion).")
+        st.write("We also show **252-day rolling mean** and **std** of log-vol.")
+
+    log_vix = np.log(vix).dropna()
+    log_rv = np.log(rv).dropna()
+    # Align for plotting windows
+    w_roll = 252
+    # ADF
+    adf_v = adfuller(log_vix, autolag="AIC")
+    adf_r = adfuller(log_rv, autolag="AIC")
+
+    # Rolling diag figure
+    fig2 = make_subplots(rows=2, cols=1, shared_xaxes=True,
+                         subplot_titles=("log(VIX) with 252-day Rolling Mean/Std",
+                                         "log(Realized Vol) with 252-day Rolling Mean/Std"))
+    fig2.add_trace(go.Scatter(x=log_vix.index, y=log_vix, name="log(VIX)"), row=1, col=1)
+    fig2.add_trace(go.Scatter(x=log_vix.index, y=log_vix.rolling(w_roll).mean(), name="Rolling Mean", line=dict(dash="dash")), row=1, col=1)
+    fig2.add_trace(go.Scatter(x=log_vix.index, y=log_vix.rolling(w_roll).std(), name="Rolling Std", line=dict(dash="dot")), row=1, col=1)
+
+    fig2.add_trace(go.Scatter(x=log_rv.index, y=log_rv, name="log(Realized Vol)"), row=2, col=1)
+    fig2.add_trace(go.Scatter(x=log_rv.index, y=log_rv.rolling(w_roll).mean(), name="Rolling Mean", line=dict(dash="dash")), row=2, col=1)
+    fig2.add_trace(go.Scatter(x=log_rv.index, y=log_rv.rolling(w_roll).std(), name="Rolling Std", line=dict(dash="dot")), row=2, col=1)
+
+    fig2.update_yaxes(title_text="log scale", row=1, col=1)
+    fig2.update_yaxes(title_text="log scale", row=2, col=1)
+    fig2.update_xaxes(title_text="Date", row=2, col=1)
+    fig2.update_layout(height=600, legend=dict(orientation="h", y=1.05, x=0))
+    _white_axes(fig2)
+    st.plotly_chart(fig2, use_container_width=True)
+
+    # ADF results
+    def _fmt_adf(label, res):
+        stat, pval, usedlag, nobs, crit, icbest = res
+        interp = "Reject H₀ → stationary" if (stat < crit["5%"] and pval < 0.05) else "Fail to reject H₀"
+        return {
+            "Series": label,
+            "ADF stat": f"{stat:.3f}",
+            "p-value": f"{pval:.4f}",
+            "5% crit": f"{crit['5%']:.3f}",
+            "Interp": interp
+        }
+    st.table(pd.DataFrame([_fmt_adf("log(VIX)", adf_v), _fmt_adf("log(Realized Vol)", adf_r)]))
+
+    # ===================== SECTION 3 — AR(1) & Half-Life =====================
+    st.header("3) AR(1) Mean-Reversion & Shock Half-Life")
+    with st.expander("Methodology", expanded=False):
+        st.write("Fit AR(1) to log-vol and compute the shock half-life.")
+        st.latex(r"z_t = c + \phi z_{t-1} + \varepsilon_t")
+        st.write("If \(0<\phi<1\), shocks decay geometrically. **Half-life**:")
+        st.latex(r"\text{HL} = -\frac{\ln 2}{\ln \phi}")
+        st.write("Shorter HL ⇒ faster mean-reversion.")
+
+    def estimate_ar1(series: pd.Series):
+        y = series.dropna()
+        y_lag = y.shift(1).dropna()
+        y = y.loc[y_lag.index]
+        X = sm.add_constant(y_lag)
+        res = sm.OLS(y, X).fit()
+        c = float(res.params["const"])
+        phi = float(res.params[y_lag.name])
+        return c, phi, res
+
+    c_v, phi_v, res_v = estimate_ar1(log_vix)
+    c_r, phi_r, res_r = estimate_ar1(log_rv)
+
+    def half_life_from_phi(phi: float):
+        if phi <= 0 or phi >= 1:
+            return np.nan
+        return -np.log(2) / np.log(phi)
+
+    hl_v = half_life_from_phi(phi_v)
+    hl_r = half_life_from_phi(phi_r)
+
+    # Scatter + regression lines (side-by-side)
+    def _scatter_fit(series, c, phi, name, color):
+        y = series.dropna()
+        xlag = y.shift(1).dropna()
+        y = y.loc[xlag.index]
+        x_line = np.linspace(float(xlag.min()), float(xlag.max()), 100)
+        return xlag, y, x_line, c + phi * x_line, name, color
+
+    x1, y1, xl1, yl1, n1, col1 = _scatter_fit(log_vix, c_v, phi_v, "log(VIX)", "#00d2ff")
+    x2, y2, xl2, yl2, n2, col2 = _scatter_fit(log_rv,  c_r, phi_r,  "log(Realized Vol)", "#ff8ef8")
+
+    fig3 = make_subplots(rows=1, cols=2, subplot_titles=(
+        f"AR(1) on log(VIX): φ={phi_v:.3f}, HL={hl_v:.1f}d" if np.isfinite(hl_v) else f"AR(1) on log(VIX): φ={phi_v:.3f}",
+        f"AR(1) on log(Realized Vol): φ={phi_r:.3f}, HL={hl_r:.1f}d" if np.isfinite(hl_r) else f"AR(1) on log(Realized Vol): φ={phi_r:.3f}"
+    ))
+    fig3.add_trace(go.Scatter(x=x1, y=y1, mode="markers", marker=dict(size=3, opacity=0.5, color=col1), name=n1), row=1, col=1)
+    fig3.add_trace(go.Scatter(x=xl1, y=yl1, mode="lines", line=dict(width=2, color=col1), name="fit"), row=1, col=1)
+    fig3.add_trace(go.Scatter(x=x2, y=y2, mode="markers", marker=dict(size=3, opacity=0.5, color=col2), name=n2), row=1, col=2)
+    fig3.add_trace(go.Scatter(x=xl2, y=yl2, mode="lines", line=dict(width=2, color=col2), name="fit"), row=1, col=2)
+    fig3.update_xaxes(title_text="lagged log-vol", row=1, col=1)
+    fig3.update_yaxes(title_text="log-vol",       row=1, col=1)
+    fig3.update_xaxes(title_text="lagged log-vol", row=1, col=2)
+    fig3.update_yaxes(title_text="log-vol",       row=1, col=2)
+    fig3.update_layout(height=450, legend=dict(orientation="h", y=1.05, x=0))
+    _white_axes(fig3)
+    st.plotly_chart(fig3, use_container_width=True)
+
+    st.caption(
+        f"AR(1) φ: VIX = **{phi_v:.3f}**, Realized = **{phi_r:.3f}**. "
+        f"Half-life (days): VIX = **{hl_v:.1f}**, Realized = **{hl_r:.1f}** "
+        "(if φ∈(0,1))."
+    )
+
+    # ===================== SECTION 4 — OU Parameters & Rolling Half-Life =====================
+    st.header("4) Ornstein–Uhlenbeck (OU) & Rolling Half-Life")
+    with st.expander("Methodology", expanded=False):
+        st.write("Estimate discrete-time OU parameters via Δx regression and track rolling half-life.")
+        st.latex(r"\Delta x_t = a + b\,x_{t-1} + \varepsilon_t \quad\Rightarrow\quad \kappa=-b,\ \ \mu=\frac{a}{\kappa},\ \ \text{HL}=\frac{\ln 2}{\kappa}")
+        st.write("Interpretation: **κ>0** → mean-reverting toward **μ**. Larger κ → faster reversion (shorter HL).")
+
+    def estimate_ou_params(x: pd.Series):
+        x = x.dropna()
+        dx = x.diff().dropna()
+        x_lag = x.shift(1).loc[dx.index]
+        X = sm.add_constant(x_lag)
+        res = sm.OLS(dx, X).fit()
+        a = float(res.params["const"])
+        b = float(res.params[x_lag.name])
+        kappa = -b
+        mu = a / kappa if kappa != 0 else np.nan
+        hl = np.log(2) / kappa if kappa > 0 else np.nan
+        sigma = float(res.resid.std())
+        return kappa, mu, sigma, hl
+
+    k_v, mu_v, sig_v, hl_v_ou = estimate_ou_params(log_vix)
+    k_r, mu_r, sig_r, hl_r_ou = estimate_ou_params(log_rv)
+
+    st.caption(
+        f"OU κ (speed): VIX = **{k_v:.4f}**, Realized = **{k_r:.4f}** | "
+        f"HL (days): VIX = **{hl_v_ou:.1f}**, Realized = **{hl_r_ou:.1f}**"
+    )
+
+    # Rolling half-life series
+    roll = int(ou_roll_window)
+    def rolling_ou_hl(x: pd.Series, w: int):
+        out_idx, out_vals = [], []
+        for i in range(w, len(x)):
+            seg = x.iloc[i-w:i]
+            k, _, _, hl = estimate_ou_params(seg)
+            out_idx.append(x.index[i])
+            out_vals.append(hl)
+        return pd.Series(out_vals, index=pd.Index(out_idx, name="Date"))
+
+    hl_v_ts = rolling_ou_hl(log_vix, roll)
+    hl_r_ts = rolling_ou_hl(log_rv,  roll)
+    med_v = float(hl_v_ts.median(skipna=True)) if len(hl_v_ts) else np.nan
+    med_r = float(hl_r_ts.median(skipna=True)) if len(hl_r_ts) else np.nan
+
+    fig4 = make_subplots(rows=1, cols=1, subplot_titles=(f"Rolling OU Half-Life (window={roll}d)",))
+    fig4.add_trace(go.Scatter(x=hl_v_ts.index, y=hl_v_ts, name="HL log(VIX)", line=dict(width=1)))
+    fig4.add_trace(go.Scatter(x=hl_r_ts.index, y=hl_r_ts, name="HL log(Realized Vol)", line=dict(width=1)))
+    if np.isfinite(med_v): fig4.add_hline(y=med_v, line_dash="dash", line_color="#00d2ff", annotation_text=f"Median VIX HL {med_v:.1f}d")
+    if np.isfinite(med_r): fig4.add_hline(y=med_r, line_dash="dash", line_color="#ff8ef8", annotation_text=f"Median RV HL {med_r:.1f}d")
+    fig4.update_yaxes(title_text="Half-life (days)")
+    fig4.update_xaxes(title_text="Date")
+    fig4.update_layout(height=450, legend=dict(orientation="h", y=1.05, x=0))
+    _white_axes(fig4)
+    st.plotly_chart(fig4, use_container_width=True)
+
+    # ===================== SECTION 5 — Markov Regimes on log(Realized Vol) =====================
+    st.header("5) High/Low-Volatility Regimes (Markov Switching)")
+    with st.expander("Methodology", expanded=False):
+        st.write("Two-state Markov model on log realized volatility with switching variance.")
+        st.latex(r"y_t \sim \mathcal{N}(\mu_{s_t},\,\sigma^2_{s_t}),\quad s_t\in\{0,1\}")
+        st.latex(r"P=\begin{bmatrix}p_{00} & p_{01}\\ p_{10} & p_{11}\end{bmatrix},\quad \text{Exp spell length of state }j=\frac{1}{1-p_{jj}}")
+        st.write(
+            "The high-vol regime is identified as the state with the higher mean \( \mu \). "
+            "We plot smoothed probabilities and shade periods with \( P(\text{high-vol})>0.5 \)."
+        )
+
+    y_ms = np.log(rv).dropna()
+    try:
+        ms = MarkovRegression(y_ms, k_regimes=2, trend="c", switching_variance=True)
+        res = ms.fit(disp=False)
+        p = res.smoothed_marginal_probabilities  # columns [0,1]
+        # Transition matrix
+        P = res.model.regime_transition_matrix(res.params).squeeze()
+        # Identify high-vol
+        mean0 = (y_ms * p[0]).sum() / p[0].sum()
+        mean1 = (y_ms * p[1]).sum() / p[1].sum()
+        high = 1 if mean1 > mean0 else 0
+        p_high = p[high]
+
+        # Expected spell lengths
+        p00, p11 = float(P[0, 0]), float(P[1, 1])
+        exp_len_0 = 1.0 / (1.0 - p00) if p00 < 1 else np.inf
+        exp_len_1 = 1.0 / (1.0 - p11) if p11 < 1 else np.inf
+
+        # Plot series + shading and probability
+        fig5 = make_subplots(rows=2, cols=1, shared_xaxes=True,
+                             subplot_titles=("log(Realized Vol) with High-Vol Shading",
+                                             f"Smoothed Probability of High-Vol Regime (State {high})"))
+        fig5.add_trace(go.Scatter(x=y_ms.index, y=y_ms, name="log(Realized Vol)"), row=1, col=1)
+        # Shading where p_high > 0.5
+        mask = p_high > 0.5
+        # Highlight spans by drawing rectangles across contiguous True segments
+        grp = (mask != mask.shift()).cumsum()
+        for _, span in mask[mask].groupby(grp):
+            x0 = span.index[0]; x1 = span.index[-1]
+            fig5.add_vrect(x0=x0, x1=x1, fillcolor="red", opacity=0.2, line_width=0, row=1, col=1)
+        fig5.add_trace(go.Scatter(x=p_high.index, y=p_high, name="P(High-Vol)"), row=2, col=1)
+        fig5.add_hline(y=0.5, line_dash="dash", line_color="rgba(180,180,180,0.8)", row=2, col=1)
+        fig5.update_yaxes(title_text="log-vol", row=1, col=1)
+        fig5.update_yaxes(title_text="Probability", row=2, col=1, range=[0, 1])
+        fig5.update_xaxes(title_text="Date", row=2, col=1)
+        fig5.update_layout(height=600, legend=dict(orientation="h", y=1.05, x=0))
+        _white_axes(fig5)
+        st.plotly_chart(fig5, use_container_width=True)
+
+        # Transition matrix & durations
+        st.subheader("Regime Persistence")
+        tbl = pd.DataFrame(
+            [[P[0,0], P[0,1]], [P[1,0], P[1,1]]],
+            index=["to Reg-0", "to Reg-1"], columns=["from Reg-0", "from Reg-1"]
+        ).round(4)
+        st.table(tbl)
+        st.caption(
+            f"Expected spell lengths — Reg-0: **{exp_len_0:.1f}** days, Reg-1: **{exp_len_1:.1f}** days. "
+            f"High-vol identified as **Reg-{high}**."
+        )
+    except Exception as e:
+        st.warning(f"Markov model failed to converge: {e}")
+
+    # ============================ Footer note =============================
+    st.markdown(
+        "<sub>Note: analytical settings (windows, scaling, etc.) recompute from the "
+        "cached price data. Changing dates triggers a new data fetch; changing parameters "
+        "does not.</sub>",
+        unsafe_allow_html=True
+    )