Update src/streamlit_app.py

src/streamlit_app.py

@@ -6,6 +6,7 @@ import yfinance as yf
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
+from numpy.lib.stride_tricks import sliding_window_view
 from sklearn.ensemble import GradientBoostingClassifier
 
 st.set_page_config(page_title="Market Dashboard", page_icon="📊", layout="wide")
@@ -305,14 +306,348 @@ def render_peak_detector():
     )
 
 
+# =========================================================
+# TAB 3: SNIPER SCANNER (historical analog / triple-positive setup scanner)
+# =========================================================
+
+def sniper_rsi(series, period=14):
+    delta = series.diff()
+    gain = (delta.where(delta > 0, 0)).ewm(alpha=1 / period, adjust=False).mean()
+    loss = (-delta.where(delta < 0, 0)).ewm(alpha=1 / period, adjust=False).mean()
+    rs = gain / (loss + 1e-9)
+    return 100 - (100 / (1 + rs))
+
+
+def get_strict_stats(df, rsi, sma, current_stretch, rsi_threshold, strict_window,
+                      forward_1d=1, forward_5d=5, forward_3m=63):
+    close = df["Close"].values
+    stretches = ((close - sma.values) / sma.values) * 100
+
+    ret_1d = (pd.Series(close).shift(-forward_1d).values - close) / close
+    ret_5d = (pd.Series(close).shift(-forward_5d).values - close) / close
+    ret_3m = (pd.Series(close).shift(-forward_3m).values - close) / close
+
+    mask_stretch_lower = stretches >= current_stretch - strict_window
+    mask_stretch_upper = stretches <= current_stretch + strict_window
+    mask_rsi_threshold = (rsi < rsi_threshold).values
+
+    mask = mask_stretch_lower & mask_stretch_upper & mask_rsi_threshold
+    valid_mask = mask & (~np.isnan(ret_3m))
+    match_indices = np.where(valid_mask)[0]
+
+    if len(match_indices) < 10:
+        return None
+
+    return {
+        "count": len(match_indices),
+        "avg_1d": np.mean(ret_1d[valid_mask]) * 100,
+        "avg_5d": np.mean(ret_5d[valid_mask]) * 100,
+        "avg_3m": np.mean(ret_3m[valid_mask]) * 100,
+        "win_3m": (ret_3m[valid_mask] > 0).mean() * 100,
+        "match_dates": df.index[match_indices],
+        "match_prices": close[match_indices],
+    }
+
+
+def analyze_ticker(df, rsi_threshold, stretch_threshold, strict_window, lookback, win_rate_min=80):
+    df = df.dropna()
+    if len(df) < 200:
+        return None
+
+    close = df["Close"].astype(float)
+    rsi = sniper_rsi(close)
+    sma20 = close.rolling(20).mean()
+
+    current_stretch = ((close.iloc[-1] - sma20.iloc[-1]) / sma20.iloc[-1]) * 100
+
+    result = {
+        "rsi": rsi.iloc[-1],
+        "stretch": current_stretch,
+        "stats": None,
+        "fractal_target": None,
+        "df": df,
+        "rsi_series": rsi,
+        "signal_met": False,
+    }
+
+    try:
+        hist = np.squeeze(close.values[:-90])
+        if hist.ndim == 1 and len(hist) > lookback:
+            curr = close.values[-lookback:]
+            curr_n = (curr - np.mean(curr)) / (np.std(curr) + 1e-9)
+            wins = sliding_window_view(hist, lookback)
+            wins_n = (wins - np.mean(wins, axis=1, keepdims=True)) / (np.std(wins, axis=1, keepdims=True) + 1e-9)
+            corrs = np.dot(wins_n, curr_n) / lookback
+            top_idx = np.argmax(corrs)
+            result["fractal_target"] = close.values[-1] * (
+                close.values[top_idx + lookback] / close.values[top_idx + lookback - 1]
+            )
+    except Exception:
+        pass
+
+    if result["rsi"] < rsi_threshold and current_stretch < stretch_threshold:
+        stats = get_strict_stats(df, rsi, sma20, current_stretch, rsi_threshold, strict_window)
+        result["stats"] = stats
+        if stats:
+            is_triple_positive = stats["avg_1d"] > 0 and stats["avg_5d"] > 0 and stats["avg_3m"] > 0
+            result["signal_met"] = is_triple_positive and stats["win_3m"] >= win_rate_min
+
+    return result
+
+
+def get_sniper_ticker_data(ticker: str) -> pd.DataFrame:
+    df = yf.download(ticker, period="max", interval="1d", progress=False)
+    if df.empty:
+        return df
+    if isinstance(df.columns, pd.MultiIndex):
+        df.columns = df.columns.get_level_values(0)
+    return df.dropna()
+
+
+@st.cache_data(ttl=24 * 3600, show_spinner="Fetching ticker universe...")
+def get_universe_tickers(include_russell: bool, extra_tickers: tuple):
+    tickers = set()
+    try:
+        sp500 = pd.read_csv(
+            "https://raw.githubusercontent.com/datasets/s-and-p-500-companies/master/data/constituents.csv"
+        )["Symbol"].tolist()
+        tickers.update(t.replace(".", "-") for t in sp500)
+    except Exception as e:
+        st.warning(f"Could not fetch S&P 500 list: {e}")
+
+    if include_russell:
+        try:
+            russell = pd.read_csv(
+                "https://raw.githubusercontent.com/ikoniaris/Russell2000/master/russell_2000_components.csv"
+            )["Ticker"].tolist()
+            tickers.update(t.replace(".", "-") for t in russell)
+        except Exception as e:
+            st.warning(f"Could not fetch Russell 2000 list: {e}")
+
+    tickers.update(extra_tickers)
+    return sorted(tickers)
+
+
+@st.cache_data(ttl=12 * 3600, show_spinner=False)
+def run_full_scan(universe_label, extra_tickers_tuple, rsi_threshold, stretch_threshold,
+                   strict_window, lookback, win_rate_min, _tickers):
+    results = []
+    batch_size = 150
+    total_batches = max(1, (len(_tickers) + batch_size - 1) // batch_size)
+    progress = st.progress(0, text="Starting scan...")
+
+    for b, i in enumerate(range(0, len(_tickers), batch_size)):
+        batch = _tickers[i:i + batch_size]
+        try:
+            data = yf.download(batch, period="max", interval="1d", group_by="ticker", progress=False, threads=True)
+        except Exception:
+            progress.progress((b + 1) / total_batches, text=f"Batch {b + 1}/{total_batches} failed, continuing...")
+            continue
+
+        for ticker in batch:
+            try:
+                try:
+                    raw = data[ticker]
+                except Exception:
+                    raw = data
+                df = raw.dropna()
+                if len(df) < 200:
+                    continue
+                result = analyze_ticker(df, rsi_threshold, stretch_threshold, strict_window, lookback, win_rate_min)
+                if result and result["signal_met"]:
+                    stats = result["stats"]
+                    results.append({
+                        "Ticker": ticker,
+                        "RSI": round(result["rsi"], 1),
+                        "Stretch %": round(result["stretch"], 2),
+                        "Matches": stats["count"],
+                        "Avg 1D %": round(stats["avg_1d"], 2),
+                        "Avg 5D %": round(stats["avg_5d"], 2),
+                        "Avg 3M %": round(stats["avg_3m"], 2),
+                        "3M Win Rate %": round(stats["win_3m"], 1),
+                    })
+            except Exception:
+                continue
+
+        progress.progress((b + 1) / total_batches, text=f"Scanned batch {b + 1}/{total_batches}...")
+
+    progress.empty()
+    return pd.DataFrame(results)
+
+
+def render_sniper_dashboard(ticker, result):
+    df = result["df"]
+    rsi_series = result["rsi_series"]
+    stats = result["stats"]
+    target = result["fractal_target"]
+
+    fig = plt.figure(figsize=(12, 8))
+    gs = fig.add_gridspec(2, 2)
+
+    ax1 = fig.add_subplot(gs[0, :])
+    ax1.plot(df.index, df["Close"], color="gray", alpha=0.3, label="History")
+    recent = df.tail(120)
+    ax1.plot(recent.index, recent["Close"], color="black", linewidth=1.5, label="Current Trend")
+
+    if stats:
+        ax1.scatter(stats["match_dates"], stats["match_prices"], color="limegreen", s=20, zorder=5,
+                     label="Strict Matches")
+    if target is not None:
+        ax1.axhline(target, color="blue", ls="--", alpha=0.6, label="Single best-match analog (not a target)")
+
+    ax1.set_title(f"{ticker}", fontsize=16, fontweight="bold")
+    ax1.legend(loc="upper left", fontsize=9)
+    ax1.grid(True, alpha=0.1)
+
+    if stats:
+        stats_text = (
+            f"Historical Matches: {stats['count']}\n"
+            f"Avg Change 1D:  {stats['avg_1d']:+.2f}%\n"
+            f"Avg Change 5D:  {stats['avg_5d']:+.2f}%\n"
+            f"Avg Change 3M:  {stats['avg_3m']:+.2f}%\n"
+            f"3M Win Rate: {stats['win_3m']:.1f}% (n={stats['count']})"
+        )
+        ax1.text(0.98, 0.05, stats_text, transform=ax1.transAxes, va="bottom", ha="right",
+                  bbox=dict(boxstyle="round", facecolor="white", alpha=0.9, edgecolor="darkgreen"),
+                  fontsize=10, family="monospace")
+
+    ax2 = fig.add_subplot(gs[1, 0])
+    ax2.plot(recent.index, rsi_series.tail(120), color="purple")
+    ax2.axhline(result["rsi"], color="orange", ls=":")
+    ax2.set_title(f"RSI: {result['rsi']:.1f}")
+
+    ax3 = fig.add_subplot(gs[1, 1])
+    if stats:
+        horizons = ["1D", "5D", "3M"]
+        values = [stats["avg_1d"], stats["avg_5d"], stats["avg_3m"]]
+        ax3.bar(horizons, values, color="limegreen", alpha=0.8)
+        ax3.axhline(0, color="black", linewidth=0.8)
+        ax3.set_title("Historical Edge by Horizon")
+    else:
+        ax3.set_title("No matches to show")
+
+    plt.tight_layout()
+    st.pyplot(fig)
+    plt.close(fig)
+
+
+def render_sniper_tab():
+    st.title("🎯 Sniper Scanner")
+    st.caption(
+        "Looks for 'triple-positive' historical analog setups: today's RSI/SMA-stretch combination "
+        "compared against similar conditions earlier in a ticker's own price history, scored by average "
+        "forward returns and win rate."
+    )
+    st.warning(
+        "⚠️ Two things worth keeping in mind:\n\n"
+        "1. **Small samples** — many qualifying setups have only 10-30 historical matches. An '80% win rate' "
+        "on 10 matches (8 wins) has a much wider true range than the headline number suggests — treat it as "
+        "a lean, not a precise probability.\n\n"
+        "2. **Full-universe scans test thousands of tickers at once.** With that many independent tests, some "
+        "will clear an 80%+ historical win-rate bar by chance alone, with no real edge behind it. A hit showing "
+        "up in a scan is a reason to look closer, not a standalone signal.\n\n"
+        "The dashed blue line ('best-match analog') is one single closest-matching historical window, shown "
+        "for context — not a statistical price target."
+    )
+
+    with st.sidebar:
+        st.markdown("---")
+        st.header("Sniper Scanner Settings")
+        rsi_threshold = st.slider("RSI threshold (oversold below this)", 20, 60, 45, 1, key="sn_rsi")
+        stretch_threshold = st.slider("Max SMA20 stretch %", -8.0, 0.0, -2.0, 0.5, key="sn_stretch")
+        strict_window = st.slider("Match strictness (± stretch %)", 0.1, 2.0, 0.5, 0.1, key="sn_window")
+        lookback = st.slider("Fractal lookback (days)", 20, 120, 60, 5, key="sn_lookback")
+        win_rate_min = st.slider("Min 3M win rate to flag (%)", 50, 95, 80, 5, key="sn_winrate")
+        extra_input = st.text_input("Extra tickers for full scan (comma-separated)", value="GC=F,BTC-USD",
+                                     key="sn_extra")
+        include_russell = st.checkbox("Include Russell 2000 in full scan (~2,000 more tickers, much slower)",
+                                       value=False, key="sn_russell")
+
+    extra_tickers = tuple(t.strip().upper() for t in extra_input.split(",") if t.strip())
+
+    st.subheader("Analyze a single ticker")
+    single_ticker = st.text_input("Ticker", value="BTC-USD", key="sn_single").strip().upper()
+    if st.button("Analyze", key="sn_analyze_btn") and single_ticker:
+        raw = get_sniper_ticker_data(single_ticker)
+        if raw.empty:
+            st.error(f"No data for '{single_ticker}'.")
+        else:
+            result = analyze_ticker(raw, rsi_threshold, stretch_threshold, strict_window, lookback, win_rate_min)
+            if result is None:
+                st.error("Not enough history for this ticker.")
+            else:
+                entry_met = result["rsi"] < rsi_threshold and result["stretch"] < stretch_threshold
+                if not entry_met:
+                    st.info(
+                        f"RSI {result['rsi']:.1f} / Stretch {result['stretch']:.2f}% — entry conditions "
+                        f"(RSI < {rsi_threshold}, stretch < {stretch_threshold}%) not currently met. "
+                        "Showing current state for reference."
+                    )
+                elif result["stats"] is None:
+                    st.info(
+                        f"Entry conditions met (RSI {result['rsi']:.1f}, stretch {result['stretch']:.2f}%) "
+                        "but fewer than 10 historical analogs found — not enough data to score."
+                    )
+                elif result["signal_met"]:
+                    st.success(
+                        f"✅ Full signal met — {result['stats']['win_3m']:.1f}% historical 3M win rate "
+                        f"over {result['stats']['count']} matches."
+                    )
+                else:
+                    st.info(
+                        f"Entry conditions met but didn't clear the win-rate/triple-positive bar "
+                        f"({result['stats']['win_3m']:.1f}% win rate over {result['stats']['count']} matches)."
+                    )
+                render_sniper_dashboard(single_ticker, result)
+
+    st.markdown("---")
+    st.subheader("Full universe scan")
+    universe_label = "sp500_russell2000" if include_russell else "sp500"
+    st.caption(
+        f"Will scan the {'S&P 500 + Russell 2000' if include_russell else 'S&P 500'} plus your extra tickers "
+        f"for setups meeting the full criteria. First run can take several minutes — results are cached for "
+        f"12 hours after that. Start with Russell 2000 unchecked to see how long a run takes on this host "
+        f"before opting into the larger universe."
+    )
+    if st.button("🔍 Run Full Universe Scan", key="sn_scan_btn"):
+        tickers = get_universe_tickers(include_russell, extra_tickers)
+        st.write(f"Scanning {len(tickers)} tickers...")
+        results_df = run_full_scan(
+            universe_label, extra_tickers, rsi_threshold, stretch_threshold,
+            strict_window, lookback, win_rate_min, tickers,
+        )
+        st.session_state["sn_results"] = results_df
+
+    if "sn_results" in st.session_state:
+        results_df = st.session_state["sn_results"]
+        if results_df.empty:
+            st.info("No tickers met the full signal criteria with current settings.")
+        else:
+            st.success(f"{len(results_df)} ticker(s) met the criteria.")
+            sorted_df = results_df.sort_values("3M Win Rate %", ascending=False).reset_index(drop=True)
+            st.dataframe(sorted_df, use_container_width=True, hide_index=True)
+
+            pick = st.selectbox("View chart for:", sorted_df["Ticker"].tolist(), key="sn_pick")
+            if pick:
+                raw = get_sniper_ticker_data(pick)
+                if not raw.empty:
+                    result = analyze_ticker(raw, rsi_threshold, stretch_threshold, strict_window, lookback,
+                                             win_rate_min)
+                    if result:
+                        render_sniper_dashboard(pick, result)
+
+
 # =========================================================
 # MAIN LAYOUT
 # =========================================================
 
-tab1, tab2 = st.tabs(["🐋 Whale Monitor", "📉 Peak Detector"])
+tab1, tab2, tab3 = st.tabs(["🐋 Whale Monitor", "📉 Peak Detector", "🎯 Sniper Scanner"])
 
 with tab1:
     render_whale_monitor()
 
 with tab2:
-    render_peak_detector()
+    render_peak_detector()
+
+with tab3:
+    render_sniper_tab()