| """Scanner CLI — the automated daily/loop run. |
| |
| Usage: |
| python -m options_scanner.scan # auto universe, free data |
| python -m options_scanner.scan --symbols SPY,QQQ # explicit watchlist |
| python -m options_scanner.scan --provider tradier # force real-time provider |
| python -m options_scanner.scan --output results.json --csv results.csv |
| |
| TRADIER_API_KEY / POLYGON_API_KEY in the environment switch to real-time data |
| automatically. |
| """ |
| import argparse |
| import csv |
| import json |
| import sys |
| import time |
| from datetime import datetime, timezone |
|
|
| from .config import RiskParams |
| from .universe import auto_universe |
| from .data import get_provider |
| from .strategies import ALL_BUILDERS |
| from .risk import passes_liquidity, passes_defined_risk, risk_report, score |
| from .chain_model import Chain |
|
|
|
|
| def fetch_chain(provider, symbol, max_expiries, retries=2): |
| last_err = None |
| for _ in range(retries + 1): |
| try: |
| return provider.get_chain(symbol, max_expiries=max_expiries) |
| except Exception as e: |
| last_err = e |
| time.sleep(1.0) |
| raise last_err |
|
|
|
|
| def earnings_gate_ok(chain, candidate, params): |
| if not params.avoid_earnings or not chain.next_earnings: |
| return True, "" |
| earn = chain.next_earnings |
| exps = {l.expiry for l, _ in candidate.legs} |
| for e in exps: |
| if earn <= e: |
| return False, f"earnings {earn} inside trade window (expiry {e})" |
| return True, "" |
|
|
|
|
| def scan_symbol(provider, symbol, params, max_expiries=5): |
| chain = fetch_chain(provider, symbol, max_expiries) |
| if not chain.quotes or chain.spot <= 0: |
| return symbol, [], f"empty chain" |
| horizon = chain.expirations(min_dte=params.min_dte, max_dte=params.max_dte)[0] |
| candidates = [] |
| for builder in ALL_BUILDERS: |
| for cand in builder(chain, params): |
| |
| cand.risk_metrics(chain, min(l.expiry for l, _ in cand.legs)) |
| ok, why = passes_liquidity(cand, params.min_oi, params.max_rel_spread) |
| if not ok: |
| cand.reasons.append(f"rejected: {why}") |
| continue |
| ok, why = passes_defined_risk(cand, params.allow_undefined_risk) |
| if not ok: |
| cand.reasons.append(f"rejected: {why}") |
| continue |
| if cand.max_loss * 100.0 > params.account_size * params.max_buying_power_pct / 100.0: |
| cand.reasons.append( |
| f"rejected: BPE ${cand.max_loss * 100:.0f} > " |
| f"{params.max_buying_power_pct:.0f}% of ${params.account_size:,.0f}") |
| continue |
| ok, why = earnings_gate_ok(chain, cand, params) |
| if not ok: |
| cand.reasons.append(f"rejected: {why}") |
| continue |
| if cand.net_credit < 0 and cand.max_profit <= 0: |
| continue |
| score(cand) |
| candidates.append(cand) |
| |
| candidates.sort(key=lambda c: c.score, reverse=True) |
| for c in candidates: |
| c.reasons.append(f"chain liquidity {chain.liquidity_score(min(l.expiry for l, _ in c.legs)):.0f}/100, " |
| f"ATM IV {chain.iv30:.0%}, spot {chain.spot:g}, earnings {chain.next_earnings or 'n/a'}") |
| return symbol, candidates[:params.max_candidates_per_symbol], "" |
|
|
|
|
| def to_row(symbol, c): |
| notes = c.notes |
| if "Backspread" in c.name: |
| notes += " | max profit unbounded above; reported value is at the +60% grid boundary" |
| return { |
| "symbol": symbol, "strategy": c.name, "view": c.view, |
| "net_credit_debit": round(c.net_credit, 2), "credit_debit_usd": round(c.net_credit * 100, 2), |
| "max_profit_usd": round(c.max_profit * 100, 2), "max_loss_usd": round(c.max_loss * 100, 2), |
| "pop_pct": round(c.pop * 100, 1), "score": c.score, |
| "breakevens": ",".join(str(b) for b in c.breakevens), |
| "legs": " ; ".join(l.label() for l, _ in c.legs), |
| "notes": notes, "reasons": " | ".join(c.reasons), |
| } |
|
|
|
|
| def main(argv=None): |
| ap = argparse.ArgumentParser(prog="options-scanner") |
| ap.add_argument("--symbols", default="", help="comma-separated watchlist; empty = auto") |
| ap.add_argument("--provider", default=None, choices=["alpaca", "tradier", "polygon", "yfinance"]) |
| ap.add_argument("--auto-top", type=int, default=10, help="universe size when auto-picking") |
| ap.add_argument("--max-expiries", type=int, default=5) |
| ap.add_argument("--account-size", type=float, default=25000.0) |
| ap.add_argument("--risk-pct", type=float, default=5.0) |
| ap.add_argument("--output", default="results.json") |
| ap.add_argument("--csv", default="") |
| ap.add_argument("--allow-undefined-risk", action="store_true", |
| help="admit naked straddles/strangles (NOT recommended)") |
| args = ap.parse_args(argv) |
|
|
| params = RiskParams(account_size=args.account_size, max_buying_power_pct=args.risk_pct, |
| allow_undefined_risk=args.allow_undefined_risk) |
| provider = get_provider(args.provider) |
| print(f"[scan] provider={provider.name} account=${params.account_size:,.0f} " |
| f"max risk/trade={params.max_buying_power_pct:.0f}%", flush=True) |
|
|
| if args.symbols: |
| universe = [s.strip().upper() for s in args.symbols.split(",") if s.strip()] |
| else: |
| universe = auto_universe() |
|
|
| results, errors = [], [] |
| started = time.time() |
| for sym in universe: |
| try: |
| sym, cands, err = scan_symbol(provider, sym, params, args.max_expiries) |
| if err: |
| errors.append({"symbol": sym, "error": err}) |
| print(f"[scan] {sym}: {err}", flush=True) |
| elif cands: |
| print(f"[scan] {sym}: {len(cands)} candidates " |
| f"(best {cands[0].name} score {cands[0].score})", flush=True) |
| for c in cands: |
| results.append(to_row(sym, c)) |
| except Exception as e: |
| errors.append({"symbol": sym, "error": str(e)[:200]}) |
| print(f"[scan] {sym}: ERROR {e}", flush=True) |
| time.sleep(0.4) |
|
|
| results.sort(key=lambda r: r["score"], reverse=True) |
| payload = { |
| "generated_at": datetime.now(timezone.utc).isoformat(), |
| "provider": provider.name, |
| "universe_size": len(universe), |
| "scanned": len(universe) - len(errors), |
| "params": { |
| "account_size": params.account_size, |
| "max_buying_power_pct": params.max_buying_power_pct, |
| "credit_short_delta": params.credit_short_delta, |
| "condor_short_delta": params.condor_short_delta, |
| "min_oi": params.min_oi, "max_rel_spread": params.max_rel_spread, |
| "allow_undefined_risk": params.allow_undefined_risk, |
| "avoid_earnings": params.avoid_earnings, |
| }, |
| "top_candidates": results, |
| "errors": errors, |
| "runtime_seconds": round(time.time() - started, 1), |
| } |
| with open(args.output, "w") as f: |
| json.dump(payload, f, indent=1) |
| print(f"[scan] wrote {args.output}: {len(results)} candidates, " |
| f"{len(errors)} errors, {payload['runtime_seconds']}s", flush=True) |
| if args.csv: |
| if results: |
| with open(args.csv, "w", newline="") as f: |
| w = csv.DictWriter(f, fieldnames=list(results[0].keys())) |
| w.writeheader() |
| w.writerows(results) |
| print(f"[scan] wrote {args.csv}", flush=True) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
