Spaces:
Running
Running
| """Slipstream — target-book computation (runs on the HF Space). | |
| Portable (pandas/numpy only): reads the shipped bundle in data/ and reproduces the | |
| Slipstream rule — regime overlay + dynamic sector cap — so momentum and sector strength are | |
| computed on the Space at rebalance time. The regime test additionally extends SPY with live | |
| Alpaca closes, so the single biggest switch the fund makes never lags the bundle. | |
| """ | |
| from __future__ import annotations | |
| import json | |
| import threading | |
| import time | |
| from pathlib import Path | |
| import numpy as np | |
| import pandas as pd | |
| DATA = Path(__file__).resolve().parent / "data" | |
| TOPN, NAME_CAP, MOM_N = 20, 5, 50 | |
| CAP_BASE, CAP_LO, CAP_HI = 0.30, 0.15, 0.45 | |
| MAX_POS_W = 0.10 # max weight in any ONE position (v2, Oct 2026: Study 7 — same Sharpe as 15%, top-5 48% vs 56%) | |
| MIN_POS_W = 0.01 # min weight in any one position (see _name_floor) | |
| _CACHE_TTL_S = 15 * 60 | |
| def _load(): | |
| cand = pd.read_parquet(DATA / "candidates.parquet") | |
| px = pd.read_parquet(DATA / "prices.parquet") | |
| meta = json.loads((DATA / "meta.json").read_text()) | |
| wide = px.pivot_table(index="date", columns="ticker", values="px", aggfunc="last").sort_index() | |
| wide.index = pd.to_datetime(wide.index) | |
| return cand, wide, meta | |
| def _dyn_caps(wide, sectors, universe): | |
| """30% ± each sector's trailing 12m-1m relative strength vs SPY, clipped [15,45]%.""" | |
| if "SPY" not in wide or len(wide) < 260: | |
| return {} | |
| secs = sorted(set(sectors.get(t, "?") for t in universe) - {"?"}) | |
| sret = {s: wide[[t for t in universe if sectors.get(t) == s and t in wide.columns]] | |
| .pct_change(fill_method=None).mean(axis=1) for s in secs} | |
| sidx = (1 + pd.DataFrame(sret).fillna(0)).cumprod() | |
| spyidx = (1 + wide["SPY"].pct_change(fill_method=None).fillna(0)).cumprod() | |
| rs = (sidx.iloc[-21] / sidx.iloc[-252] - 1) - (spyidx.iloc[-21] / spyidx.iloc[-252] - 1) | |
| return {s: float(np.clip(CAP_BASE + rs.get(s, 0.0), CAP_LO, CAP_HI)) for s in secs} | |
| def _apply_sector_cap(w, sectors, caps): | |
| sec = pd.Series({t: sectors.get(t, "?") for t in w.index}) | |
| held = list(sec.unique()) | |
| cv = {s: caps.get(s, CAP_BASE) for s in held} | |
| if sum(cv.values()) < 1.0: | |
| f = 1 / sum(cv.values()); cv = {s: min(1.0, c * f) for s, c in cv.items()} | |
| w = w.copy() | |
| for _ in range(30): | |
| sw = w.groupby(sec).sum() | |
| over = {s: sw[s] for s in sw.index if sw[s] > cv.get(s, 1.0) + 1e-9} | |
| if not over: | |
| break | |
| under = ~sec.isin(list(over)); ex = 0.0 | |
| for s, val in over.items(): | |
| nm = sec[sec == s].index; ex += w[nm].sum() - cv[s]; w[nm] *= cv[s] / val | |
| if w[under].sum() <= 0: | |
| break | |
| w[under] += ex * w[under] / w[under].sum() | |
| return w / w.sum() | |
| def _spy_live(wide): | |
| """The bundle's SPY closes, extended with live Alpaca daily bars past the bundle's last | |
| date. Returns (series, through_date_str | None). The rest of the book (momentum, sector | |
| RS) keeps using bundle prices: their 12-1m windows are insensitive to a couple of weeks of | |
| lag, and extending 970 tickers live is not worth the quota. No-op on any failure.""" | |
| spx = wide["SPY"].dropna() if "SPY" in wide else pd.Series(dtype=float) | |
| if spx.empty: | |
| return spx, None | |
| try: | |
| import alpaca_client as alpaca | |
| last = spx.index.max() | |
| bars = alpaca.spy_series((last + pd.Timedelta(days=1)).strftime("%Y-%m-%d")) | |
| live = {} | |
| for b in bars: | |
| d = pd.to_datetime(b["t"], utc=True).tz_convert("America/New_York").normalize().tz_localize(None) | |
| if d > last: | |
| live[d] = float(b["c"]) | |
| if not live: | |
| return spx, None | |
| ext = pd.Series(live).sort_index() | |
| return pd.concat([spx, ext]), str(ext.index.max().date()) | |
| except Exception: | |
| return spx, None | |
| def _regime_on(spx: pd.Series): | |
| """SPY at/above its 200-day MA now AND ~1 month ago (confirmation) → risk-on.""" | |
| if spx is None or len(spx) < 221: | |
| return True | |
| spx = spx.ffill() | |
| now = spx.iloc[-1] >= spx.iloc[-200:].mean() | |
| prev = spx.iloc[-22] >= spx.iloc[-221:-21].mean() | |
| return bool(now and prev) | |
| def _pick_tickers(cand, sectors, n, excluded=frozenset()): | |
| """Top-n tickers by combined score (≤NAME_CAP/sector), skipping any excluded name — so an | |
| excluded holding is deterministically replaced by the next-ranked candidate.""" | |
| picks, sec_ct = [], {} | |
| for _, r in cand.sort_values("score", ascending=False).iterrows(): | |
| t = r["ticker"] | |
| if t in excluded: | |
| continue | |
| s = sectors.get(t, "?") | |
| if sec_ct.get(s, 0) >= NAME_CAP: | |
| continue | |
| sec_ct[s] = sec_ct.get(s, 0) + 1 | |
| picks.append(t) | |
| if len(picks) >= n: | |
| break | |
| return picks | |
| def _name_cap(w, cap=MAX_POS_W): | |
| """Clip any single position to `cap`, redistributing the excess pro-rata. | |
| Raw 13F-dollar weighting concentrates the book into a handful of mega-caps (the | |
| live book ran ~78% in its top 5, an effective breadth of ~6 names for a nominal | |
| 20-stock portfolio, with the tail rounding to sub-$100 positions). A per-name cap | |
| keeps the dollar-conviction tilt — which the backtest shows is genuinely | |
| informative, equal-weight is materially WORSE — while removing the extreme. | |
| See Quant Model/scripts/weighting_study.py: over 2014-2026 (top-20, monthly, | |
| 40bps) every cap from 8-30% beat the uncapped book on Sharpe, a smooth plateau | |
| rather than a single lucky point; 15% gave the best drawdown-adjusted return | |
| (Calmar 0.475 vs 0.387 uncapped, maxDD -35.0% vs -39.5%). Rule v2 (Oct 2026) uses 10%: | |
| on the concentrated-manager + ROA book it kept Sharpe (0.98 vs 0.98, 2016-26) while | |
| cutting the top-5 weight from 56% to 48% (data/research/slipstream/quality, Study 7).""" | |
| for _ in range(50): | |
| over = w > cap + 1e-12 | |
| if not over.any(): | |
| break | |
| excess = float((w[over] - cap).sum()) | |
| w[over] = cap | |
| under = ~over | |
| if w[under].sum() <= 0: | |
| break | |
| w[under] += excess * w[under] / w[under].sum() | |
| return w / w.sum() | |
| def _name_floor(w, floor=MIN_POS_W): | |
| """Raise any position below `floor` to it, funding the lift pro-rata from the weight the | |
| other names carry ABOVE the floor. | |
| The cap above only truncates the top of the dollar-weighted book. The 13F `size` column | |
| spans ~140× (ONON $0.5B → GOOGL $74B), so the tail still rounded to nothing: the live | |
| 2026-09 target had BSX at 0.03%, PODD 0.01%, DINO 0.07% — $14–$71 on a $98k account, | |
| below the executor's $493 min-trade deadband, so those names were never bought and the | |
| "20-stock" fund permanently held 16. A 1% floor ($~1k) is the smallest weight that | |
| clears the deadband with margin at $100k. Not part of weighting_study.py (which only | |
| tested caps); it moves ~3-5% of the book from the top names to the tail.""" | |
| for _ in range(50): | |
| under = w < floor - 1e-12 | |
| if not under.any(): | |
| break | |
| need = float((floor - w[under]).sum()) | |
| w[under] = floor | |
| pool = (w[~under] - floor).clip(lower=0) | |
| if pool.sum() <= 0: | |
| break | |
| w[~under] -= need * pool / pool.sum() | |
| return w / w.sum() | |
| def _base_book(cand, wide, sectors, universe, excluded=frozenset()): | |
| """Top-20 by combined score (≤5/sector, minus excluded), $-weighted with a per-name | |
| cap AND floor, then dynamic sector cap.""" | |
| picks = _pick_tickers(cand, sectors, TOPN, excluded) | |
| sel = cand[cand["ticker"].isin(picks)].drop_duplicates("ticker").set_index("ticker").loc[picks] | |
| w = sel["size"].clip(lower=0).astype(float) | |
| if w.sum() <= 0: | |
| w = pd.Series(1.0, index=picks) | |
| # The constraints interact: the sector cap redistributes weight pro-rata and can push a | |
| # name back above MAX_POS_W or below MIN_POS_W. Alternate them until all hold (converges | |
| # in a few passes; the final sector pass is the binding one). | |
| caps = _dyn_caps(wide, sectors, universe) | |
| w = w / w.sum() | |
| for _ in range(20): | |
| w = _apply_sector_cap(_name_floor(_name_cap(w)), sectors, caps) | |
| if w.max() <= MAX_POS_W + 1e-6 and w.min() >= MIN_POS_W - 1e-6: | |
| break | |
| return w | |
| def _momentum_book(wide, universe, sectors): | |
| """Risk-off sleeve: top-50 large-cap by 12m-1m return, equal-weight.""" | |
| if len(wide) < 253: | |
| return pd.Series(dtype=float) | |
| u = [t for t in universe if t in wide.columns] | |
| mom = (wide[u].iloc[-21] / wide[u].iloc[-252] - 1).dropna() | |
| pick = mom.nlargest(MOM_N).index | |
| return pd.Series(1.0 / len(pick), index=pick) | |
| def _compute_book(screen: bool = True) -> dict: | |
| cand, wide, meta = _load() | |
| sectors = meta.get("sectors", {}) | |
| universe = meta.get("universe", []) | |
| spx, spy_through = _spy_live(wide) | |
| on = _regime_on(spx) | |
| screen_meta = {"enabled": False, "scanned": 0, "cleared": 0, "excluded": [], "as_of": None} | |
| if on: | |
| # AI event-risk overlay: screen the candidate pool (final 20 + substitutes) for concrete | |
| # adverse events and hard-exclude high/critical; excluded names are replaced by the | |
| # next-ranked candidate inside _base_book. Degrades to no exclusions on any failure. | |
| excluded = set() | |
| if screen: | |
| try: | |
| import risk_screen | |
| pool = _pick_tickers(cand, sectors, TOPN + 6) | |
| scr = risk_screen.screen(pool) | |
| excluded, screen_meta = scr["excluded"], scr["meta"] | |
| except Exception: | |
| pass | |
| w = _base_book(cand, wide, sectors, universe, excluded=excluded) | |
| book = "base" | |
| else: | |
| w = _momentum_book(wide, universe, sectors) # broad 50-name rotation — event screen n/a | |
| book = "momentum" | |
| holdings = [{"ticker": t, "weight": round(float(x), 5), "sector": sectors.get(t, "?")} | |
| for t, x in w.sort_values(ascending=False).items()] | |
| prices_through = str(wide.index.max().date()) | |
| return { | |
| "fund": "Slipstream", | |
| "signals_as_of": meta.get("as_of"), | |
| "prices_through": prices_through, | |
| "spy_through": spy_through or prices_through, | |
| "regime": "risk-on · smart-money book" if on else "risk-off · momentum rotation", | |
| "book": book, | |
| "n_holdings": len(holdings), | |
| "holdings": holdings, | |
| "risk_screen": screen_meta, | |
| "rule": "concentrated-manager 13F consensus · top-1000 · quality(ROA top-30% in sector) · top-20 $-wt " | |
| "(1–10%/name) · dynamic sector cap 15–45% · AI critical-event exclusion · regime→momentum (SPY live) · monthly", | |
| } | |
| _cache_lock = threading.Lock() | |
| _cache: dict = {} | |
| def compute_book(screen: bool = True, max_age_s: float = _CACHE_TTL_S) -> dict: | |
| """Target book, memoised for 15 minutes. Every dashboard load and dry-run preview calls | |
| this on a public Space (a 2 MB parquet pivot + Alpaca + the daily-cached risk screen), and | |
| the inputs only change on deploy or the daily screen — pass max_age_s=0 for the real | |
| rebalance so it always trades the freshest book.""" | |
| with _cache_lock: | |
| hit = _cache.get(screen) | |
| if hit and max_age_s > 0 and time.time() - hit[0] < max_age_s: | |
| return hit[1] | |
| result = _compute_book(screen) | |
| with _cache_lock: | |
| _cache[screen] = (time.time(), result) | |
| return result | |
| if __name__ == "__main__": | |
| print(json.dumps(compute_book(), indent=1)) | |