Spaces:
Running
Running
| """Slipstream — AI event-risk overlay (second-stage exclusion on the deterministic book). | |
| The 20 holdings are chosen by the systematic quant rule. This overlay then scans the candidate | |
| names for RECENT, CONCRETE, MATERIALLY-ADVERSE EVENTS the price/fundamentals may not have caught | |
| yet — legal, regulatory/FDA, geopolitical/trade, operational, competitive — and HARD-EXCLUDES any | |
| with a CRITICAL event only (since Oct 2026; "high" events are shown as watch flags and held). It is deliberately NOT a subjective "risk score": it only fires on a | |
| discrete event backed by a real headline, so ongoing/priced risks (general competition, valuation) | |
| can never trip it. Excluded names are replaced deterministically by the next-ranked candidate. | |
| Disciplined by design: capped exclusions, every exclusion cites a headline, cached once per UTC day, | |
| and it degrades to NO exclusions if news or the LLM is unavailable (the fund must always trade). | |
| """ | |
| from __future__ import annotations | |
| import json | |
| import os | |
| import re | |
| from datetime import datetime, timezone | |
| import config | |
| MAX_EXCLUSIONS = int(os.getenv("SLIPSTREAM_MAX_EXCLUSIONS", "3")) | |
| ENABLED = os.getenv("SLIPSTREAM_RISK_SCREEN", "1") == "1" | |
| CACHE = config.DATA_DIR / "risk_screen_cache.json" | |
| _SEV_RANK = {"none": 0, "medium": 1, "high": 2, "critical": 3} | |
| # Only events at or above this severity are excluded. "critical" = very high risk only: the backtested | |
| # rule has no overlay, so the live fund should deviate from it only for events that threaten the company. | |
| EXCLUDE_AT = os.getenv("SLIPSTREAM_EXCLUDE_SEVERITY", "critical").lower() | |
| # Deterministic backstop for the prompt's "analyst actions are never events" rule — the model | |
| # still returned `NFLX / medium / "Analyst target price cut and downgrade…"` (2026-09), citing a | |
| # Wells Fargo note. A flag whose triggering headline is analyst commentary is dropped unless the | |
| # same text also names a hard event. | |
| _ANALYST = re.compile( | |
| r"\b(analyst|downgrad\w*|upgrad\w*|price target|target price|rating|slash\w* (its )?target|" | |
| r"cuts? (its )?target|initiat\w* coverage|overweight|underweight|outperform|underperform)\b", re.I) | |
| _HARD_EVENT = re.compile( | |
| r"\b(FDA|SEC|DOJ|FTC|EU|indict\w*|verdict|injunction|consent decree|recall|sanction\w*|entity list|" | |
| r"export (ban|control)|tariff|bankrupt\w*|going.concern|restat\w*|resign\w*|steps? down|breach|" | |
| r"withdr\w* guidance|clinical hold|complete response|delist\w*|nationali[sz]\w*)\b", re.I) | |
| _PROMPT = """You are a risk officer screening a concentrated equity portfolio. For EACH ticker below, | |
| review its recent news headlines and decide whether a DISCRETE, RECENT, MATERIALLY-ADVERSE EVENT has | |
| occurred — something the market may not have fully priced. Only these event types count: | |
| • legal: SEC/DOJ action, indictment, adverse verdict/settlement, major patent loss | |
| • regulatory/FDA: complete response letter, clinical hold, adcom rejection, recall, license loss | |
| • geopolitical/trade: sanctions, entity-list addition, export ban, nationalization, tariff naming the company | |
| • operational: guidance withdrawal, going-concern, bankruptcy, major customer/contract loss, cyber-breach, | |
| accounting restatement, abrupt CEO/CFO exit | |
| • competitive: a SPECIFIC rival action (approval/launch) that directly displaces this company's product | |
| Do NOT flag ongoing or already-known risks (general competition, high valuation, cyclicality, macro, | |
| "analysts are cautious"). Analyst actions of ANY kind — rating changes, downgrades, price-target cuts, | |
| "worrying trends" commentary — are NEVER events: severity "none", even if the concern sounds | |
| operational. If there is no concrete adverse event in the headlines, severity is "none". | |
| Severity: none | medium | high | critical. Use high/critical only for events that plausibly impair | |
| value materially. | |
| MATERIALITY MUST BE JUDGED RELATIVE TO COMPANY SIZE (use your knowledge of each company's | |
| approximate market capitalization): | |
| • "high" requires plausible exposure of roughly >5% of the company's market value, OR a threat to | |
| the core business model / license to operate. | |
| • A civil lawsuit or regulatory complaint at the FILING stage against a large company, where the | |
| claimed amount is under ~2% of its market value, is at most "medium" (monitor, do not exclude) — | |
| a $20B claim is existential for a $30B company but a rounding error for a $2T one, and mega-cap | |
| antitrust filings historically resolve over years without impairing 12-month returns. | |
| • Adverse VERDICTS, injunctions, consent decrees, criminal indictments, or forced structural | |
| changes CAN be "high" regardless of company size. | |
| • "critical" is reserved for VERY HIGH risk — an event that threatens the company's survival or a large | |
| part of its value: bankruptcy / going-concern warning, fraud or accounting restatement, criminal | |
| indictment of the company or its CEO/CFO, loss of the license to operate (e.g. a key drug's approval | |
| withdrawn, delisting), sanctions/export bans cutting off a major share of revenue, or plausible | |
| exposure above ~20% of market value. When in doubt between "high" and "critical", choose "high". | |
| • If headlines show the stock already fell only modestly (under ~5%) on the news, the market has | |
| likely priced it — lean "medium" unless the event meets the tests above. | |
| Return ONLY a JSON object mapping each ticker to: | |
| {{"severity": "...", "category": "...", "event": "<one factual line>", "headline": "<the triggering headline, verbatim>"}} | |
| HEADLINES: | |
| {blocks}""" | |
| def _load_cache(): | |
| try: | |
| return json.loads(CACHE.read_text()) | |
| except Exception: | |
| return {} | |
| def _classify(pool: list[str], news_by_tkr: dict) -> dict: | |
| """One batched Gemini call → {ticker: {severity, category, event, headline}}.""" | |
| from services.llm import _call_gemini | |
| blocks = [] | |
| for t in pool: | |
| hls = news_by_tkr.get(t, []) | |
| if not hls: | |
| continue | |
| lines = "\n".join(f" - {h['headline']}" for h in hls[:8]) | |
| blocks.append(f"{t}:\n{lines}") | |
| if not blocks: | |
| return {} | |
| raw = _call_gemini(_PROMPT.format(blocks="\n\n".join(blocks))) | |
| m = raw[raw.find("{"): raw.rfind("}") + 1] | |
| data = json.loads(m) | |
| out = {} | |
| for t, v in data.items(): | |
| if isinstance(v, dict) and str(v.get("severity", "none")).lower() != "none": | |
| text = f"{v.get('headline', '')} {v.get('event', '')}" | |
| if _ANALYST.search(text) and not _HARD_EVENT.search(text): | |
| continue # analyst commentary ≠ event | |
| out[t.upper()] = {"severity": str(v.get("severity", "none")).lower(), | |
| "category": str(v.get("category", ""))[:40], | |
| "event": str(v.get("event", ""))[:200], | |
| "headline": str(v.get("headline", ""))[:200]} | |
| return out | |
| def screen(pool: list[str]) -> dict: | |
| """Return {excluded: set, meta: {...}} for a candidate pool. Cached per UTC day; safe on failure.""" | |
| today = datetime.now(timezone.utc).strftime("%Y-%m-%d") | |
| pool = [t for t in pool if t] | |
| key = today + "|" + EXCLUDE_AT + "|" + ",".join(sorted(pool)) | |
| if not (ENABLED and config.GEMINI_API_KEY): | |
| return {"excluded": set(), "meta": {"enabled": False, "scanned": 0, "cleared": 0, "excluded": [], "as_of": today}} | |
| cache = _load_cache() | |
| if cache.get("key") == key: | |
| c = cache["meta"] | |
| return {"excluded": set(x["ticker"] for x in c["excluded"]), "meta": c} | |
| excluded_list, flags = [], {} | |
| try: | |
| import alpaca_client as alpaca | |
| news_by_tkr = alpaca.news(pool) | |
| flags = _classify(pool, news_by_tkr) | |
| ranked = sorted(flags.items(), key=lambda kv: -_SEV_RANK.get(kv[1]["severity"], 0)) | |
| for t, f in ranked: | |
| if _SEV_RANK.get(f["severity"], 0) >= _SEV_RANK.get(EXCLUDE_AT, 3) and len(excluded_list) < MAX_EXCLUSIONS: | |
| excluded_list.append({"ticker": t, **f}) | |
| except Exception as e: | |
| # any failure (no news, LLM error, bad JSON) → no exclusions, fund still trades | |
| meta = {"enabled": True, "scanned": len(pool), "cleared": len(pool), "excluded": [], | |
| "as_of": today, "note": f"screen unavailable ({type(e).__name__}) — no exclusions applied"} | |
| return {"excluded": set(), "meta": meta} | |
| meta = {"enabled": True, "scanned": len(pool), "cleared": len(pool) - len(excluded_list), | |
| "excluded": excluded_list, "exclude_at": EXCLUDE_AT, | |
| "flags_medium": [{"ticker": t, **f} for t, f in sorted(flags.items(), key=lambda kv: -_SEV_RANK.get(kv[1]["severity"], 0)) | |
| if 0 < _SEV_RANK.get(f["severity"], 0) < _SEV_RANK.get(EXCLUDE_AT, 3)][:5], | |
| "as_of": today} | |
| try: | |
| CACHE.write_text(json.dumps({"key": key, "meta": meta})) | |
| except Exception: | |
| pass | |
| return {"excluded": set(x["ticker"] for x in excluded_list), "meta": meta} | |