Update app.py

app.py

@@ -1,38 +1,1354 @@
-import altair as alt
+# app.py — Market Breadth & Momentum
+import os
+import io
+import time
+import math
+import random
+import threading
+import concurrent.futures as cf
+from datetime import datetime, timedelta
+
 import numpy as np
 import pandas as pd
+import requests
 import streamlit as st
+from plotly.subplots import make_subplots
+import plotly.graph_objects as go
+import os
+
+
+# ----------------------------- Helpers & Caching -----------------------------
+API_KEY = os.getenv("FMP_API_KEY")
+
+
+MAX_WORKERS = 32
+RATE_BACKOFF_MAX = 300
+JITTER_SEC = 0.2
+
+# ----------------------------- Page config -----------------------------
+st.set_page_config(page_title="Market Breadth & Momentum", layout="wide")
+st.title("Market Breadth & Momentum")
+
+st.markdown(
+    "Tracks index trend, participation, and momentum across constituents. "
+    "Shows breadth strength (% above key averages), advance–decline behavior, new highs/lows, "
+    "the McClellan Oscillator, and cross-section momentum heatmaps."
+)
+
+# ----------------------------- Sidebar -----------------------------
+with st.sidebar:
+    st.header("Parameters")
+
+    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 but slower load. Later start = faster."
+        )
+        end_date = st.date_input(
+            "End date",
+            value=default_end,
+            min_value=default_start,
+            max_value=default_end,
+            help="End date is set to today + 1 by default to include the latest close."
+        )
+
+    with st.expander("Breadth Settings", expanded=False):
+        sma_fast = st.number_input(
+            "Fast MA (days)",
+            value=50, min_value=20, max_value=200, step=5,
+            help="Used for % above fast MA and index fast MA. Higher = slower, fewer flips."
+        )
+        sma_slow = st.number_input(
+            "Slow MA (days)",
+            value=200, min_value=100, max_value=400, step=10,
+            help="Used for % above slow MA and index slow MA. Higher = slower, longer trend focus."
+        )
+        vwap_weeks = st.number_input(
+            "VWAP lookback (weeks)",
+            value=200, min_value=52, max_value=520, step=4,
+            help="Anchored weekly VWAP for the index. Higher = more inertia."
+        )
+        ad_smooth = st.number_input(
+            "Adv/Decl smoothing (days)",
+            value=30, min_value=5, max_value=90, step=5,
+            help="Smooths advancing/declining counts. Higher = steadier lines."
+        )
+        mo_span_fast = st.number_input(
+            "McClellan fast EMA (days)",
+            value=19, min_value=5, max_value=30, step=1,
+            help="Fast EMA for McClellan Oscillator. Smaller = more sensitive."
+        )
+        mo_span_slow = st.number_input(
+            "McClellan slow EMA (days)",
+            value=39, min_value=10, max_value=60, step=1,
+            help="Slow EMA for McClellan Oscillator. Larger = smoother baseline."
+        )
+        mo_signal_span = st.number_input(
+            "McClellan signal EMA (days)",
+            value=9, min_value=3, max_value=20, step=1,
+            help="Signal line for the oscillator. Crosses indicate momentum turns."
+        )
+
+    with st.expander("Rebased Comparison", expanded=False):
+        rebase_days = st.number_input(
+            "Window (trading days)",
+            value=365, min_value=60, max_value=1000, step=5,
+            help="Back window for rebased comparison. Longer = more context, smaller features."
+        )
+        rebase_base = st.number_input(
+            "Base level",
+            value=100, min_value=1, max_value=1000, step=1,
+            help="Starting level for rebased lines."
+        )
+        y_pad = st.slider(
+            "Y-range padding",
+            min_value=1, max_value=8, value=3, step=1,
+            help="Higher padding widens the log-scale y-range."
+        )
+
+    with st.expander("Heatmaps", expanded=False):
+        heat_last_days = st.number_input(
+            "Daily return heatmap window (days)",
+            value=60, min_value=20, max_value=252, step=5,
+            help="Number of recent sessions for the daily return heatmap."
+        )
+        mom_look = st.number_input(
+            "Momentum lookback (days)",
+            value=30, min_value=10, max_value=252, step=5,
+            help="Return horizon for the percentile momentum heatmap."
+        )
+
+    run_btn = st.button("Run Analysis", type="primary")
+
+
+def _to_vendor(sym: str) -> str:
+    return sym.replace("-", ".")
+
+_thread_local = threading.local()
+def _session():
+    s = getattr(_thread_local, "session", None)
+    if s is None:
+        s = requests.Session()
+        adapter = requests.adapters.HTTPAdapter(pool_connections=MAX_WORKERS, pool_maxsize=MAX_WORKERS)
+        s.mount("https://", adapter)
+        _thread_local.session = s
+    return s
+
+def _get_json(url: str, params: dict, timeout=60, backoff=5):
+    sess = _session()
+    while True:
+        r = sess.get(url, params=params, timeout=timeout)
+        if r.status_code == 429:
+            time.sleep(backoff)
+            backoff = min(backoff * 2, RATE_BACKOFF_MAX)
+            continue
+        r.raise_for_status()
+        return r.json()
+
+def _parse_hist_payload(payload):
+    item = payload if isinstance(payload, dict) else (payload[0] if payload else {})
+    sym = item.get("symbol")
+    hist = item.get("historical") or []
+    if not sym or not hist:
+        return None, None
+    dfh = pd.DataFrame(hist)
+    if "date" not in dfh or "adjClose" not in dfh:
+        return None, None
+    s = (
+        dfh[["date", "adjClose"]]
+        .dropna()
+        .assign(date=lambda x: pd.to_datetime(x["date"]))
+        .set_index("date")["adjClose"]
+        .rename(sym)
+    )
+    return sym, s
+
+@st.cache_data(show_spinner=False)
+def fetch_sp500_table():
+    url = "https://financialmodelingprep.com/api/v3/sp500_constituent"
+    params = {"apikey": API_KEY}
+    payload = _get_json(url, params)
+    tab = pd.DataFrame(payload)
+    tab = tab.rename(columns={"symbol": "Symbol", "name": "Security"})
+    return tab[["Symbol", "Security"]].dropna()
+
+def _fetch_one(orig_ticker: str, start: str, end: str):
+    time.sleep(random.random() * JITTER_SEC)
+    t_vendor = _to_vendor(orig_ticker)
+    url = f"https://financialmodelingprep.com/api/v3/historical-price-full/{t_vendor}"
+    params = {"from": start, "to": end, "apikey": API_KEY}
+    try:
+        payload = _get_json(url, params)
+        sym, s = _parse_hist_payload(payload)
+        if s is None or s.empty:
+            return orig_ticker, None, "no data"
+        return orig_ticker, s.rename(t_vendor), None
+    except Exception as e:
+        return orig_ticker, None, str(e)
+
+@st.cache_data(show_spinner=False)
+def build_close_parallel(tickers: list[str], start: str, end: str, max_workers: int = MAX_WORKERS):
+    n = len(tickers)
+    series_dict = {}
+    missing = {}
+    lock = threading.Lock()
+
+    def _task(t):
+        orig, s, err = _fetch_one(t, start, end)
+        with lock:
+            if err:
+                missing[orig] = err
+            else:
+                series_dict[s.name] = s
+
+    with cf.ThreadPoolExecutor(max_workers=max_workers) as ex:
+        futures = [ex.submit(_task, t) for t in tickers]
+        for _ in cf.as_completed(futures):
+            pass
+
+    if not series_dict:
+        return pd.DataFrame(), missing
+
+    df = pd.DataFrame(series_dict).sort_index()
+    df.index.name = "date"
+    f_to_o = {_to_vendor(t): t for t in tickers}
+    close = df.rename(columns=f_to_o)
+    close = close[[t for t in tickers if t in close.columns]]
+    return close, missing
+
+@st.cache_data(show_spinner=False)
+def fetch_index_ohlcv(start: str, end: str):
+    # ^GSPC
+    url = "https://financialmodelingprep.com/api/v3/historical-price-full/index/%5EGSPC"
+    params = {"from": start, "to": end, "apikey": API_KEY}
+    backoff = 5
+    while True:
+        r = requests.get(url, params=params, timeout=60)
+        if r.status_code == 429:
+            time.sleep(backoff)
+            backoff = min(backoff * 2, 300)
+            continue
+        r.raise_for_status()
+        payload = r.json()
+        if isinstance(payload, dict) and "historical" in payload:
+            hist = payload["historical"]
+        elif isinstance(payload, list) and payload and "historical" in payload[0]:
+            hist = payload[0]["historical"]
+        else:
+            hist = payload
+        idx_df = (
+            pd.DataFrame(hist)[["date", "close", "volume"]]
+            .assign(date=lambda x: pd.to_datetime(x["date"]))
+            .set_index("date")
+            .sort_index()
+            .rename(columns={"close": "Close", "volume": "Volume"})
+        )
+        return idx_df
+
+def _safe_last(s):
+    s = s.dropna()
+    return s.iloc[-1] if len(s) else np.nan
+
+# ----------------------------- Run -----------------------------
+if run_btn:
+    with st.spinner("Loading tickers…"):
+        try:
+            spx_table = fetch_sp500_table()
+        except Exception:
+            st.error("Ticker table request failed. Try again later.")
+            st.stop()
+
+    tickers = spx_table["Symbol"].tolist()
+    st.caption(f"Constituents loaded: {len(tickers)}")
+
+    start_str = pd.to_datetime(start_date).strftime("%Y-%m-%d")
+    end_str = pd.to_datetime(end_date).strftime("%Y-%m-%d")
+
+    with st.spinner("Fetching historical prices (parallel)…"):
+        close, missing = build_close_parallel(tickers, start_str, end_str)
+    if close.empty:
+        st.error("No price data returned. Reduce the date range and retry.")
+        st.stop()
+
+    if missing:
+        st.warning(f"No data for {min(20, len(missing))} symbols (showing up to 20).")
+
+    clean_close = close.copy()
+
+    with st.spinner("Fetching index data…"):
+        try:
+            idx_df = fetch_index_ohlcv(
+                start=clean_close.index[0].strftime("%Y-%m-%d"),
+                end=end_str
+            )
+        except Exception:
+            st.error("Index data request failed. Try again later.")
+            st.stop()
+
+    idx = idx_df["Close"].reindex(clean_close.index).ffill()
+    idx_volume = idx_df["Volume"].reindex(clean_close.index).ffill()
+
+    # ===================== SECTION 1 — Breadth Dashboard =====================
+    st.header("Breadth Dashboard")
+
+    with st.expander("Methodology", expanded=False):
+        # Overview
+        st.write("This panel tracks trend, participation, and momentum for a broad equity universe.")
+        st.write("Use it to judge trend quality, spot divergences, and gauge risk bias.")
+
+        # 1) Price trend (MAs, VWAP)
+        st.write("**Price trend**")
+        st.write("Simple moving averages (n days):")
+        st.latex(r"\mathrm{SMA}_{n}(t)=\frac{1}{n}\sum_{k=0}^{n-1}P_{t-k}")
+        st.write("Approximate 200-week VWAP (using ~5 trading days per week):")
+        st.latex(r"\mathrm{VWAP}_{200w}(t)=\frac{\sum_{k=0}^{N-1}P_{t-k}V_{t-k}}{\sum_{k=0}^{N-1}V_{t-k}},\quad N\approx200\times5")
+        st.write("Price above both MAs and fast>slow = strong trend.")
+        st.write("Price below both MAs and fast<slow = weak trend.")
+
+        # 2) Participation breadth (% above MAs)
+        st.write("**Participation breadth**")
+        st.write("Share above n-day MA:")
+        st.latex(r"\%\,\text{Above}_n(t)=100\cdot\frac{\#\{i:\ P_{i,t}>\mathrm{SMA}_{n,i}(t)\}}{N}")
+        st.write("Zones: 0–20 weak, 20–50 neutral, 50–80 strong.")
+        st.write("Higher shares mean broad support for the trend.")
+
+        # 3) Advance–Decline line
+        st.write("**Advance–Decline (A/D) line**")
+        st.latex(r"A_t=\#\{i:\ P_{i,t}>P_{i,t-1}\},\quad D_t=\#\{i:\ P_{i,t}<P_{i,t-1}\}")
+        st.latex(r"\mathrm{ADLine}_t=\sum_{u\le t}(A_u-D_u)")
+        st.write("Rising A/D confirms uptrends. Falling A/D warns of narrow leadership.")
+
+        # 4) Net new 52-week highs
+        st.write("**Net new 52-week highs**")
+        st.latex(r"H_{i,t}^{52}=\max_{u\in[t-251,t]}P_{i,u},\quad L_{i,t}^{52}=\min_{u\in[t-251,t]}P_{i,u}")
+        st.latex(r"\text{NewHighs}_t=\sum_i \mathbf{1}\{P_{i,t}=H_{i,t}^{52}\},\quad \text{NewLows}_t=\sum_i \mathbf{1}\{P_{i,t}=L_{i,t}^{52}\}")
+        st.latex(r"\text{NetHighs}_t=\text{NewHighs}_t-\text{NewLows}_t")
+        st.write("Positive and persistent net highs support trend durability.")
+
+        # 5) Smoothed advancing vs declining counts
+        st.write("**Advancing vs declining (smoothed)**")
+        st.latex(r"\overline{A}_t=\frac{1}{w}\sum_{k=0}^{w-1}A_{t-k},\quad \overline{D}_t=\frac{1}{w}\sum_{k=0}^{w-1}D_{t-k}")
+        st.write("Advancers > decliners over the window = constructive breadth.")
+
+        # 6) McClellan Oscillator
+        st.write("**McClellan Oscillator (MO)**")
+        st.latex(r"E^{(n)}_t=\text{EMA}_n(A_t-D_t)")
+        st.latex(r"\mathrm{MO}_t=E^{(19)}_t-E^{(39)}_t")
+        st.write("Zero-line up-cross = improving momentum. Down-cross = fading momentum.")
+        st.write("A 9-day EMA of MO can act as a signal line.")
+
+        # Practical reads
+        st.write("**Practical use**")
+        st.write("- Broad strength: % above 200-day ≥ 50% supports trends.")
+        st.write("- Divergences: index near highs without A/D or MO confirmation = caution.")
+        st.write("- Breadth thrust: sharp rise in % above 50-day to ≥ 55% with a +20pt jump can mark regime turns.")
+        st.write("- MO near recent extremes flags stretched short-term conditions.")
+
+
+    # --- Compute indicators (respecting sidebar params) ---
+    sma_fast_idx = idx.rolling(int(sma_fast), min_periods=int(sma_fast)).mean()
+    sma_slow_idx = idx.rolling(int(sma_slow), min_periods=int(sma_slow)).mean()
+    vwap_days = int(vwap_weeks) * 5
+    vwap_idx = (idx * idx_volume).rolling(vwap_days, min_periods=vwap_days).sum() / \
+               idx_volume.rolling(vwap_days, min_periods=vwap_days).sum()
+
+    sma_fast_all = clean_close.rolling(int(sma_fast), min_periods=int(sma_fast)).mean()
+    sma_slow_all = clean_close.rolling(int(sma_slow), min_periods=int(sma_slow)).mean()
+    pct_above_fast = (clean_close > sma_fast_all).sum(axis=1) / clean_close.shape[1] * 100
+    pct_above_slow = (clean_close > sma_slow_all).sum(axis=1) / clean_close.shape[1] * 100
+
+    advances = (clean_close.diff() > 0).sum(axis=1)
+    declines = (clean_close.diff() < 0).sum(axis=1)
+    ad_line = (advances - declines).cumsum()
+
+    window = int(ad_smooth)
+    avg_adv = advances.rolling(window, min_periods=window).mean()
+    avg_decl = declines.rolling(window, min_periods=window).mean()
+
+    high52 = clean_close.rolling(252, min_periods=252).max()
+    low52 = clean_close.rolling(252, min_periods=252).min()
+    new_highs = (clean_close == high52).sum(axis=1)
+    new_lows = (clean_close == low52).sum(axis=1)
+    net_highs = new_highs - new_lows
+    sma10_net_hi = net_highs.rolling(10, min_periods=10).mean()
+
+    net_adv = (advances - declines).astype("float64")
+    ema_fast = net_adv.ewm(span=int(mo_span_fast), adjust=False).mean()
+    ema_slow = net_adv.ewm(span=int(mo_span_slow), adjust=False).mean()
+    mc_osc = (ema_fast - ema_slow).rename("MO")
+    mo_pos = mc_osc.clip(lower=0)
+    mo_neg = mc_osc.clip(upper=0)
+
+    bound = float(np.nanpercentile(np.abs(mc_osc.dropna()), 99)) if mc_osc.notna().sum() else 20.0
+    bound = max(20.0, math.ceil(bound / 10.0) * 10.0)
+
+    # --- Plot (6 rows) ---
+    # --- Plot (6 rows) — dynamic date ticks on zoom, dark theme, white labels ---
+    fig = make_subplots(
+        rows=6, cols=1, shared_xaxes=True, vertical_spacing=0.03,
+        subplot_titles=(
+            "S&P 500 Price / Fast MA / Slow MA / Weekly VWAP",
+            f"% Above {int(sma_fast)}d & {int(sma_slow)}d",
+            "Advance–Decline Line",
+            "Net New 52-Week Highs (bar) + 10d SMA",
+            f"Advancing vs Declining ({int(window)}d MA)",
+            f"McClellan Oscillator ({int(mo_span_fast)},{int(mo_span_slow)})"
+        )
+    )
+
+    # Enforce dark template + white annotation titles
+    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)
+
+    # Row 1: Price + MAs + VWAP
+    fig.add_trace(go.Scatter(x=idx.index, y=idx, name="S&P 500"), row=1, col=1)
+    fig.add_trace(go.Scatter(x=sma_fast_idx.index, y=sma_fast_idx, name=f"{int(sma_fast)}-day MA"), row=1, col=1)
+    fig.add_trace(go.Scatter(x=sma_slow_idx.index, y=sma_slow_idx, name=f"{int(sma_slow)}-day MA"), row=1, col=1)
+    fig.add_trace(go.Scatter(x=vwap_idx.index, y=vwap_idx, name=f"{int(vwap_weeks)}-week VWAP"), row=1, col=1)
+
+    # Row 2: % Above MAs + zones
+    fig.add_hrect(y0=0, y1=20, line_width=0, fillcolor="red",    opacity=0.3, row=2, col=1)
+    fig.add_hrect(y0=20, y1=50, line_width=0, fillcolor="yellow", opacity=0.3, row=2, col=1)
+    fig.add_hrect(y0=50, y1=80, line_width=0, fillcolor="green",  opacity=0.3, row=2, col=1)
+    fig.add_trace(go.Scatter(x=pct_above_fast.index, y=pct_above_fast, name=f"% Above {int(sma_fast)}d"), row=2, col=1)
+    fig.add_trace(go.Scatter(x=pct_above_slow.index, y=pct_above_slow, name=f"% Above {int(sma_slow)}d"), row=2, col=1)
+    fig.add_annotation(x=0, xref="paper", y=10, yref="y2", text="Weak",    showarrow=False, align="left", font=dict(color="white"))
+    fig.add_annotation(x=0, xref="paper", y=35, yref="y2", text="Neutral", showarrow=False, align="left", font=dict(color="white"))
+    fig.add_annotation(x=0, xref="paper", y=65, yref="y2", text="Strong",  showarrow=False, align="left", font=dict(color="white"))
+
+    # Row 3: A/D Line
+    fig.add_trace(go.Scatter(x=ad_line.index, y=ad_line, name="A/D Line"), row=3, col=1)
+
+    # Row 4: Net new highs + SMA
+    fig.add_trace(go.Bar(x=net_highs.index, y=net_highs, name="Net New Highs", opacity=0.5), row=4, col=1)
+    fig.add_trace(go.Scatter(x=sma10_net_hi.index, y=sma10_net_hi, name="10-day SMA"), row=4, col=1)
+
+    # Row 5: Adv vs Decl (smoothed)
+    fig.add_trace(go.Scatter(x=avg_adv.index,  y=avg_adv,  name=f"Adv ({int(window)}d MA)"), row=5, col=1)
+    fig.add_trace(go.Scatter(x=avg_decl.index, y=avg_decl, name=f"Dec ({int(window)}d MA)"), row=5, col=1)
+
+    # Row 6: McClellan Oscillator histogram
+    fig.add_trace(
+        go.Bar(
+            x=mo_pos.index, y=mo_pos, name="MO +",
+            marker=dict(color="#2ecc71", line=dict(width=0)),
+            hovertemplate="MO: %{y:.1f}<br>%{x|%Y-%m-%d}<extra></extra>",
+            showlegend=False
+        ),
+        row=6, col=1
+    )
+    fig.add_trace(
+        go.Bar(
+            x=mo_neg.index, y=mo_neg, name="MO -",
+            marker=dict(color="#e74c3c", line=dict(width=0)),
+            hovertemplate="MO: %{y:.1f}<br>%{x|%Y-%m-%d}<extra></extra>",
+            showlegend=False
+        ),
+        row=6, col=1
+    )
+    fig.add_hline(y=0, line_width=1, line_dash="dash", line_color="rgba(180,180,180,0.8)", row=6, col=1)
+
+    # Axes styling (white ticks/titles, subtle grid) for ALL subplots
+    fig.update_xaxes(
+        ticklabelmode="period",   # labels at period boundaries
+        tickformatstops=[
+            # < 1 day
+            dict(dtickrange=[None, 24*3600*1000],             value="%b %d\n%Y"),
+            # 1 day .. 1 week
+            dict(dtickrange=[24*3600*1000, 7*24*3600*1000],   value="%b %d"),
+            # 1 week .. 1 month
+            dict(dtickrange=[7*24*3600*1000, "M1"],           value="%b %d\n%Y"),
+            # 1 .. 6 months
+            dict(dtickrange=["M1", "M6"],                     value="%b %Y"),
+            # 6+ months
+            dict(dtickrange=["M6", None],                     value="%Y"),
+        ],
+        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)",
+        rangeslider_visible=False
+    )
+    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)"
+    )
+
+    # Per-row y-axis titles / ranges
+    fig.update_yaxes(title_text="Price",   row=1, col=1)
+    fig.update_yaxes(title_text="Percent", row=2, col=1, range=[0, 100])
+    fig.update_yaxes(title_text="A/D",     row=3, col=1)
+    fig.update_yaxes(title_text="Net",     row=4, col=1)
+    fig.update_yaxes(title_text="Count",   row=5, col=1)
+    fig.update_yaxes(title_text="MO",      row=6, col=1, range=[-bound, bound], side="right")
+
+    # Bottom x-axis title
+    fig.update_xaxes(title_text="Date", row=6, col=1)
+
+    # Layout / legend
+    fig.update_layout(
+        height=1350,
+        bargap=0.02,
+        barmode="relative",
+        legend=dict(
+            orientation="h", yanchor="bottom", y=1.02, xanchor="left", x=0,
+            font=dict(color="white")
+        ),
+        margin=dict(l=60, r=20, t=40, b=40),
+        hovermode="x unified",
+        font=dict(color="white"),
+        title=dict(font=dict(color="white"))
+    )
+
+    st.plotly_chart(fig, use_container_width=True)
+
+    # --- Dynamic interpretation (captured exactly as prints) ---
+    with st.expander("Dynamic Interpretation", expanded=False):
+        buf = io.StringIO()
+
+        def _last_val(s):
+            s = s.dropna()
+            return s.iloc[-1] if len(s) else np.nan
+
+        def _last_date(s):
+            s = s.dropna()
+            return s.index[-1] if len(s) else None
+
+        def _pct(a, b):
+            if not np.isfinite(a) or not np.isfinite(b) or b == 0:
+                return np.nan
+            return (a - b) / b * 100.0
+
+        def _fmt_pct(x):
+            return "n/a" if not np.isfinite(x) else f"{x:.1f}%"
+
+        def _fmt_num(x):
+            return "n/a" if not np.isfinite(x) else f"{x:,.2f}"
+
+        # Values
+        as_of = _last_date(idx)
+
+        px      = _last_val(idx)
+        ma50    = _last_val(sma_fast_idx)
+        ma200   = _last_val(sma_slow_idx)
+        vwap200 = _last_val(vwap_idx)
+
+        p50  = float(_last_val(pct_above_fast))
+        p200 = float(_last_val(pct_above_slow))
+
+        ad_now  = _last_val(ad_line)
+        nh_now  = int(_last_val(new_highs)) if np.isfinite(_last_val(new_highs)) else 0
+        nh_sma  = float(_last_val(sma10_net_hi))
+
+        avg_adv_last  = float(_last_val(avg_adv))
+        avg_decl_last = float(_last_val(avg_decl))
+
+        _ema19     = net_adv.ewm(span=int(mo_span_fast), adjust=False).mean()
+        _ema39     = net_adv.ewm(span=int(mo_span_slow), adjust=False).mean()
+        mc_osc2    = (_ema19 - _ema39).rename("MO")
+        mc_signal  = mc_osc2.ewm(span=int(mo_signal_span), adjust=False).mean().rename("Signal")
+
+        mo_last     = float(_last_val(mc_osc2))
+        mo_prev     = float(_last_val(mc_osc2.shift(1)))
+        mo_5ago     = float(_last_val(mc_osc2.shift(5)))
+        mo_slope5   = mo_last - mo_5ago
+        mo_sig_last = float(_last_val(mc_signal))
+        mo_sig_prev = float(_last_val(mc_signal.shift(1)))
+
+        mo_roll   = mc_osc2.rolling(252, min_periods=126)
+        mo_mean   = mo_roll.mean()
+        mo_std    = mo_roll.std()
+        mo_z      = (mc_osc2 - mo_mean) / mo_std
+        mo_z_last = float(_last_val(mo_z))
+
+        mo_abs = np.abs(mc_osc2.dropna())
+        if len(mo_abs) >= 20:
+            mo_ext = float(np.nanpercentile(mo_abs.tail(252), 90))
+        else:
+            mo_ext = np.nan
+
+        look_fast = 10
+        look_mid  = 20
+        look_div  = 63
+
+        ma50_slope  = _last_val(sma_fast_idx.diff(look_fast))
+        ma200_slope = _last_val(sma_slow_idx.diff(look_mid))
+        p50_chg     = p50  - float(_last_val(pct_above_fast.shift(look_fast)))
+        p200_chg    = p200 - float(_last_val(pct_above_slow.shift(look_fast)))
+        ad_mom      = ad_now - float(_last_val(ad_line.shift(look_mid)))
+
+        d50   = _pct(px, ma50)
+        d200  = _pct(px, ma200)
+        dvw   = _pct(px, vwap200)
+        h63   = float(_last_val(idx.rolling(look_div).max()))
+        dd63  = _pct(px, h63) if np.isfinite(h63) else np.nan
+
+        ad_63h = float(_last_val(ad_line.rolling(look_div).max()))
+        mo_63h = float(_last_val(mc_osc2.rolling(look_div).max()))
+        near_high_px = np.isfinite(h63) and np.isfinite(px) and px >= 0.995 * h63
+        near_high_ad = np.isfinite(ad_63h) and np.isfinite(ad_now) and ad_now >= 0.995 * ad_63h
+        near_high_mo = np.isfinite(mo_63h) and np.isfinite(mo_last) and mo_last >= 0.95 * mo_63h
+
+        breadth_thrust = (p50 >= 55) and (p50_chg >= 20)
+
+        score = 0
+        score += 1 if px > ma50 else 0
+        score += 1 if px > ma200 else 0
+        score += 1 if ma50 > ma200 else 0
+        score += 1 if ma50_slope > 0 else 0
+        score += 1 if p50 >= 50 else 0
+        score += 1 if p200 >= 50 else 0
+        score += 1 if ad_mom > 0 else 0
+        score += 1 if nh_now > 0 and nh_sma >= 0 else 0
+        score += 1 if avg_adv_last > avg_decl_last else 0
+        score += 1 if (mo_last > 0 and mo_slope5 > 0) else 0
+
+        if score >= 8:
+            regime = "Risk-on bias"
+        elif score >= 5:
+            regime = "Mixed bias"
+        else:
+            regime = "Risk-off bias"
+
+        print(f"=== Market breadth narrative — {as_of.date() if as_of is not None else 'N/A'} ===", file=buf)
+
+        # [Trend]
+        print("\n[Trend]", file=buf)
+        if np.isfinite(px) and np.isfinite(ma50) and np.isfinite(ma200):
+            print(
+                "The index is {px}, the 50-day is {ma50}, and the 200-day is {ma200}. "
+                "Price runs {d50} vs the 50-day and {d200} vs the 200-day. "
+                "The 50-day changed by {m50s} over {f} sessions and the 200-day changed by {m200s} over {m} sessions."
+                .format(
+                    px=_fmt_num(px), ma50=_fmt_num(ma50), ma200=_fmt_num(ma200),
+                    d50=_fmt_pct(d50), d200=_fmt_pct(d200),
+                    m50s=f"{ma50_slope:+.2f}" if np.isfinite(ma50_slope) else "n/a",
+                    m200s=f"{ma200_slope:+.2f}" if np.isfinite(ma200_slope) else "n/a",
+                    f=look_fast, m=look_mid
+                ), file=buf
+            )
+            if np.isfinite(vwap200):
+                print("The index is {dvw} versus the 200-week VWAP.".format(dvw=_fmt_pct(dvw)), file=buf)
+            if np.isfinite(dd63):
+                print("Distance from the 3-month high is {dd}.".format(dd=_fmt_pct(dd63)), file=buf)
+            if px > ma50 and ma50 > ma200:
+                print("Structure is bullish: price above both averages and the fast above the slow.", file=buf)
+            elif px < ma50 and ma50 < ma200:
+                print("Structure is bearish: price below both averages and the fast below the slow.", file=buf)
+            else:
+                print("Structure is mixed: levels are not aligned.", file=buf)
+        else:
+            print("Trend inputs are incomplete.", file=buf)
+
+        # [Participation]
+        print("\n[Participation]", file=buf)
+        if np.isfinite(p50) and np.isfinite(p200):
+            print(
+                "{p50} of members sit above the 50-day and {p200} above the 200-day. "
+                "The 50-day share moved {p50chg} over {f} sessions, and the 200-day share moved {p200chg}."
+                .format(
+                    p50=f"{p50:.1f}%", p200=f"{p200:.1f}%",
+                    p50chg=f"{p50_chg:+.1f} pts", p200chg=f"{p200_chg:+.1f} pts", f=look_fast
+                ), file=buf
+            )
+            if p50 < 20 and p200 < 20:
+                print("Participation is very weak across both horizons.", file=buf)
+            elif p50 < 50 and p200 < 50:
+                print("Participation is weak; leadership is narrow.", file=buf)
+            elif p50 >= 50 and p200 < 50:
+                print("Short-term breadth improved, long-term base still soft.", file=buf)
+            elif p50 >= 50 and p200 >= 50:
+                print("Participation is broad and supportive.", file=buf)
+            if breadth_thrust:
+                print("The 50-day breadth jump qualifies as a breadth thrust.", file=buf)
+        else:
+            print("Breadth percentages are missing.", file=buf)
+
+        # [Advance–Decline]
+        print("\n[Advance–Decline]", file=buf)
+        if np.isfinite(ad_now):
+            print(
+                "A/D momentum over {m} sessions is {admom:+.0f}. "
+                "Price is {pxnear} a 3-month high and A/D is {adnear} the same mark."
+                .format(
+                    m=look_mid, admom=ad_mom,
+                    pxnear="near" if near_high_px else "not near",
+                    adnear="near" if near_high_ad else "not near"
+                ), file=buf
+            )
+            if near_high_px and not near_high_ad:
+                print("Price tested highs without A/D confirmation.", file=buf)
+            elif near_high_px and near_high_ad:
+                print("Price and A/D both near recent highs.", file=buf)
+            elif (not near_high_px) and near_high_ad:
+                print("A/D improved while price lagged.", file=buf)
+            else:
+                print("No short-term confirmation signal.", file=buf)
+        else:
+            print("A/D data is unavailable.", file=buf)
+
+        # [McClellan Oscillator]
+        print("\n[McClellan Oscillator]", file=buf)
+        if np.isfinite(mo_last):
+            zero_cross_up   = (mo_prev < 0) and (mo_last >= 0)
+            zero_cross_down = (mo_prev > 0) and (mo_last <= 0)
+            sig_cross_up    = (mo_prev <= mo_sig_prev) and (mo_last > mo_sig_last)
+            sig_cross_down  = (mo_prev >= mo_sig_prev) and (mo_last < mo_sig_last)
+            near_extreme    = np.isfinite(mo_ext) and (abs(mo_last) >= 0.9 * mo_ext)
+
+            print(
+                "MO prints {mo:+.1f} with a 9-day signal at {sig:+.1f}. "
+                "Five-day slope is {slope:+.1f}. Z-score over 1y is {z}."
+                .format(
+                    mo=mo_last, sig=mo_sig_last, slope=mo_slope5,
+                    z=f"{mo_z_last:.2f}" if np.isfinite(mo_z_last) else "n/a"
+                ), file=buf
+            )
+
+            if zero_cross_up:
+                print("Bullish zero-line cross: momentum turned positive.", file=buf)
+            if zero_cross_down:
+                print("Bearish zero-line cross: momentum turned negative.", file=buf)
+            if sig_cross_up:
+                print("Bullish signal cross: MO moved above its 9-day signal.", file=buf)
+            if sig_cross_down:
+                print("Bearish signal cross: MO fell below its 9-day signal.", file=buf)
+
+            if near_extreme:
+                tag = "positive" if mo_last > 0 else "negative"
+                print(f"MO is near a recent {tag} extreme by distribution.", file=buf)
+            elif np.isfinite(mo_ext):
+                print(f"Recent absolute extreme band is about ±{mo_ext:.0f}.", file=buf)
+
+            if near_high_px and not near_high_mo:
+                print("Price near short-term highs without a matching MO high.", file=buf)
+            if (not near_high_px) and near_high_mo:
+                print("MO near a short-term high while price lags.", file=buf)
+        else:
+            print("MO series is unavailable.", file=buf)
+
+        # [New Highs vs Lows]
+        print("\n[New Highs vs Lows]", file=buf)
+        if np.isfinite(nh_sma):
+            if nh_now > 0 and nh_sma >= 0:
+                print("Net new highs are positive and the 10-day trend is non-negative.", file=buf)
+            elif nh_now < 0 and nh_sma <= 0:
+                print("Net new lows dominate and the 10-day trend is negative.", file=buf)
+            else:
+                print("Daily print and 10-day trend disagree; signal is mixed.", file=buf)
+        else:
+            print("High/low series is incomplete.", file=buf)
+
+        # [Advancing vs Declining]
+        print("\n[Advancing vs Declining]", file=buf)
+        if np.isfinite(avg_adv_last) and np.isfinite(avg_decl_last):
+            spread = avg_adv_last - avg_decl_last
+            print(
+                "On a {w}-day smoothing window, advancers average {adv:.0f} and decliners {dec:.0f}. Net spread is {spr:+.0f}."
+                .format(w=window, adv=avg_adv_last, dec=avg_decl_last, spr=spread), file=buf
+            )
+            if spread > 0:
+                print("The spread favors advancers.", file=buf)
+            elif spread < 0:
+                print("The spread favors decliners.", file=buf)
+            else:
+                print("Advancers and decliners are balanced.", file=buf)
+        else:
+            print("Smoothed A/D data is missing.", file=buf)
+
+        # [Aggregate]
+        print("\n[Aggregate]", file=buf)
+        print("Composite score is {score}/10 → {regime}.".format(score=score, regime=regime), file=buf)
+        if regime == "Risk-on bias":
+            if p200 >= 60 and ma200_slope > 0 and mo_last > 0:
+                print("Long-term breadth and MO agree; pullbacks above the 50-day tend to be buyable.", file=buf)
+            else:
+                print("Tone is supportive; watch the 200-day and MO zero-line for confirmation.", file=buf)
+        elif regime == "Mixed bias":
+            print("Signals diverge; manage size and tighten risk until MO and breadth align.", file=buf)
+        else:
+            if p200 <= 40 and ma200_slope < 0 and mo_last < 0:
+                print("Weak long-term breadth with negative MO argues for caution.", file=buf)
+            else:
+                print("Bias leans defensive until breadth steadies and MO turns up.", file=buf)
+
+        # [What to monitor]
+        print("\n[What to monitor]", file=buf)
+        print("Watch the 200-day breadth around 50% for confirmation of durable trends.", file=buf)
+        print("Track MO zero-line and signal crosses during price tests of resistance.", file=buf)
+        print("Look for steady positive net new highs over a 10-day window.", file=buf)
+
+        st.text(buf.getvalue())
+
+    # ===================== SECTION 2 — Rebased Comparison =====================
+    st.header("Rebased Comparison (Last N sessions)")
+
+    with st.expander("Methodology", expanded=False):
+        st.write("Compares stock paths on a common scale and highlights leadership vs laggards.")
+        st.write("Use it to judge breadth, concentration, and dispersion over the selected window.")
+
+        st.write("**Rebasing (start = B)**")
+        st.latex(r"R_{i,t}= \frac{P_{i,t}}{P_{i,t_0}}\times B")
+        st.write("Each line shows cumulative performance since the window start.")
+        st.write("The index is rebased the same way for reference.")
+
+        st.write("**Log scale**")
+        st.write("We plot the y-axis in log scale so equal percent moves look equal.")
+        st.write("Y-range uses robust bounds (1st–99th percentiles) with padding.")
+
+        st.write("**Leaders and laggards**")
+        st.latex(r"\text{Perf}_{i}=R_{i,T}")
+        st.write("Leaders are highest Perf at T. Laggards are lowest.")
+        st.write("MAG7 are highlighted if present.")
+
+        st.write("**Equal-weight summaries**")
+        st.latex(r"\text{EWAvg}_T=\frac{1}{M}\sum_{i=1}^{M}R_{i,T}")
+        st.latex(r"\text{Median}_T=\operatorname{median}\{R_{i,T}\}")
+        st.latex(r"\%\text{Up}_T=100\cdot \frac{1}{M}\sum_{i=1}^{M}\mathbf{1}[R_{i,T}>B]")
+        st.latex(r"\%\text{BeatIdx}_T=100\cdot \frac{1}{M}\sum_{i=1}^{M}\mathbf{1}[R_{i,T}>R_{\text{idx},T}]")
+        st.write("These give a breadth read relative to the index and to flat (B).")
+
+        st.write("**Dispersion (cross-section)**")
+        st.latex(r"\sigma_T=\operatorname{stdev}\{R_{i,T}\},\quad \text{IQR}_T=Q_{0.75}-Q_{0.25}")
+        st.write("High dispersion means large performance spread across names.")
+
+        st.write("**Concentration (top N share of gains)**")
+        st.latex(r"\text{TopNShare}_T=\frac{\sum_{i\in \text{Top}N}(R_{i,T}-B)}{\sum_{j=1}^{M}(R_{j,T}-B)}\times 100")
+        st.write("Large TopNShare implies leadership is concentrated.")
+
+        st.write("**Correlation to index (optional diagnostic)**")
+        st.latex(r"\rho_i=\operatorname{corr}\big(\Delta \ln P_{i,t},\, \Delta \ln P_{\text{idx},t}\big)")
+        st.write("Lower median correlation favors stock picking. High correlation means beta drives moves.")
+
+        st.write("**Practical reads**")
+        st.write("- Broad advance: many lines above the index and %BeatIdx high.")
+        st.write("- Concentration risk: TopNShare large while most lines trail the index.")
+        st.write("- Rotation/dispersion: high cross-section std and lower median correlation.")
+        st.write("- Leadership quality: leaders holding gains on a log scale with limited drawdowns.")
+
+    n_days = int(rebase_days)
+    base = float(rebase_base)
+
+    recent = clean_close.iloc[-n_days:].dropna(axis=1, how="any")
+    if recent.empty:
+        st.warning("Not enough overlapping history for the rebased comparison window.")
+    else:
+        first = recent.iloc[0]
+        mask = (first > 0) & np.isfinite(first)
+        rebased = (recent.loc[:, mask] / first[mask]) * base
+
+        perf = rebased.iloc[-1].dropna()
+        mag7_all = ["AAPL","MSFT","AMZN","META","GOOGL","NVDA","TSLA"]
+        mag7 = [t for t in mag7_all if t in rebased.columns]
+        non_mag = perf.drop(index=mag7, errors="ignore")
+        top5 = non_mag.nlargest(min(5, len(non_mag))).index.tolist()
+        worst5 = non_mag.nsmallest(min(5, len(non_mag))).index.tolist()
+
+        mag_colors = {
+            "AAPL":"#00bfff","MSFT":"#3cb44b","AMZN":"#ffe119",
+            "META":"#4363d8","GOOGL":"#f58231","NVDA":"#911eb4","TSLA":"#46f0f0"
+        }
+
+        spx = idx.reindex(rebased.index).dropna()
+        spx_rebased = spx / spx.iloc[0] * base
+
+        def hover_tmpl(name: str) -> str:
+            return "%{y:.2f}<br>%{x|%Y-%m-%d}<extra>" + name + "</extra>"
+
+        fig2 = go.Figure()
+        for t in rebased.columns:
+            fig2.add_trace(go.Scatter(
+                x=rebased.index, y=rebased[t], name=t, mode="lines",
+                line=dict(width=1, color="rgba(160,160,160,0.4)"),
+                hovertemplate=hover_tmpl(t), showlegend=False
+            ))
+        for t in mag7:
+            fig2.add_trace(go.Scatter(
+                x=rebased.index, y=rebased[t], name=t, mode="lines",
+                line=dict(width=2, color=mag_colors.get(t, "#ffffff")),
+                hovertemplate=hover_tmpl(t)
+            ))
+        for t in top5:
+            fig2.add_trace(go.Scatter(
+                x=rebased.index, y=rebased[t], name=f"Top {t}", mode="lines",
+                line=dict(width=2, color="lime"),
+                hovertemplate=hover_tmpl(t), showlegend=False
+            ))
+        for t in worst5:
+            fig2.add_trace(go.Scatter(
+                x=rebased.index, y=rebased[t], name=f"Worst {t}", mode="lines",
+                line=dict(width=2, color="red", dash="dash"),
+                hovertemplate=hover_tmpl(t), showlegend=False
+            ))
+        fig2.add_trace(go.Scatter(
+            x=spx_rebased.index, y=spx_rebased.values, name="S&P 500 (rebased)", mode="lines",
+            line=dict(width=3, color="white"), hovertemplate=hover_tmpl("S&P 500")
+        ))
+
+        vals = pd.concat([rebased.stack(), pd.Series(spx_rebased.values, index=spx_rebased.index)])
+        vals = vals.replace([np.inf, -np.inf], np.nan).dropna()
+        vals = vals[vals > 0]
+        y_range = None
+        if len(vals) > 10:
+            qlo, qhi = vals.quantile([0.01, 0.99])
+            y_min = max(1e-2, qlo / y_pad)
+            y_max = max(y_min * 1.1, qhi * y_pad)
+            y_range = [np.log10(y_min), np.log10(y_max)]
+
+        fig2.update_yaxes(type="log", range=y_range, title=f"Rebased Price (start = {int(base)})")
+        fig2.update_xaxes(title="Date")
+        fig2.update_layout(
+            template="plotly_dark",
+            height=700,
+            margin=dict(l=60, r=30, t=70, b=90),
+            title=f"Price Level Comparison (Rebased, Log Scale) — Last {n_days} Sessions",
+            legend=dict(orientation="h", y=-0.18, yanchor="top", x=0, xanchor="left"),
+            hovermode="closest",
+            font=dict(color="white")
+        )
+        st.plotly_chart(fig2, use_container_width=True)
+
+        with st.expander("Dynamic Interpretation", expanded=False):
+            buf2 = io.StringIO()
+
+            def _fmt_pct(x):
+                return "n/a" if pd.isna(x) else f"{x:.1f}%"
+
+            def _fmt_num(x):
+                return "n/a" if pd.isna(x) else f"{x:,.2f}"
+
+            if rebased.empty or spx_rebased.empty:
+                print("No data for interpretation.", file=buf2)
+            else:
+                as_of = rebased.index[-1].date()
+                perf_last = rebased.iloc[-1].dropna()
+                spx_last = float(spx_rebased.iloc[-1])
+                n_names = len(perf_last)
+                eq_avg = float(perf_last.mean())
+                eq_med = float(perf_last.median())
+                pct_pos = float((perf_last > base).mean() * 100)
+                pct_beat = float((perf_last > spx_last).mean() * 100)
+                disp_std = float(perf_last.std(ddof=0))
+                iqr_lo, iqr_hi = float(perf_last.quantile(0.25)), float(perf_last.quantile(0.75))
+                iqr_w = iqr_hi - iqr_lo
+
+                mag7_in = [t for t in mag7 if t in perf_last.index]
+                rest_idx = perf_last.index.difference(mag7_in)
+                mag7_mean = float(perf_last[mag7_in].mean()) if len(mag7_in) else np.nan
+                rest_mean = float(perf_last[rest_idx].mean()) if len(rest_idx) else np.nan
+                mag7_beat = float((perf_last[mag7_in] > spx_last).mean() * 100) if len(mag7_in) else np.nan
+
+                gains_all = float((perf_last - base).sum())
+                topN = 10
+                top_contrib = np.nan
+                if abs(gains_all) > 1e-9:
+                    top_contrib = float((perf_last.sort_values(ascending=False).head(topN) - base).sum() / gains_all * 100)
+
+                rets = rebased.pct_change().replace([np.inf, -np.inf], np.nan).dropna(how="all")
+                spx_r = pd.Series(spx_rebased, index=spx_rebased.index).pct_change()
+                corr_to_spx = rets.corrwith(spx_r, axis=0).dropna()
+                corr_med = float(corr_to_spx.median()) if len(corr_to_spx) else np.nan
+                low_corr_share = float((corr_to_spx < 0.3).mean() * 100) if len(corr_to_spx) else np.nan
+
+                spx_chg = spx_last - base
+                k = min(5, n_names)
+                leaders = perf_last.sort_values(ascending=False).head(k)
+                laggards = perf_last.sort_values(ascending=True).head(k)
+
+                print(f"=== Rebased performance read — {as_of} (window: {n_days} sessions) ===\n", file=buf2)
+                print("[Market]", file=buf2)
+                print(f"S&P 500 is {_fmt_pct(spx_chg)} over the window.", file=buf2)
+                print(f"Equal-weight average is {_fmt_pct(eq_avg - base)}, median is {_fmt_pct(eq_med - base)}.", file=buf2)
+                if np.isfinite(eq_avg) and np.isfinite(spx_last):
+                    gap = (eq_avg - spx_last)
+                    side = "above" if gap >= 0 else "below"
+                    print(f"Equal-weight sits {_fmt_pct(abs(gap))} {side} the index.", file=buf2)
+                print("", file=buf2)
+
+                print("[Breadth]", file=buf2)
+                print(f"{_fmt_pct(pct_pos)} of names are up. {_fmt_pct(pct_beat)} beat the index.", file=buf2)
+                print(f"Dispersion std is {_fmt_num(disp_std)} points on the rebased scale.", file=buf2)
+                print(f"IQR width is {_fmt_num(iqr_w)} points ({_fmt_num(iqr_lo)} to {_fmt_num(iqr_hi)}).", file=buf2)
+                if pct_pos >= 70 and pct_beat >= 55:
+                    print("Rally is broad. Leadership is shared across many names.", file=buf2)
+                elif pct_pos <= 35 and pct_beat <= 45:
+                    print("Rally is narrow or absent. Leadership is concentrated.", file=buf2)
+                else:
+                    print("Breadth is mixed. The tape can rotate quickly.", file=buf2)
+                print("", file=buf2)
+
+                print("[Concentration]", file=buf2)
+                if np.isfinite(top_contrib):
+                    print(f"Top {topN} names explain {_fmt_pct(top_contrib)} of equal-weight gains.", file=buf2)
+                if len(mag7_in):
+                    print(f"MAG7 equal-weight is {_fmt_pct(mag7_mean - base)}. Rest is {_fmt_pct(rest_mean - base)}.", file=buf2)
+                    if np.isfinite(mag7_beat):
+                        print(f"{_fmt_pct(mag7_beat)} of MAG7 beat the index.", file=buf2)
+                else:
+                    print("MAG7 tickers are not all present in this window.", file=buf2)
+                print("", file=buf2)
+
+                print("[Correlation]", file=buf2)
+                if len(corr_to_spx):
+                    print(f"Median correlation to the index is {_fmt_num(corr_med)}.", file=buf2)
+                    print(f"{_fmt_pct(low_corr_share)} of names show low correlation (<0.30).", file=buf2)
+                    if np.isfinite(corr_med) and corr_med < 0.5:
+                        print("Factor dispersion is high. Stock picking matters more.", file=buf2)
+                    elif np.isfinite(corr_med) and corr_med > 0.8:
+                        print("Common beta dominates. Moves are index-driven.", file=buf2)
+                    else:
+                        print("Correlation sits in a middle zone. Rotation can continue.", file=buf2)
+                else:
+                    print("Not enough data to compute correlations.", file=buf2)
+                print("", file=buf2)
+
+                print("[Leaders]", file=buf2)
+                for t, v in leaders.items():
+                    print(f"  {t}: {_fmt_pct(v - base)}", file=buf2)
+
+                print("\n[Laggards]", file=buf2)
+                for t, v in laggards.items():
+                    print(f"  {t}: {_fmt_pct(v - base)}", file=buf2)
+
+                print("\n[What to monitor]", file=buf2)
+                print("Watch the gap between equal-weight and index. A widening gap signals concentration risk.", file=buf2)
+                print("Track the share beating the index. Sustained readings above 55% support trend durability.", file=buf2)
+                print("Watch median correlation. Falling correlation favors dispersion and relative value setups.", file=buf2)
+
+            st.text(buf2.getvalue())
+
+    # ===================== SECTION 3 — Daily Return Heatmap =====================
+    st.header("Daily Return Heatmap")
+
+    with st.expander("Methodology", expanded=False):
+        st.write("Shows daily % returns for all names over the selected window. Highlights broad up/down days, dispersion, and leadership.")
+        st.write("Use it to spot synchronized moves, stress days, and rotation across the universe.")
+
+        st.write("**Daily return (per name)**")
+        st.latex(r"r_{i,t}=\frac{P_{i,t}}{P_{i,t-1}}-1")
+
+        st.write("**Heatmap values**")
+        st.write("Cells display r_{i,t}. Tickers are sorted by the most recent day’s return so leaders/laggards are obvious.")
+
+        st.write("**Robust color scale (cap extremes)**")
+        st.latex(r"c=\operatorname{P95}\left(\left|r_{i,t}\right|\right)\ \text{over the window}")
+        st.latex(r"\text{color range}=[-c,\,+c],\quad \text{midpoint}=0")
+        st.write("Capping avoids a few outliers overpowering the color scale.")
+
+        st.write("**Breadth and dispersion (how to read)**")
+        st.latex(r"\text{Up share}_t=100\cdot \frac{1}{N}\sum_{i=1}^{N}\mathbf{1}[r_{i,t}>0]")
+        st.latex(r"\sigma_{\text{cs},t}=\operatorname{stdev}\{r_{i,t}\}_{i=1}^{N}")
+        st.write("- High up share with low dispersion = uniform risk-on.")
+        st.write("- Mixed colors with high dispersion = rotation and factor spread.")
+        st.write("- Clusters of red/green by industry often flag sector moves.")
+
+        st.write("**Large-move counts (quick context)**")
+        st.latex(r"\text{BigUp}_t=\sum_{i}\mathbf{1}[r_{i,t}\ge \tau],\quad \text{BigDn}_t=\sum_{i}\mathbf{1}[r_{i,t}\le -\tau]")
+        st.latex(r"\tau=2\% \ \text{(default)}")
+        st.write("A jump in BigUp/BigDn signals a thrust or a shock day.")
+
+        st.write("**Short-horizon follow-through**")
+        st.latex(r"\bar{r}_{i,t}^{(w)}=\frac{1}{w}\sum_{k=0}^{w-1} r_{i,t-k},\quad w=5")
+        st.write("A broad rise in 5-day averages supports continuation; a fade warns of stall.")
+
+        st.write("**Practical reads**")
+        st.write("- Many greens, low dispersion: beta tailwind; index setups work.")
+        st.write("- Greens + high dispersion: stock picking/sector tilts matter.")
+        st.write("- Reds concentrated in a few groups: rotate risk, not necessarily de-risk.")
+        st.write("- Extreme red breadth with spikes in dispersion: watch liquidity and reduce gross.")
+
+
+    # Daily returns last N days
+    ret_daily = clean_close.pct_change().iloc[1:]
+    ret_window = int(heat_last_days)
+    ret_last = ret_daily.iloc[-ret_window:]
+    if ret_last.empty:
+        st.warning("Not enough data for the daily return heatmap.")
+    else:
+        order = ret_last.iloc[-1].sort_values(ascending=True).index
+        ret_last = ret_last[order]
+
+        abs_max = np.nanpercentile(np.abs(ret_last.values), 95)
+        z = ret_last.T.values
+        x = ret_last.index
+        y = list(order)
+
+        n_dates = len(x)
+        step = max(1, n_dates // 10)
+        xtick_vals = x[::step]
+        xtick_texts = [ts.strftime("%Y-%m-%d") for ts in xtick_vals]
+
+        fig_hm = go.Figure(go.Heatmap(
+            z=z, x=x, y=y,
+            colorscale="RdYlGn",
+            zmin=-abs_max, zmax=abs_max, zmid=0,
+            colorbar=dict(title="Daily Return", tickformat=".0%"),
+            hovertemplate="%{y}<br>%{x|%Y-%m-%d}<br>%{z:.2%}<extra></extra>"
+        ))
+
+        height = max(800, min(3200, 18 * len(y)))
+        fig_hm.update_layout(
+            template="plotly_dark",
+            title=f"Last {ret_window}-Day Daily Return Heatmap",
+            height=height,
+            margin=dict(l=100, r=40, t=60, b=60),
+            font=dict(color="white")
+        )
+        fig_hm.update_yaxes(title="Tickers (sorted by latest daily return)", tickfont=dict(size=8))
+        fig_hm.update_xaxes(title="Date", tickmode="array", tickvals=xtick_vals, ticktext=xtick_texts, tickangle=45)
+        st.plotly_chart(fig_hm, use_container_width=True)
+
+        with st.expander("Dynamic Interpretation", expanded=False):
+            buf3 = io.StringIO()
+
+            def _pct(x):
+                return "n/a" if pd.isna(x) else f"{x*100:.1f}%"
+
+            def _pp(x):
+                return "n/a" if pd.isna(x) else f"{x*100:.2f}%"
+
+            if ret_last.empty:
+                print("No data for interpretation.", file=buf3)
+            else:
+                as_of = ret_last.index[-1].date()
+                last = ret_last.iloc[-1]
+                N = last.shape[0]
+                up = int((last > 0).sum())
+                dn = int((last < 0).sum())
+                flat = int(N - up - dn)
+                mean = float(last.mean()); med = float(last.median())
+                std = float(last.std(ddof=0))
+                q25 = float(last.quantile(0.25)); q75 = float(last.quantile(0.75))
+                iqr = q75 - q25
+                thr = 0.02
+                big_up = int((last >=  thr).sum())
+                big_dn = int((last <= -thr).sum())
+                w = min(5, len(ret_last))
+                avg_w = ret_last.tail(w).mean()
+                pct_pos_w = float((avg_w > 0).mean())
+                cs_std = ret_last.std(axis=1, ddof=0)
+                today_std = float(cs_std.iloc[-1])
+                disp_pct  = float((cs_std <= today_std).mean())
+                k = min(10, N)
+                leaders  = last.sort_values(ascending=False).head(k)
+                laggards = last.sort_values(ascending=True ).head(k)
+
+                def _streak(s, max_look=20):
+                    v = s.tail(max_look).to_numpy(dtype=float)
+                    sign = np.sign(v); sign[np.isnan(sign)] = 0
+                    if len(sign) == 0 or sign[-1] == 0:
+                        return 0
+                    tgt = sign[-1]; cnt = 0
+                    for x in sign[::-1]:
+                        if x == tgt: cnt += 1
+                        else: break
+                    return int(cnt if tgt > 0 else -cnt)
+
+                streaks = {t: _streak(ret_last[t]) for t in set(leaders.index).union(laggards.index)}
+
+                print(f"=== Daily return heatmap read — {as_of} (last {len(ret_last)} sessions) ===", file=buf3)
+                print("\n[Today]", file=buf3)
+                print(f"Up: {up}/{N} ({_pct(up/N)}). Down: {dn}/{N} ({_pct(dn/N)}). Flat: {flat}.", file=buf3)
+                print(f"Mean: {_pp(mean)}. Median: {_pp(med)}. Std: {_pp(std)}. IQR: {_pp(iqr)}.", file=buf3)
+                print(f"Moves ≥ {int(thr*100)}%: +{big_up}. Moves ≤ -{int(thr*100)}%: {big_dn}.", file=buf3)
+
+                print("\n[Recent breadth]", file=buf3)
+                print(f"{_pct(pct_pos_w)} of names have a positive average over the last {w} sessions.", file=buf3)
+
+                print("\n[Dispersion]", file=buf3)
+                print(f"Cross-section std today: {_pp(today_std)} (window percentile ~{disp_pct*100:.0f}th).", file=buf3)
+
+                print("\n[Leaders today]", file=buf3)
+                for t, v in leaders.items():
+                    stv = streaks.get(t, 0)
+                    lab = ("flat" if stv == 0 else (f"{stv}d up" if stv > 0 else f"{-stv}d down"))
+                    print(f"  {t}: {_pp(v)} ({lab})", file=buf3)
+
+                print("\n[Laggards today]", file=buf3)
+                for t, v in laggards.items():
+                    stv = streaks.get(t, 0)
+                    lab = ("flat" if stv == 0 else (f"{stv}d up" if stv > 0 else f"{-stv}d down"))
+                    print(f"  {t}: {_pp(v)} ({lab})", file=buf3)
+
+                print("\n[What to monitor]", file=buf3)
+                print("Watch big-move counts and the 5-day positive share for follow-through.", file=buf3)
+                print("Track dispersion; elevated dispersion favors relative moves over index moves.", file=buf3)
+
+            st.text(buf3.getvalue())
+
+    # ===================== SECTION 4 — Percentile Momentum Heatmap =====================
+    st.header("Percentile Momentum Heatmap")
+
+    with st.expander("Methodology", expanded=False):
+        st.write("Ranks each stock’s medium-horizon return against the cross-section each day.")
+        st.write("Use it to spot broad momentum, rotation, and persistence.")
+
+        st.write("**n-day return (per name)**")
+        st.latex(r"r^{(n)}_{i,t}=\frac{P_{i,t}}{P_{i,t-n}}-1")
+
+        st.write("**Cross-sectional percentile (per day)**")
+        st.latex(r"p_{i,t}=\frac{\operatorname{rank}\!\left(r^{(n)}_{i,t}\right)}{N}")
+        st.write("0 means worst in the universe that day. 1 means best.")
+        st.write("The heatmap shows p_{i,t}. Rows are sorted by the latest percentile.")
+
+        st.write("**Breadth buckets (how to read)**")
+        st.latex(r"\text{Top\,20\%}_t=\frac{1}{N}\sum_{i}\mathbf{1}[p_{i,t}\ge 0.80]")
+        st.latex(r"\text{Bottom\,20\%}_t=\frac{1}{N}\sum_{i}\mathbf{1}[p_{i,t}\le 0.20]")
+        st.write("High Top-20% share signals broad upside momentum. High Bottom-20% share signals broad weakness.")
+
+        st.write("**Momentum shift vs a short lookback**")
+        st.latex(r"\Delta p_i=p_{i,T}-p_{i,T-w}")
+        st.write("Improving names: Δp_i > 0. Weakening names: Δp_i < 0.")
+
+        st.write("**Persistence (top/bottom quintile)**")
+        st.latex(r"\text{TopQ}_{i}=\sum_{k=0}^{w-1}\mathbf{1}[p_{i,T-k}\ge 0.80]")
+        st.latex(r"\text{BotQ}_{i}=\sum_{k=0}^{w-1}\mathbf{1}[p_{i,T-k}\le 0.20]")
+        st.write("Names with TopQ = w held leadership. BotQ = w stayed weak.")
+        
+        st.write("**Practical reads**")
+        st.write("- Rising median percentile and high Top-20% share: trend has breadth.")
+        st.write("- Mixed median with both tails active: rotation/dispersion regime.")
+        st.write("- Persistent top-quintile list: candidates for follow-through.")
+        st.write("- Persistent bottom-quintile list: candidates for mean-reversion checks.")
+
+
+    look_days = int(mom_look)
+    ret_n = clean_close.pct_change(look_days)
+    ret_n = ret_n.iloc[look_days:]
+    if ret_n.empty:
+        st.warning("Not enough data for the momentum heatmap.")
+    else:
+        perc = ret_n.rank(axis=1, pct=True)
+        order2 = perc.iloc[-1].sort_values(ascending=True).index
+        perc = perc[order2]
+
+        z = perc.T.values
+        x = perc.index
+        y = list(order2)
+
+        n_dates = len(x)
+        step = max(1, n_dates // 10)
+        xtick_vals  = x[::step]
+        xtick_texts = [ts.strftime("%Y-%m-%d") for ts in xtick_vals]
+
+        fig_pm = go.Figure(go.Heatmap(
+            z=z, x=x, y=y,
+            colorscale="Viridis",
+            zmin=0, zmax=1,
+            colorbar=dict(title="Return Percentile"),
+            hovertemplate="%{y}<br>%{x|%Y-%m-%d}<br>%{z:.0%}<extra></extra>"
+        ))
+
+        height = max(800, min(3200, 18 * len(y)))
+        fig_pm.update_layout(
+            template="plotly_dark",
+            title=f"{look_days}-Day Return Percentile Heatmap",
+            height=height,
+            margin=dict(l=110, r=40, t=60, b=60),
+            font=dict(color="white")
+        )
+        fig_pm.update_yaxes(title="Tickers (sorted by latest %ile)", tickfont=dict(size=8))
+        fig_pm.update_xaxes(title="Date", tickmode="array", tickvals=xtick_vals, ticktext=xtick_texts, tickangle=45)
+        st.plotly_chart(fig_pm, use_container_width=True)
+
+        with st.expander("Dynamic Interpretation", expanded=False):
+            buf4 = io.StringIO()
+            if perc.empty or ret_n.empty:
+                print("No data for interpretation.", file=buf4)
+            else:
+                as_of = perc.index[-1].date()
+                last_p = perc.iloc[-1].astype(float)
+                last_r = ret_n.iloc[-1].astype(float)
+
+                N = int(last_p.shape[0])
+                mean_p = float(last_p.mean()); med_p = float(last_p.median())
+                q25 = float(last_p.quantile(0.25)); q75 = float(last_p.quantile(0.75))
+                iqr_w = q75 - q25
+
+                top10 = float((last_p >= 0.90).mean() * 100)
+                top20 = float((last_p >= 0.80).mean() * 100)
+                mid40 = float(((last_p > 0.40) & (last_p < 0.60)).mean() * 100)
+                bot20 = float((last_p <= 0.20).mean() * 100)
+                bot10 = float((last_p <= 0.10).mean() * 100)
+
+                pct_up = float((last_r > 0).mean() * 100)
+
+                look = min(5, len(perc))
+                delta = (last_p - perc.iloc[-look].astype(float)).dropna()
+                improving = float((delta > 0).mean() * 100)
+                weakening = float((delta < 0).mean() * 100)
+                delta_med = float(delta.median())
+
+                k = min(10, N)
+                leaders  = last_p.sort_values(ascending=False).head(k)
+                laggards = last_p.sort_values(ascending=True ).head(k)
+
+                window_p = 5
+                top_quint = (perc.tail(window_p) >= 0.80).sum()
+                bot_quint = (perc.tail(window_p) <= 0.20).sum()
+                persistent_up = top_quint[top_quint == window_p].index.tolist()
+                persistent_dn = bot_quint[bot_quint == window_p].index.tolist()
+
+                print(f"=== {look_days}-day momentum read — {as_of} ===", file=buf4)
+                print("\n[Snapshot]", file=buf4)
+                print(f"Names: {N}. Up on window: {pct_up:.1f}%.", file=buf4)
+                print(f"Mean percentile: {mean_p:.2f}. Median: {med_p:.2f}.", file=buf4)
+                print(f"IQR: {q25:.2f}–{q75:.2f} (width {iqr_w:.2f}).", file=buf4)
+
+                print("\n[Breadth]", file=buf4)
+                print(f"Top 10%: {top10:.1f}%. Top 20%: {top20:.1f}%.", file=buf4)
+                print(f"Middle 40–60%: {mid40:.1f}%.", file=buf4)
+                print(f"Bottom 20%: {bot20:.1f}%. Bottom 10%: {bot10:.1f}%.", file=buf4)
+
+                print("\n[Shift]", file=buf4)
+                print(f"Improving vs {look} days ago: {improving:.1f}%. Weakening: {weakening:.1f}%.", file=buf4)
+                print(f"Median percentile change: {delta_med:+.2f}.", file=buf4)
+
+                print("\n[Leaders]", file=buf4)
+                for t, v in leaders.items():
+                    print(f"  {t}: {v:.2f}", file=buf4)
+
+                print("\n[Laggards]", file=buf4)
+                for t, v in laggards.items():
+                    print(f"  {t}: {v:.2f}", file=buf4)
+
+                print("\n[Persistence]", file=buf4)
+                if persistent_up:
+                    up_list = ", ".join(persistent_up[:15]) + ("…" if len(persistent_up) > 15 else "")
+                    print(f"Top-quintile {window_p} days: {up_list}", file=buf4)
+                else:
+                    print("No names stayed in the top quintile.", file=buf4)
+                if persistent_dn:
+                    dn_list = ", ".join(persistent_dn[:15]) + ("…" if len(persistent_dn) > 15 else "")
+                    print(f"Bottom-quintile {window_p} days: {dn_list}", file=buf4)
+                else:
+                    print("No names stayed in the bottom quintile.", file=buf4)
+
+                print("\n[Focus]", file=buf4)
+                print("Watch the top-quintile share. Rising share supports continuation.", file=buf4)
+                print("Track the median percentile. Sustained readings above 0.60 show broad momentum.", file=buf4)
+                print("Use persistence lists for follow-through and mean-reversion checks.", file=buf4)
+
+            st.text(buf4.getvalue())
+
 
-"""
-# Welcome to Streamlit!
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# Hide default Streamlit style
+st.markdown(
+    """
+    <style>
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    </style>
+    """,
+    unsafe_allow_html=True
+)