| """DeepQuant — deterministic rebalance engine (Phase 1: compute only, no execution). |
| |
| Reproduces the MarketFM Tactical target portfolio and diffs it against the live account in |
| DOLLARS, trading only the change. No order is placed here — compute_orders returns the list |
| the agent *would* submit. Execution (Phase 2) consumes this same output, guardrailed. |
| """ |
| import json |
| import os |
| import ssl |
| import urllib.request |
|
|
| import numpy as np |
| import pandas as pd |
| from huggingface_hub import hf_hub_download |
|
|
| try: |
| import certifi |
| _CTX = ssl.create_default_context(cafile=certifi.where()) |
| except Exception: |
| _CTX = ssl.create_default_context() |
|
|
| PANEL_REPO = os.environ.get("MARKETFM_REPO", "s-ttp/marketfm-panel") |
| AV = os.environ.get("ALPHAVANTAGE_API_KEY", "") |
| SEG_K, SECTOR_CAP, SIZE, MAX_W = 1000, 5, 50, 0.10 |
| DEF_EQ, DEF_AGG, DEF_GLD = 0.60, 0.20, 0.20 |
| ETF = {"AGG": ("iShares Core US Aggregate Bond ETF", "Bonds (ETF)"), |
| "GLD": ("SPDR Gold Shares", "Gold (ETF)")} |
|
|
|
|
| def cap_weights(w, mw=MAX_W): |
| w = np.asarray(w, float) |
| for _ in range(30): |
| over = w > mw + 1e-9 |
| if not over.any(): |
| break |
| excess = (w[over] - mw).sum() |
| w[over] = mw |
| under = ~over |
| if w[under].sum() <= 0: |
| break |
| w[under] += excess * w[under] / w[under].sum() |
| return w |
|
|
|
|
| DEFAULT_CFG = {"signal": ["n_roa"], "regime": "gate20", |
| "defense": "mom60_agg20_gld20", "cadence_weeks": 4, "construction": "n60_nocap", "version": 2} |
|
|
|
|
| CONSTRUCTIONS = { |
| "n60_nocap": {"rule": "abs", "hard": 0.10, "buffer": 0.0, "sector_cap": 999, "size": 60}, |
| "n50_nocap": {"rule": "abs", "hard": 0.10, "buffer": 0.0, "sector_cap": 999, "size": 50}, |
| "n75_nocap": {"rule": "abs", "hard": 0.10, "buffer": 0.0, "sector_cap": 999, "size": 75}, |
| "abs10_sec5": {"rule": "abs", "hard": 0.10, "buffer": 0.0, "sector_cap": 5, "size": 50}, |
| } |
|
|
|
|
| def cap_vec(w, caps): |
| w = np.asarray(w, float); caps = np.asarray(caps, float) |
| for _ in range(50): |
| over = w > caps + 1e-9 |
| if not over.any(): |
| break |
| ex = (w[over] - caps[over]).sum(); w[over] = caps[over] |
| under = ~over |
| room = w[under].sum() |
| if room <= 0: |
| break |
| w[under] += ex * w[under] / room |
| return w |
|
|
|
|
| def load_config(token): |
| """Live strategy config written by the autonomous recalibration agent (falls back to the incumbent).""" |
| try: |
| c = json.load(open(hf_hub_download(PANEL_REPO, "strategy_config.json", repo_type="dataset", token=token, force_download=True))) |
| return {**DEFAULT_CFG, **{k: c[k] for k in DEFAULT_CFG if k in c}} |
| except Exception: |
| return dict(DEFAULT_CFG) |
|
|
|
|
| def _spy_series(): |
| u = f"https://www.alphavantage.co/query?function=TIME_SERIES_WEEKLY_ADJUSTED&symbol=SPY&apikey={AV}" |
| ts = json.load(urllib.request.urlopen(u, timeout=25, context=_CTX))["Weekly Adjusted Time Series"] |
| return pd.Series({k: float(v["5. adjusted close"]) for k, v in ts.items()}).sort_index() |
|
|
|
|
| def _trail_dd(closes, n=52): |
| win = list(closes[-n:]) |
| if len(win) < 26: |
| return 0.0 |
| pk, m = win[0], 0.0 |
| for p in win: |
| pk = max(pk, p); m = max(m, 1 - p/pk) |
| return m |
|
|
|
|
| def detect_regime(rule="gate20"): |
| try: |
| s = _spy_series() |
| p = float(s.iloc[-1]); s10 = float(s.rolling(10).mean().iloc[-1]); s20 = float(s.rolling(20).mean().iloc[-1]) |
| s40 = float(s.rolling(40).mean().iloc[-1]); p_prev = float(s.iloc[-2]); s40_prev = float(s.rolling(40).mean().iloc[-2]) |
| if rule in ("gate20", "gate15"): |
| thr = 0.20 if rule == "gate20" else 0.15 |
| off = not ((s10 < s40) and (_trail_dd(list(s.values)) >= thr)) |
| elif rule == "single40": |
| off = p >= s40 |
| elif rule == "dual20/40": |
| off = True if (p >= s20 and p >= s40) else (False if (p < s20 and p < s40) else (s10 >= s40)) |
| elif rule == "hyst5": |
| off = True if p > 1.05 * s40 else (False if p < 0.95 * s40 else (s10 >= s40)) |
| elif rule == "confirm2": |
| cur, prev = p >= s40, p_prev >= s40_prev |
| off = cur if cur == prev else (s10 >= s40) |
| else: |
| off = s10 >= s40 |
| return {"offense": bool(off), "rule": rule, "sma10": s10, "sma40": s40, "spy": p} |
| except Exception as e: |
| return {"offense": True, "rule": rule, "sma10": None, "sma40": None, "spy": None, |
| "warn": f"SPY fetch failed ({type(e).__name__}); defaulting to OFFENSE"} |
|
|
|
|
| def _rank_sleeve(df, cols, sign=1, con=None): |
| con = con or CONSTRUCTIONS["abs10_sec5"] |
| df = df[df["marketcap"].notna() & (df["marketcap"] > 0)].copy() |
| df = df.sort_values("marketcap", ascending=False).head(SEG_K) |
| top500 = float(df["marketcap"].head(500).sum()) or 1.0 |
| df["score"] = sum(sign * df[c].fillna(0) for c in cols) |
| df = df.sort_values("score", ascending=False) |
| picked, sec = [], {} |
| for _, r in df.iterrows(): |
| if sec.get(r["sector"], 0) >= con["sector_cap"]: |
| continue |
| sec[r["sector"]] = sec.get(r["sector"], 0) + 1 |
| picked.append(r) |
| if len(picked) >= con.get("size", SIZE): |
| break |
| mc = np.array([r["marketcap"] for r in picked], float) |
| if con["rule"] == "rel": |
| caps = np.maximum(np.minimum(con["hard"], mc / top500 + con["buffer"]), 0.02) |
| else: |
| caps = np.full(len(picked), con["hard"]) |
| w = cap_vec(mc / mc.sum(), caps) |
| return [{"ticker": r["ticker"], "name": r.get("name"), "sector": r["sector"], "weight": float(wi)} |
| for r, wi in zip(picked, w)] |
|
|
|
|
| def equity_sleeve(token, cols=None): |
| cols = cols or DEFAULT_CFG["signal"] |
| p = hf_hub_download(PANEL_REPO, "marketfm_snapshot.parquet", repo_type="dataset", token=token) |
| return _rank_sleeve(pd.read_parquet(p), cols) |
|
|
|
|
| def get_target(token): |
| cfg = load_config(token) |
| reg = detect_regime(cfg["regime"]) |
| snap = pd.read_parquet(hf_hub_download(PANEL_REPO, "marketfm_snapshot.parquet", repo_type="dataset", token=token)) |
| con = CONSTRUCTIONS.get(cfg.get("construction", "abs10_sec5"), CONSTRUCTIONS["abs10_sec5"]) |
| sleeve = _rank_sleeve(snap, cfg["signal"], con=con) |
| if reg["offense"]: |
| rows = [dict(x) for x in sleeve] |
| else: |
| d = cfg["defense"] |
| if d == "agg50_gld50": |
| rows = [] |
| eq_frac, agg_w, gld_w = 0.0, 0.5, 0.5 |
| elif d == "lowvol": |
| rows = _rank_sleeve(snap, ["n_vol_13w"], sign=-1, con=con) |
| eq_frac, agg_w, gld_w = 1.0, 0.0, 0.0 |
| elif d == "mom40_agg30_gld30": |
| rows = [dict(x, weight=0.4 * x["weight"]) for x in sleeve]; eq_frac, agg_w, gld_w = 0.4, 0.3, 0.3 |
| else: |
| rows = [dict(x, weight=DEF_EQ * x["weight"]) for x in sleeve]; eq_frac, agg_w, gld_w = DEF_EQ, DEF_AGG, DEF_GLD |
| for sym, wv in [("AGG", agg_w), ("GLD", gld_w)]: |
| if wv > 0: |
| nm, sct = ETF[sym] |
| rows.append({"ticker": sym, "name": nm, "sector": sct, "weight": wv}) |
| weights = {r["ticker"]: r["weight"] for r in rows} |
| return {"regime": reg, "weights": weights, "rows": rows, "config": cfg} |
|
|
|
|
| def compute_orders(weights, positions, equity, band_pct=0.005, invest_frac=0.995, force_sells=False): |
| """positions: {symbol: market_value $}. Returns order list (sells first), trading only the delta. |
| invest_frac keeps a ~0.5% cash buffer so sell-proceeds slippage can't push cash negative (no margin). |
| force_sells (set when cash < 0): sell deltas bypass the band so a thin ~5% overshoot spread across |
| 50 names can actually be trimmed back — otherwise every per-name trim is under the band.""" |
| band = band_pct * equity |
| investable = equity * invest_frac |
| orders = [] |
| for sym in set(weights) | set(positions): |
| tw = weights.get(sym, 0.0) |
| tgt = tw * investable |
| cur = positions.get(sym, 0.0) |
| delta = tgt - cur |
| cw = (cur / equity) if equity else 0.0 |
| if tw == 0 and cur > 0: |
| orders.append({"symbol": sym, "side": "SELL", "delta": -cur, "cur_w": cw, "tgt_w": 0.0, "exit": True}) |
| elif cur == 0 and tgt > 1.0: |
| orders.append({"symbol": sym, "side": "BUY", "delta": tgt, "cur_w": 0.0, "tgt_w": tw, "exit": False}) |
| elif force_sells and delta < -1.0: |
| orders.append({"symbol": sym, "side": "SELL", "delta": delta, "cur_w": cw, "tgt_w": tw, "exit": False}) |
| elif abs(delta) < band: |
| continue |
| else: |
| orders.append({"symbol": sym, "side": "BUY" if delta > 0 else "SELL", |
| "delta": delta, "cur_w": cw, "tgt_w": tw, "exit": False}) |
| orders.sort(key=lambda o: (0 if o["side"] == "SELL" else 1, -abs(o["delta"]))) |
| return orders |
|
|
