The user wants a backtest script for NQ futures involving: 1. Open interest gamma levels (likely referring to gamma exposure levels like GEX flip point, call walls, put walls — key levels from options market maker hedging) 2. Focus on the first two hours of trading (likely 9:30-11:30 AM ET) 3. Fading those levels (trading against them — price rejecting at these levels) 4. Stop loss of 50 ticks (NQ tick = 0.25 points = $5 per tick, so 50 ticks = 12.5 points = $250 risk per contract) "Open interest gamma levels" — this refers to gamma exposure (GEX) levels computed from options open interest. Key levels include: - Call Wall (strike with highest call gamma/OI) - Put Wall (strike with highest put gamma/OI) - Gamma Flip / Zero Gamma level (where dealers shift from short gamma to long gamma) - HVL (High Volume Level) - These are commonly computed by services like SpotGamma, and free versions exist (e.g., gammalevels, sesstrikes) The backtest would: 1. Compute or ingest gamma levels daily (from options chain open interest data) 2. During the first two hours (9:30-11:30 ET), detect when price touches/approaches these levels 3. Enter a fade trade: if price rallies into a call wall from below → short; if price drops into a put wall from above → long 4. 50 tick stop loss (12.50 NQ points) 5. Track PnL, win rate, profit factor, drawdown, etc. I should write a complete Python backtest. Let me think about the architecture: **Data requirements:** - NQ futures intraday data (1-minute bars ideally) — I can generate synthetic data or show how to load real data - Options open interest data for NQ options (or use ES/SPX proxy). NQ options are on the CME (NQ options) — getting real OI data is hard for free. I could: - Show how to pull from a provider (like Polygon, Tradier, CME) - Compute gamma levels from an OI chain snapshot - Provide a fallback with hardcoded/example gamma levels **Gamma level computation:** GEX per strike = Σ (OI × gamma × 100 × contract multiplier × spot² × 0.01) × (call +1, put -1 or ± depending on convention) Standard approach (SpotGamma style): - Gamma exposure at strike K = gamma(K) × OI(K) × 100 × spot² (dollar gamma) with sign +1 for calls, -1 for puts (assuming dealers long calls short puts, or the opposite — conventions vary) - Call Wall = strike with max total call gamma - Put Wall = strike with max total put gamma - Gamma Flip = strike where cumulative net gamma flips sign **Strategy logic:** - Session window: 09:30–11:30 ET - For each day: - Compute levels from previous day's OI (or same morning) - Track price in the window - Entry: when price first touches a level (within a small tolerance, e.g., a few ticks) - Direction: fade — at Call Wall, go short (expect resistance); at Put Wall, go long (expect support); at Gamma Flip could go either way (some fade through it, some treat as magnet — for fade logic, fade rejection) - Stop: 50 ticks (12.5 pts) adverse move - Exit options: stop loss, opposite level, end of window (11:30) flat, or take profit (could add configurable TP like 2x risk or target next level) **Outputs / charts:** Multiple charts requested: 1. Equity curve 2. Daily PnL distribution (histogram) 3. Win rate / stats table 4. Trade scatter (entry time of day vs PnL) 5. Price chart with levels and trade markers for sample days 6. Cumulative gamma profile chart per day (gamma by strike) 7. Drawdown chart 8. MFE/MAE analysis maybe Let me write a comprehensive script: ```python """ NQ Futures Gamma Level Fade Backtest ===================================== - Fades Open-Interest-based gamma levels (Call Wall, Put Wall, Gamma Flip) during the first two hours of the regular session (09:30-11:30 ET) - Stop loss: 50 ticks (12.50 NQ points = $250/contract) """ ``` I'll structure it: 1. **Config** — symbol, tick size, stop ticks, session times, tolerance 2. **Gamma level computation** from an options chain (OI, strikes, gamma per strike). I'll include a function that computes Black-Scholes gamma for each strike if gamma isn't supplied, then aggregates into call/put gamma by strike, finds walls and flip. 3. **Data layer** — abstract loader with (a) real data hooks (e.g., CSV/parquet from Databento/Polygon/CME), (b) synthetic data generator so the script runs out of the box for demonstration. 4. **Backtest engine** — event loop over 1-min bars, per-day logic, first-touch fade entries, stop monitoring, exit at window end. 5. **Metrics** — net PnL, win rate, PF, expectancy, Sharpe, max DD, avg win/loss, ticks stats. 6. **Multi-chart plotting** — matplotlib subplots: equity curve, drawdown, daily PnL, histogram, time-of-day PnL, per-level performance, gamma profile example, sample day chart with trades. I should be careful: futures data isn't free, so a synthetic demo path is essential. But I must clearly label synthetic results as illustrative — I shouldn't let them think it's real performance. Let me also include the Black-Scholes gamma function: gamma = e^(-qT) * φ(d1) / (S σ √T) For futures options (Black model), q = r effectively (Black-76): gamma is same form with forward. GEX per strike (dollar gamma per 1% move), common convention: - Call GEX = Σ_call OI × gamma × 100 (multiplier) × F² × 0.01 - Net GEX = call GEX - put GEX (dealer long calls/short puts assumption varies) - Total gamma per strike = call gamma + put gamma (unsigned) for walls - Gamma flip: strike where cumulative net GEX crosses zero I'll implement both: walls by absolute gamma, flip by cumulative net. Entry rules detail: - Call Wall fade: price trades up to within `entry_tolerance` ticks of Call Wall (or touches it) → SHORT - Put Wall fade: price trades down to within tolerance of Put Wall → LONG - Gamma Flip: often a magnet in positive gamma; fade logic: if price approaches from below and stalls... For simplicity, treat flip as a fade level only if we want, make configurable, default maybe fade extremes only. Actually, common practice: put wall = support (fade short down-move → buy), call wall = resistance (fade up-move → sell). Gamma flip is often the "vol trigger." I'll include it as optional level with its own fade direction based on sign of net gamma: in positive gamma regime levels hold (fade), in negative gamma levels get run through (breakout). But to keep the fade theme, I'll fade walls always, and flip optionally. Position sizing: 1 contract per trade (fixed), stop 50 ticks. Add optional TP at 50/100/150 ticks or at opposite wall; also test holding till window end. I'll make TP configurable including None. Only one trade per level per day (first touch), max trades per day configurable. Levels computed from prior day's close OI snapshot. Trade management on 1-min bars: use bar high/low to check stop; assume fill at level price when bar crosses it (entry when bar range reaches within tolerance). Conservative: if both entry and stop in same bar, count as stop. Let me also produce per-level-type breakdown stats (call wall shorts vs put wall longs). Now the multi-chart figure. I'll do a big figure with ~8 panels: 1. Equity curve (ticks and $) 2. Underwater/drawdown 3. Daily PnL bars 4. Histogram of trade PnL (ticks) 5. PnL by hour of entry (or by minutes since open) 6. Win rate / cumulative stats per level type (bar) 7. Sample day: price path + levels + entries/exits 8. Gamma profile (net GEX by strike) for a sample day 9. Maybe MAE/MFE scatter 10. Rolling win rate Matplotlib with GridSpec. Also print a stats table. Let me write the code carefully. Key parts: ```python import numpy as np import pandas as pd import matplotlib.pyplot as plt from dataclasses import dataclass, field from math import log, sqrt, exp, pi from scipy.stats import norm # I could avoid scipy and implement erf-based normal pdf/cdf to reduce deps ``` To reduce dependencies, implement norm pdf manually: φ(x) = exp(-x²/2)/√(2π). Gamma doesn't need CDF. Good — no scipy needed. Black-76 gamma for futures options: d1 = (ln(F/K) + 0.5σ²T) / (σ√T) gamma = φ(d1) e^{-rT} / (F σ √T) Approximately ignore r or include it. Gamma exposure in $ per 1% move: GEX$ = gamma × OI × contract_mult × F² × 0.01 For NQ options, contract multiplier is 20 (NQ = 20 × index... actually CME NQ options multiplier is $20 per point? Let me recall: NQ futures multiplier is $20 per index point. Options on NQ futures also $20). But since we only need relative ranking for walls and zero-crossing for flip, multiplier cancels — but for the chart y-axis it matters. I'll parametrize. Data loading: I'll write `load_futures_data(path)` expecting CSV with columns: datetime (ET), open, high, low, close, volume, with 1-min bars; and `load_oi_chain(path)` with date, strike, cp, open_interest, (optional gamma, iv). Then a synthetic generator to demo. Synthetic generator: - Daily NQ-like price around 20000 with intraday trend + noise - Random level assignments consistent with price: pick call wall above open range, put wall below - Regime days: positive gamma (mean-reverting, walls hold) vs negative (trend, walls break) — so results show mixture; this demonstrates the machinery, not real edge. Must state clearly. Engine specifics: For each day: - levels = dict(call_wall, put_wall, gamma_flip) in price terms (strike prices — but futures price vs strike index: NQ options strikes are on the index; futures trade near index. Assume strikes ≈ futures prices.) - window bars = 09:30–11:30 inclusive entry; force exit at 11:30 close. - Track touched flags per level. - For each bar in window: - if not in position: - check call wall touch: if bar.high >= call_wall - tol and previous approach from below (bar.high >= level - tol). Simplest: if bar.high >= call_wall - tol_price and bar.close < call_wall (still below → fade short) → short at entry price = min(bar.high, ...)? Fill assumption: when price first trades at (level - tol), we sell there. Let's define trigger = level - tol_price for call wall (fade just before touch) or level exactly. I'll use `entry_buffer_ticks` (e.g., 5 ticks before the level) so fills are realistic. - similarly put wall: bar.low <= put_wall + tol and bar.close > put_wall → long at trigger. - if in position: - check stop: short stop if bar.high >= entry + 50 ticks → exit at stop price (assume limit/stop filled at stop, no slippage param optional). - if same bar as entry and stop could trigger, we check with the bar after entry; for same-bar ambiguity, assume worst case (stop hit) — conservative. - take profit optional: e.g., 100 ticks. - time exit at window end. - Record trades: date, level_type, direction, entry_time, entry_price, exit_time, exit_price, pnl_ticks, pnl_$, mfe, mae. MFE/MAE tracked with running extremes. Stats: - n trades, win rate, avg win/loss (ticks), expectancy, profit factor, max consecutive losses, total $, max DD (ticks and $ on closed equity), Sharpe (daily), per-level breakdown, per-hour breakdown. Charts (multi-chart figure ~ 3x3): 1. Equity curve ($) 2. Drawdown ($) 3. Daily PnL ($) 4. Trade PnL histogram (ticks) 5. PnL by entry minutes-since-open (scatter + mean) 6. Per level-type bar (total $ & win rate) 7. Sample day price with levels & trades 8. Net GEX profile sample day (bar by strike, walls highlighted) 9. MAE vs PnL scatter or rolling 20-trade win rate Also print a formatted stats table. Timezone handling: I'll just say the CSV must be ET and document it; synthetic data is ET. Keep it simple: parse naive timestamps as ET. Let me now write the whole thing. It'll be long, but the user asked for a backtest with multi charts. I'll aim for a complete runnable single-file script with clear sections and notes on hooking real data. Also add notes at the end: data sources (Databento CME, CME DataMine, Polygon for equity index options — note NQ options OI via CME; many people use SPX/SPY GEX levels as proxy for NQ since correlation), caveats (OI updated once daily, gamma assumes dealer positioning, stop fills assumptions, no slippage/fees unless added), and realistic expectations. Fees/slippage: add per-trade cost param in ticks (e.g., commissions $2.5/side + 1 tick slippage). Default maybe 1 tick round-trip slippage + $5 RT commission → in ticks: NQ tick $5, so $10 = 2 ticks. I'll make `COST_TICKS = 1.5` default or 0 with comment. Better default: 0 to keep it pure, but mention. Actually for honesty default to something realistic like 2 ticks RT. Hmm, I'll include parameter, default 1 tick, clearly documented. Gamma flip usage: I'll include it as a tradable level but direction: fade only when net gamma regime positive? To keep the script simpler but still meaningful: fade flip like a wall in the direction that returns price toward the flip? Actually simplest sensible: at gamma flip, if price approaches from below with positive net gamma... this gets complicated. Alternative: use flip as filter — only fade walls when net GEX > 0 (levels tend to hold in positive gamma), skip fades when net GEX < 0 (levels tend to break). That's a nice, defensible design: regime filter. And optionally trade flip breakouts in negative gamma? No — keep fade theme: fade walls when net gamma positive; optionally also fade walls in negative gamma but stats broken out. I'll make `regime_filter` a config bool: True → only take wall fades on days with positive total net GEX. Hmm, but then with synthetic data I control regime. Fine. Let me also compute "HVL" (highest total OI strike)? Could add but walls suffice. I'll compute and chart total gamma profile. Let me define tolerance: `ENTRY_BUFFER_TICKS = 5` → enter 5 ticks before the level. `STOP_TICKS = 50`. `TP_TICKS = None or 100`. `MAX_TRADES_PER_DAY = 2` (one per wall). Also disallow re-entry same level same day. End-of-window exit at 11:30 bar close (the 11:30 bar). Entries allowed up to 11:00 maybe (leave at least 30 min)? Configurable `LAST_ENTRY = 11:15`. I'll add. Now write the gamma computation from chain: ```python def bs_gamma_black76(F, K, T, sigma, r=0.0): if T <= 0 or sigma <= 0: return 0.0 d1 = (np.log(F/K) + 0.5*sigma**2*T) / (sigma*np.sqrt(T)) return np.exp(-r*T) * np.exp(-0.5*d1**2)/np.sqrt(2*np.pi) / (F*sigma*np.sqrt(T)) ``` Per-day chain aggregation: ```python def compute_gamma_levels(chain_df, F, DTE, iv_fallback=0.25, ...): # chain_df: strike, cp ('C'/'P'), open_interest, optional iv # returns levels dict + profile DataFrame call_gex, put_gex per strike total_gex_by_strike (signed: call - put ... convention) ``` Convention note: many vendors use dealers long calls (customers buy puts) → net dealer gamma = call gamma - put gamma... Actually common retail-facing convention (SpotGamma "GEX"): Net GEX = Call GEX - Put GEX? They assume dealers are short calls and long puts? Hmm. There are multiple conventions; I'll implement sign convention flag `PUT_SIGN = -1` and note that direction of the regime flip should be validated. The zero-gamma crossing strike is the Gamma Flip either way. Walls: call wall = argmax call gamma exposure (unsigned); put wall = argmax put gamma exposure. Now synthetic generator details: ```python def synth_days(n_days, seed, base_price=20000): for each day: open gap from prev close regime: 60% positive gamma (mean reverting around open), 40% negative (trending) choose put_wall ~ open - (30..80 pts), call_wall ~ open + (30..80 pts), flip between generate 1-min bars 09:30-16:00 with OU process or trend+noise so that walls hold on pos days and break on neg days ``` Also generate synthetic OI chains consistent with walls (peaked OI at walls) so `compute_gamma_levels` reproduces them — nice demo of the pipeline. I'll generate chain with OI bumps at call/put walls, plus background OI skew. Then levels computed from chain, not handed directly. That exercises the gamma code. IV by strike: skew smile: iv = 0.2 + 0.5*max(K-F,0)/F + ... simple quadratic smile. DTE: use 5 days constant or weekly. Position of flip: solve from cumulative net. OK, and the demo runner: `run_backtest(...)` returns trades df, stats, then `make_report(...)` builds the multi-chart figure and prints stats. Time-of-day analysis: minutes since open (0-120). Sample day chart: pick day with most trades; plot 1-min closes (or candlesticks via OHLC lines — use vlines/plot); horizontal lines for call wall (red), put wall (green), flip (gray dashed); markers for entries/exits; shading 09:30–11:30. Gamma profile chart: bars of call GEX and put GEX by strike (positive up for calls, negative down for puts), highlight walls, mark flip. I think also add a "trade sequence" scatter: consecutive trade index vs cumulative ticks equity — that's the equity curve. Rolling win rate (20 trades) line chart. That's 9 charts. Multi-chart figure: GridSpec 3x3, figsize ~ (18, 12). Also maybe a second figure for sample day + gamma profile to give them room. I'll do one big figure with 8-9 panels — that satisfies "multi charts." Print stats table with per-level and per-regime breakdown. Let me draft the full code now, being careful about correctness. Key engine pseudocode: ```python TICK = 0.25 STOP_TICKS = 50 STOP_PT = STOP_TICKS * TICK # 12.5 for day, day_bars in data.groupby(date): levels = levels_map[day] # dict with 'call_wall','put_wall','gamma_flip','net_gex' if regime_filter and levels['net_gex'] < 0: continue (but still track levels for chart) open_t = 09:30, last_entry_t = 11:00, close_all_t = 11:30 pos = None touched = set() trades = [] for ts, bar in day_bars.iterrows(): t = ts.time() if pos is None: if t <= last_entry: # call wall fade (short) if 'call_wall' not in touched and bar.high >= levels['call_wall'] - buf and bar.close < levels['call_wall']: entry = levels['call_wall'] - buf # if bar.high >= entry + stop_pt (same bar stop) → worst-case: take trade, mark stopped pos = dict(dir=-1, entry=entry, ...) touched.add('call_wall') elif put wall similar (long) ... else: # manage if pos.dir == -1: stop = pos.entry + STOP_PT if bar.high >= stop: exit at stop → record elif tp and bar.low <= pos.entry - TP_PT: exit at tp ... if t >= close_all and pos: exit at bar.close if pos at end of day data: exit at last bar close ``` Wait — subtlety on entry condition `bar.close < call_wall`: if the bar closes above the wall (broke through), do we fade? Classic fade would enter at touch before knowing close. Since we iterate bar by bar, at bar close we know the bar's close; the realistic sim: within the bar, price touched the trigger first (we don't know path). Conservative approach: enter at trigger, and if the same bar's range also hits the stop, assume stop hit (worst case). If bar closes beyond level, trade still entered at trigger and managed going forward. I think that's the right conservative approach; I'll implement: entry triggered by bar range reaching trigger; same-bar stop check worst-case; same-bar TP check ignored (conservative). Also require approach direction: for call wall short, we want price coming from below — since trigger is level - buffer and price was below the wall recently... Simplify: require bar.close <= call_wall (not strongly above) OR just always trigger on range touch. I'll add `require_rejection_close`: bool — if True, only enter if bar.close < wall (shows rejection). Default True — it's a fade after all. Hmm, but if bar closes above wall, price broke through; skipping entry that day is reasonable ("failed fade filter"). I'll implement with flag on. MFE/MAE: track from entry across subsequent bars until exit. PnL: dir * (exit - entry) / TICK in ticks; $ = ticks * $5 (NQ: $20/pt, tick $5). Costs: COST_TICKS per round trip subtract. Equity: cumulative sum of trade $ (closed-trade equity, no intraday compounding). Daily PnL groupby date. Max DD on daily equity. Sharpe: mean daily ret / std * sqrt(252) — on $ with fixed 1 contract, fine-ish. Now stats per level type: n, win%, avg ticks, total $. Per-regime (synthetic only? for real data regime = sign of net GEX that day): breakdown positive vs negative net gamma days. Since I default regime_filter True, negative days produce no trades; to show breakdown, set filter False in demo? Better: default regime_filter False so all days trade and the chart can show positive-vs-negative regime performance — demonstrating why the filter matters. Then in write-up: "turn on REGIME_FILTER to only fade on positive gamma days." Hmm — but which default gives a nicer demo? With synthetic data I control it: positive-gamma days → walls hold → fades win; negative-gamma days → walls break → fades lose. With filter False you see both, and the per-regime bar chart shows the edge is regime-dependent; that's pedagogically great. I'll default False and let the charts reveal it, and mention flipping it on. Actually, let me make the demo even better: keep both, print stats for filter=False, and also print the filtered subset stats ("If you only faded on positive-gamma days: ..."). Nice. Synthetic data generation specifics: Trading days: use pd.bdate_range('2024-01-02', periods=n) — 126 business days for 6 months. Each day: - prev_close tracked; overnight gap ~ N(0, 40 pts) - open = prev_close + gap - regime ~ Bernoulli(p=0.6 positive) - drift: pos-gamma: OU around open (mean-revert, θ strong); neg-gamma: trend with drift ± (10..40 pts over the day) and higher vol - levels: call_wall = round(open + U(25, 70) to 25-pt grid), put_wall = open - U(25,70) - Simulate 1-min bars 09:30–16:15 (405+ bars) with: - vol per-minute sigma ~ (pos: 3 pts/√min? that's too high. NQ 1-min stdev typically ~ 5-10 pts. Let's use 6 pts/min vol → daily (390 min) σ ≈ 6*√390 ≈ 118 pts — too high; realistic NQ daily range ~ 150-250 pts, okay-ish. I'll use 4 pts/min → daily σ≈79. fine.) - OU: x_{t+1} = x_t + θ(μ - x_t)dt + σ√dt ε, θ tuned so half-life ~ 20 min on positive days. - On negative days, μ drifts (open + trend_t) and vol multiplier 1.3, walls break. - Ensure on positive days price actually visits walls sometimes: μ = open, but need excursions of 25-70 pts with 4 pts/min noise — over 2 hours (120 min), σ ≈ 4*√120 ≈ 44 pts — will touch often. Good. - Add wall "magnet/rejection": on positive days, add a soft force away from walls when within 10 pts (optional — makes walls hold convincingly). I can implement: if x > call_wall - 15: push down a bit. This is synthetic; fine. Build OHLC from per-minute path: for each minute, simulate 4 sub-steps → open/high/low/close. Chain generation per day (using previous day's settlement as F for OI snapshot — actually OI snapshot from prior evening; use prior close F and DTE until Friday): - strikes grid: around F ± 1500 pts in 25-pt steps - baseline OI ~ lognormal, more puts below (typical skew), calls above - add bumps: OI at call_wall ~ ×(5-10) factor; put_wall similar - iv smile per strike - This produces computed walls ≈ planted walls. flip = weighted center. Then compute_gamma_levels computes from this chain — pipeline exercised. But careful: chain uses OI at strikes; wall = argmax gamma×OI. With bumps planted at chosen walls, computed call wall = planted (bump dominates). Good. For real-data users: `load_chain_csv` documented. Now the code. Let me write it fully and carefully. I'll aim for clean, organized, commented, ~500-600 lines. Format: one big code block, then explanation of assumptions, how to plug real data, and interpretation notes. The user asked "write me a multi charts backtest" — deliverable is the code primarily. Length: long is fine, but avoid unnecessary padding. I'll include concise section headers. Let me write: ```python # ===================================================================== # NQ FUTURES — GAMMA-LEVEL FADE BACKTEST (first 2 hours) # ===================================================================== # Strategy: # * Each morning, compute OI-based gamma levels from the options chain: # - Call Wall (strike with the largest total CALL gamma exposure) # - Put Wall (strike with the largest total PUT gamma exposure) # - Gamma Flip (strike where cumulative NET gamma crosses zero) # * During 09:30-11:30 ET, FADE first touch of each wall: # - price rallies into the Call Wall -> SHORT # - price sells off into the Put Wall -> LONG # * Stop loss: 50 ticks (12.50 pts). Optional TP. Flat by 11:30. # ===================================================================== ``` Config dataclass. Data loaders with expected schemas documented. BS gamma. compute_gamma_levels(chain, F, T_years, ...) → dict. Synthetic generator. Engine. Stats. Charts. main(). Let me be careful with a few implementation details: - NQ tick = 0.25 pts, $5/tick, $20/pt. - 50 ticks = 12.5 pts = $250. - Entry buffer default 4 ticks (1 pt) before level. - Levels rounded to 0.25 grid. Time handling: index must be DatetimeIndex; I'll assume ET naive. Window: entry_time=time(9,30), last_entry=time(11,0), flat_time=time(11,30). Bars are 1-min labeled at start time. Trade record fields: date, level, dir, entry_time, exit_time, entry_px, exit_px, pnl_ticks, pnl_dol, mfe_ticks, mae_ticks, reason, net_gex_regime. For the stop same-bar worst case: after entering mid-bar, check if the bar's adverse extreme exceeds stop → exit same bar at stop, worst case. Also if TP would also be within the bar, we can't know order — conservative: stop takes priority. Position exits: stop (50t), TP (optional), flat_time close, or end of data. One trade per wall per day; also global max_trades_per_day. Now, regime: net_gex = total signed (call - put) at all strikes (sum). Positive → dealer long gamma (typically) → mean reversion; walls hold. Also compute per-day "expected" levels validity. The multi-chart figure — let me lay out 3x3: (1,1) Equity curve $ (closed trade cumulative) (1,2) Drawdown $ (1,3) Daily PnL bars $ (2,1) Trade PnL histogram (ticks) with win/loss colors (2,2) Cumulative PnL by level type (step lines) or total $ per level — I'll do grouped bar: total $ and win% per level type (2,3) PnL vs minutes-since-open scatter + mean per 15-min bucket (3,1) Per-regime (net gamma sign) grouped bars: total $, win% (3,2) Sample day chart: 1-min path + levels + entries/exits, shaded window (3,3) Gamma profile for that day: call/put GEX by strike, walls & flip marked Plus (3rd row maybe) rolling win rate — squeeze into (1,3)? I'll do a 4th chart in col 3? Let's do 3x3 as above and add rolling win rate inside stats print. Or make figure 2x4? 3x3 is fine. Actually let me add MFE/MAE scatter replacing something? Keep 9 panels as listed; that's a rich multi-chart output. suptitle with key stats. Also `print_stats` producing aligned text table. Edge cases: days with no touch → no trades; count them. Now write the synthetic chain such that computed levels come out near planted. Bump multiplier large enough (e.g., base OI up to ~2000, bump 8000-15000 at wall strikes). Also DTE: constant 3 days. T = 3/365. IV: smile: iv(K) = 0.18 + 1.2 * ((F-K)/F)^2 * sign... simpler: iv = 0.15 + 0.6*max((K-F)/F,0) + 1.5*max((F-K)/F,0) → downside skew. Fine. GEX per strike: call_gex = Σ_calls OI * gamma(K) * 100? For futures options multiplier 20 and GEX$ formula: gamma×OI×mult×F²×0.01. Mult=20. I'll parametrize OPT_MULT = 20. Numbers will be in billions — like real NQ GEX charts. Nice. put_gex similarly with sign -1 for net. net_by_strike = call - put (convention A) — note comment on convention ambiguity. flip: strike where cumsum(net_by_strike from lowest) crosses 0. Since downside puts dominate, cumulative starts very negative... cum crossing zero from negative to positive happens somewhere mid. Implement: strikes sorted; cum = cumsum(net); flip = strike where cum changes sign. Good. Walls: argmax call_gex, argmax put_gex. For synthetic chain OI bumps, gamma weighting shifts walls slightly toward ATM (since gamma higher ATM, argmax of gamma×OI might be at a neighboring strike if bump at wall is big enough). Bump ×6-8 should dominate. Fine — and any shift is okay, it's synthetic. Also plant flip implicitly: put OI heavier below → cumulative negative below put wall... net per strike: below F, put gamma dominates → negative; near/above F call dominates positive. So flip lands near F. Fine. Now real-data loaders (documented, not executed by default): ```python def load_futures_csv(path): ... # datetime,open,high,low,close,volume def load_chain_csv(path): ... # date,strike,cp,open_interest,iv(optional) ``` And note about sources: Databento (CME NQ futures + options OI settlement), CME DataMine, Polygon (index options for proxy levels), etc. NQ index options trade on CME (options on Nasdaq-100 futures). Many traders use SPX/SPY/NQ index options from OPRA... NDX options are on OPRA (Nasdaq-100 index options, ticker NDX). Using NDX options GEX levels for NQ futures is common practice — levels line up since futures track the index. I'll note this. Alright — also compute stats: - total trades, days traded, win rate, PF, expectancy (ticks & $), avg win, avg loss, max loss streak, best/worst, total $, max DD $, daily Sharpe, avg MFE/MAE. Write code now. I'll be meticulous with the engine loop. ```python from __future__ import annotations import numpy as np import pandas as pd import matplotlib.pyplot as plt import matplotlib.dates as mdates from dataclasses import dataclass from datetime import time as dtime from math import sqrt, exp, log ``` TICK_SIZE = 0.25; TICK_VALUE = 5.0 @dataclass Config: stop_ticks=50, tp_ticks=None (None=hold to flat time or opposite... keep None default; user can set 100), entry_buffer_ticks=4, entry_from=9:30, last_entry=11:00, flat_by=11:30, cost_ticks=1.0, max_trades_per_day=2, require_rejection_close=True, regime_filter=False, seed=7, n_days=120. Gamma computation function: ```python def black76_gamma(F, K, T, iv, r=0.0): F,K,T,iv = np.asarray... vectorized d1 = (np.log(F/K) + 0.5*iv*iv*T)/(iv*np.sqrt(T)) pdf = np.exp(-0.5*d1*d1)/np.sqrt(2*np.pi) return np.exp(-r*T)*pdf/(F*iv*np.sqrt(T)) ``` compute_gamma_levels(chain_df, F, dte_years, opt_mult=20): returns dict + profile df. chain columns: strike, cp, oi, iv(optional) Engine: ```python def run_backtest(bars: pd.DataFrame, levels_by_day: dict, cfg) -> (trades_df, skipped_days) ``` bars: DatetimeIndex ET, 1-min, columns open high low close volume. levels_by_day: {date: {'call_wall':px, 'put_wall':px,'gamma_flip':px,'net_gex':float}} Loop as designed. Let me write carefully: ```python buf = cfg.entry_buffer_ticks * TICK stop = cfg.stop_ticks * TICK tp = cfg.tp_ticks * TICK if cfg.tp_ticks else None for day, g in bars.groupby(bars.index.date): lv = levels_by_day.get(day) if lv is None: continue if cfg.regime_filter and lv['net_gex'] < 0: continue cw, pw = lv['call_wall'], lv['put_wall'] # order bars within window 09:30 to 11:30 day_bars = g[(g.index.time >= cfg.entry_from) & (g.index.time <= cfg.flat_by)] ``` Hmm — index.time comparisons with >= on time objects: `g.index.time` returns array of time objects; comparing arrays of time with time works elementwise? numpy object arrays... Safer: mask = (g.index >= day morning). Use `tidx = g.index.time` then `[(t >= cfg.entry_from) & (t <= cfg.flat_by)]` — with object dtype, comparisons broadcast elementwise, returning bool arrays. I believe `np.array([time(9,30)]) >= time(9,0)` works elementwise. Yes, numpy compares object arrays elementwise with Python operators. It works. Alternative: minutes = g.index.hour*60+g.index.minute. I'll do minutes since open approach for clarity: ```python mins_open = (g.index - pd.Timestamp(day) ... ) ``` Simpler: `tod = g.index.hour * 60 + g.index.minute`; `entry_from_m = 9*60+30` etc. Config as minutes ints. Cleaner. Config: entry_from_min=570 (9:30), last_entry_min=660 (11:00), flat_by_min=690 (11:30). I'll present as times but convert. Let me just store minutes ints with comment. Trade state machine per day: ```python pos = None touched = {'call_wall': False, 'put_wall': False} day_trades = 0 for ts, bar in day_bars.iterrows(): m = ts.hour*60+ts.minute if pos is None: if m <= cfg.last_entry_min and day_trades < cfg.max_trades_per_day: # Call wall fade: short if (not touched['call_wall'] and np.isfinite(cw) and bar.high >= cw - buf): if (not cfg.require_rejection_close) or bar.close < cw: px = cw - buf pos = open_trade('call_wall', -1, px, ts) touched['call_wall'] = True elif (not touched['put_wall'] and np.isfinite(pw) and bar.low <= pw + buf): if (not cfg.require_rejection_close) or bar.close > pw: px = pw + buf pos = open_trade('put_wall', +1, px, ts) touched['put_wall'] = True if pos: manage same-bar stop (worst case) else: # manage stop / tp / mfe / mae adv = stop if dir... if pos.dir == -1: pos.mfe = max(pos.mfe, (pos.entry - bar.low)/TICK) pos.mae = max(pos.mae, (bar.high - pos.entry)/TICK) if bar.high >= pos.entry + stop: close at pos.entry+stop, reason='stop' elif tp is not None and bar.low <= pos.entry - tp: close at pos.entry-tp, reason='tp' else: mirror if m >= cfg.flat_by_min and pos still open: close at bar.close, reason='flat' ``` Careful: when m >= flat_by we should exit — but also entries barred after last_entry. The flat exit condition: if m >= flat_by_min → exit at this bar's close. I'll place after stop/tp checks. Also if the day's data ends before flat time, exit at last bar close ('eod'). Note: the same-bar stop after entry: handle right after opening: check adverse extreme on the entry bar itself, worst-case. Trade dict: {'date','level','dir','entry_time','entry','exit_time','exit','reason','ticks','dollars','mfe','mae'} ticks = dir*(exit-entry)/TICK - cost_ticks... apply cost: pnl_ticks_gross = dir*(exit-entry)/TICK; net = gross - cost_ticks. Now stats function: ```python def compute_stats(trades_df, bars_days_count): ... ``` Print block with per-level breakdown and per-regime. Charts function `build_report(trades, levels_by_day, bars, cfg, sample_date=None)`: Fig 3x3 GridSpec figsize (18,11). Panel 1 equity: x = trade sequence (or exit_time), y = cum dollars. Use exit_time for time axis. Panel 2 drawdown: min(cum - running max). Panel 3 daily PnL bars: groupby date dollars. Panel 4 histogram of ticks. Panel 5 grouped bars per level type: total $ (one bar) + win rate on twin axis. Panel 6 scatter: minutes since entry_from of entry vs ticks; overlay bucket means line. Panel 7 regime grouped bars: total $ per net-gex sign; win rate. Panel 8 sample day: line of bar closes (or high-low envelope) from 09:30 to ~12:00 plus level lines; entry/exit markers with arrows. Use a few hours beyond window for context (until 13:00). Panel 9 gamma profile: call gex up bars, put gex down bars by strike; annotate walls/flip, and price line. Add suptitle: "NQ Gamma-Level Fade | 09:30–11:30 ET | Stop 50 ticks | Trades N | Win X% | PF Y | Net $Z". Return fig; also `fig.savefig('nq_gamma_backtest.png', dpi=140)`. Sample day selection: day with a trade, prefer one with both wall touches and typical behavior; just pick the day with max number of trades then median PnL, or let user pass date. I'll pick day with most trades; tie → first. Also need profile stored — I'll have compute levels also store profile df; levels_by_day entries include 'profile'. Synthetic data generator: ```python def synth_market(cfg, n_days=120, seed=7): rng = np.random.default_rng(seed) dates = pd.bdate_range('2024-01-02', periods=n_days) F0 = 20000.0 bars_list, chains = [], {} prev_settle = F0 for d in dates: gap = rng.normal(0, 30) open_px = prev_settle + gap pos = rng.random() < 0.6 # positive gamma regime # planted walls cw = open_px + rng.uniform(25, 75) pw = open_px - rng.uniform(25, 75) cw = round to 0.25? strikes are 25-pt grid: round(cw/25)*25 pw likewise # minute path 09:30–16:15 (405 min) n = 405 dt = 1.0 sigma = 4.0 if pos else 6.0 theta = 0.04 if pos else 0.005 # mean reversion strength per minute mu_t: pos: open_px constant; neg: linear trend to open_px ± (80-160) by end x = open_px for i in range(n): if pos: mu = open_px else: mu = open_px + trend*i/n # wall pinning on positive days if pos: if x > cw - 12: mu = min(mu, cw - 15) # push back elif x < pw + 12: mu = max(mu, pw + 15) x = x + theta*(mu - x) + sigma*rng.normal() path.append(x) ``` Hmm, theta*(mu-x) with mu changing: this creates soft repulsion from walls on positive days. With theta 0.04 and being 30 pts from mu, pull 1.2 pts/min vs noise 4 pts — walls hold mostly but noise (4/min) can push through by chance sometimes — good mixture of wins/losses even on positive days (stop is 12.5 pts — noise can stop us out sometimes). That's realistic-ish for a demo. Sub-steps for OHLC: to get intraminute H/L, simulate 3 sub-steps per minute and record O/H/L/C. To keep code light: per minute, do 3 sub-updates; track min/max; close=last. Open=prev close. Bars indexed 09:30 each minute: index = pd.date_range(d + 09:30, periods=405, freq='1min'). Chain for that day (used next day): from settlement F = close of day, DTE = 3/365... Chain date: evening of day d used for day d+1. I'll build chain from day's close: strikes grid F±1000 step 25; base OI: calls ~ lognormal mean 800 scaled with distance, puts heavier: put base ×2 below F. Bumps: at round(cw)/25: add 6000-12000 calls; at pw: 6000-12000 puts. iv smile as described. Store as DataFrame with date = next trading day. levels computed from chain at F. Wait — planted walls are relative to day's open; chain built from day's close with strikes near close... but levels for next day come from next day's open? The walls planted should be around next day's opening price. Since I generate days sequentially with gaps ≤ 30 pts and walls ±25-75 from open... If I build the chain at day d's close with bumps at strikes near day d's walls, and next day opens with a gap, next day's computed walls will be near day-d's walls which are ±25-75 from day-d open. Next day open within ±30 of close typically... This decorrelation is actually realistic (stale OI) but makes walls sometimes far from next day's open → fewer touches. Simpler: build chain with bumps around next day's open price — I know next open when generating sequentially (generate open first, then chain). So: for day d, after generating path and knowing day d+1's open... order: generate day d open → walls → path → bars. Then chain for day d+1: F = day d close, bumps at strikes near day d+1's... no wait. Let me restructure: walls for day d are planted from day d's open. The chain that produces day d's levels must have bumps near day d's walls. That chain is "yesterday evening's OI" — but yesterday doesn't know today's open. In synthetic world, I can just cheat: build chain dated day d−1 (evening) with F = day d−1 close, but bumps placed at day d's wall strikes. Since strikes are on 25-grid and walls rounded to grid, and gaps are small, it's plausible. The pipeline: chain_d_minus_1 → compute levels → used on day d. Bumps at day d's cw/pw strikes. Fine — synthetic, fully plausible. So: for each day d (except first), levels_by_day[d] = compute(chain built from day d-1 close F, bumps at d's walls, dated d-1). First day: build chain from F0 with bumps at day-1 walls. Implementation: loop days; before path simulation for day d, we've defined d's open and walls; then we can build the chain that will be used for day d+1... but we need d's chain before simulating d. Chicken-egg: day d's chain needs day d's walls (known after open gen — but open gen for d needs d-1 close from path...). Sequence: ``` prev_close = F0 levels_map = {} pending_chain = build_chain(F0, walls_for_day_1?) # day 1 walls depend on day1 open which comes from gap from F0 — generate open first for day 1 before loop? ``` Restructure loop: ```python for i, d in enumerate(dates): # 1) generate today's open & regime & walls open_px = prev_close + gap walls planted # 2) levels for TODAY come from chain built last night (previous iteration) if last_night_chain is not None: levels_map[d] = compute_levels(last_night_chain, F=prev_close, ...) else: (first day) levels from initial chain around F0 — build one now with bumps at today's walls (fine for demo) # 3) simulate path → bars; prev_close = last close # 4) build tonight's chain (for tomorrow) with F=prev_close, bumps at TOMORROW's walls — unknown! ``` Tomorrow's walls depend on tomorrow's open (gap) — unknown tonight. So bumps can't be at tomorrow's walls. Alternative: plant bumps relative to TODAY's close (F) at strikes we choose, and generate tomorrow's open close to today's close... but gap noise decorrelates. Cleaner alternative: decouple — the walls that price "respects" in the synthetic path are the COMPUTED levels (from last night's chain), not planted ones. I.e., build tonight's chain with bumps at arbitrary strikes near today's close (e.g., ±40 pts, mimicking where hedging accumulated today), compute levels from it, and tomorrow's path dynamics (pinning/repulsion) use those computed levels. Then the strategy fades exactly the levels price is respecting — consistent, and exercises the real pipeline (chain → levels → price respects levels). So loop: ```python prev_close = F0 tonight_levels = compute_levels(build_chain(F0, bumps around F0±U(25,75)), F0) # for day 1 for d in dates: lv = tonight_levels (call_wall, put_wall, flip, net_gex, profile) regime = sign-dependent? Let regime = (net_gex > 0) matches chain construction: choose chain skew to make net_gex sign = desired regime open = prev_close + gap simulate path with pinning to lv's walls when regime positive; trend when negative bars... prev_close = close # build chain for tomorrow: decide tomorrow's regime first! tomorrow_regime = rng < 0.6 bump strikes: cw' = round(prev_close + U(25,75)/25)*25 ; pw' = ... chain: if regime positive → put skew moderate; negative → heavier puts lower (net negative) tonight_levels = compute_levels(chain, prev_close) ``` And regime for tomorrow stored alongside. The engine's regime_filter uses net_gex sign from computed levels — consistent. Implement build_chain(F, cw_strike, pw_strike, net_sign, rng): - strikes = F ± 1200 step 25 (rounded grid relative to F multiple of 25) - call OI baseline: 300 + lognormal noise, decreasing with distance above? Keep flat-ish with noise; plus bump at cw: +U(5000,9000), plus smaller bump maybe cw+25. - put OI baseline similar; bump at pw. - For net positive sign: calls also get a general tilt up (×1.3 base) and puts bump smaller; for negative: put bump huge and extra put OI below (disaster puts). Net sign emerges. Compute net_gex = Σ(call_gex - put_gex). Then regime for next day path = (net_gex > 0). Path simulation uses lv['call_wall'], lv['put_wall'] for pinning on positive days; on negative days trend through walls. This is coherent: positive-gamma days → price mean-reverts and walls hold; negative days → trends and breaks walls. The backtest fading every day will show: wins on positive days, losses on negative ones → per-regime chart shows split → motivates regime filter. One more consideration: on negative-gamma days with trend, price may only touch one wall (e.g., rally to call wall then break through and keep going → short gets stopped). Good — that's the lesson. TP default: None → hold until 11:30 flat. Also add option take profit at opposite wall? Keep simple: cfg.tp_ticks. I think also track `no_touch_days` count. Also compute stats on "what if filtered": stats of subset trades where day net_gex>0. Sharpe from daily PnL: sharpe = mean/std*sqrt(252) (in dollars, scale-invariant-ish given fixed size). Max DD: on cumulative daily equity. Now write charts with careful matplotlib code. Use constrained_layout or tight_layout. I'll use `fig = plt.figure(figsize=(18, 12), constrained_layout=True)`; `gs = fig.add_gridspec(3, 3)`. Panel details: 1. Equity: ax.plot(exit_times, cumsum(dollars)); maybe use step. Add horizontal 0 line. Title "Cumulative PnL ($)". 2. Drawdown: fill_between dates, dd, 0, color red alpha. 3. Daily PnL: bar dates (could be many; use width=1, color by sign). 4. Hist: np.histogram ticks, bins ~ 30; color win green/loss red — easiest: plot two hists (wins, losses) with alpha. 5. Level performance: for each level type: bar total $ (colors) + twin axis line/dots win rate. Or two sub-bars. I'll do: x = level types; bars = total $; annotate win% above. Simple. 6. Entry time scatter: x = minutes since 9:30 (0-90 for entries), y = ticks; color win/loss; plus mean per 15-min bucket line. 7. Regime: two bars net $ (pos vs neg gamma days) + win rate annotation. 8. Sample day: get bars for that date 09:30–13:00; plot close line (or OHLC via fill_between low-high alpha for candle-ish feel + close line); hlines cw (red dashed), pw (green dashed), flip (gray dotted); shade entry window 09:30–11:30 (axvspan); mark entries (v marker), exits (x marker), stop level line per trade? Keep clean: markers with arrows and annotate reason. 9. Gamma profile: from levels_map[sample_day]['profile': strike, call_gex, put_gex (negative), net cumulative maybe]. bar chart; highlight wall strikes; axvline price at open. Suptitle with headline stats. Print stats table. Now also write "REAL DATA HOOKS" section: functions with docstrings describing schemas: ```python def load_futures_csv(path) -> pd.DataFrame def load_chain_csv(path) -> pd.DataFrame ``` And note in main: `USE_SYNTHETIC = True`. I need to double check engine subtlety: touched flags prevent re-entry per level per day. Also `require_rejection_close` might skip a touch entirely (never enters, and touched flag set? If we set touched when trigger hit even without entry, then no retry — reasonable: first touch is the fade). I'll set touched=True at trigger regardless of entry. Also, entry fill price: `cw - buf` (limit-ish). Realistically entering at market when bar reaches trigger — fill at trigger price ± slippage; cost_ticks covers. Same-bar stop worst-case: after entry, compute if bar.high >= entry+stop (for short) → exit same bar at stop. If require_rejection_close True and bar closed below wall, the same bar having high ≥ stop means the bar spiked 12.5 pts above trigger before closing below — plausible; worst-case accounting fine. MAE/MFE: for same-bar exit, mfe/mae from that bar. Also handle: bar triggers both walls same bar (big bar) — elif ensures only one entry. Also for levels from real data: strikes are index points; NQ futures price ≈ NDX index + basis (typically futures slightly above). Note: apply `FUT_INDEX_BASIS = 0.0` config to adjust levels (e.g., shift levels by basis). I'll include a `level_shift` param note. Timezone note: data must be America/New_York; bars 1-min. Now write stats printing: ``` ================= RESULTS ================= Trades: N (X per day avg) Win rate: % Avg win / loss (ticks): / Expectancy: ticks ($ /trade) Profit factor: Total PnL: $ Max DD: $ Daily Sharpe: Longest losing streak: ------------------------------------------- By level: table By regime: table ------------------------------------------- [Regime filter] If only fading net-gamma>0 days: subset stats ``` Implement helper `summarize(df)` returning dict, and `fmt_summary`. Let me now also make sure `compute_gamma_levels` robust: group chain by strike & cp; compute gamma per row via vectorized black76 with F scalar, K array, iv array; gex = gamma*oi*OPT_MULT*F*F*0.01. Aggregate call/put per strike. net = call - put. total_call_by_strike etc. Walls: strike with max call_gex; put wall similarly. If ties, nearest to F. Flip: sort strikes asc, cum = cumsum(net); find first index where cum >= 0 after being <0 — more robust: find sign change in cum (from ≤0 to ≥0); if none, use argmin |cum|. Note convention. Return also profile df for chart: columns strike, call_gex, put_gex, cum_net. Also include `net_gex_total = cum[-1]` (sum net) for regime. Rounding: levels to 0.25 grid via round(px/0.25)*0.25. DTE: cfg.chain_dte_days = 3 → T=3/365. Edge: gamma for deep ITM/OTM fine with smile iv. Now, code volume: this will be ~600 lines. That's acceptable given the ask ("write me a multi charts backtest"). I'll keep comments tight. Also include requirements: numpy, pandas, matplotlib. No scipy. Let me draft the final code mentally then write it out. ```python """ NQ FUTURES — OPEN-INTEREST GAMMA LEVEL FADE — BACKTEST & MULTI-CHART REPORT ============================================================================ WHAT IT DOES 1. Builds daily gamma levels from an options OI chain (Nasdaq-100 / NDX-style): Call Wall, Put Wall, Gamma Flip. 2. Fades the FIRST touch of each wall in the first two hours (09:30-11:30 ET): rally into Call Wall -> short; sell-off into Put Wall -> long. 3. 50-tick stop (12.50 pts = $250), flat by 11:30, optional take-profit. 4. Prints full stats and draws a 9-panel report. DATA * Demo mode generates synthetic 1-min bars + synthetic OI chains so the file runs end-to-end. Results are ILLUSTRATIVE — swap in real data to get real results (see load_futures_csv / load_chain_csv + notes at bottom). * Bars must be 1-min, timezone America/New_York (naive ET ok). * Chain must be the PRIOR EVENING's settlement OI, used for the next session. pip install numpy pandas matplotlib """ ``` Then constants, config dataclass, gamma math, chain→levels, loaders, synthetic, engine, stats, charts, main. Let me write the engine precisely. ```python def run_backtest(bars, levels_by_day, cfg): tick = 0.25 buf = cfg.entry_buffer_ticks * tick stop_px = cfg.stop_ticks * tick tp_px = (cfg.tp_ticks * tick) if cfg.tp_ticks else None trades = [] no_touch = 0 for day, g in bars.groupby(bars.index.date, sort=True): lv = levels_by_day.get(day) if lv is None: continue if cfg.regime_filter and lv['net_gex'] <= 0: continue cw, pw = lv.get('call_wall'), lv.get('put_wall') g = g.sort_index() tod = g.index.hour*60 + g.index.minute win = g[(tod >= cfg.entry_from_min) & (tod <= cfg.flat_by_min)] if win.empty: continue touched = set() pos = None n_tr = 0 def close_pos(pos, ts, px, reason): ... for ts, bar in win.iterrows(): m = ts.hour*60+ts.minute if pos is None: if (m <= cfg.last_entry_min and n_tr < cfg.max_trades_per_day): if cw is not None and 'CW' not in touched and bar.high >= cw - buf: touched.add('CW') if (not cfg.require_rejection_close) or bar.close < cw: pos = dict(level='CallWall', d=-1, entry=cw-buf, t_in=ts, mfe=0.0, mae=0.0) n_tr += 1 # same-bar worst-case stop if bar.high >= pos['entry'] + stop_px: _close(pos, ts, pos['entry']+stop_px, 'stop'); pos=None elif pw is not None and 'PW' not in touched and bar.low <= pw + buf: touched.add('PW') if (not cfg.require_rejection_close) or bar.close > pw: pos = dict(level='PutWall', d=+1, entry=pw+buf, t_in=ts, mfe=0, mae=0) n_tr += 1 if bar.low <= pos['entry'] - stop_px: _close(...); pos=None else: d, e = pos['d'], pos['entry'] pos['mfe'] = max(pos['mfe'], (d*(bar.low - e))/tick if d>0 else (e-bar.low)/tick) ... ``` Let me write mfe/mae generically: favorable = d>0 → (bar.low - e); d<0 → (e - bar.high). adverse = d>0 → (e - bar.low)... wait adverse for long is when low < e: adverse = e - bar.low. For short adverse: bar.high - e. ```python if d > 0: pos['mfe'] = max(pos['mfe'], (bar.low - e)/tick) pos['mae'] = max(pos['mae'], (e - bar.low)/tick) # careful negative when low>e → max keeps 0 floor fine if bar.low <= e - stop_px: exit at e-stop_px, 'stop' elif tp_px and bar.high >= e + tp_px: exit e+tp_px, 'tp' else: pos['mfe'] = max(pos['mfe'], (e - bar.high)/tick) pos['mae'] = max(pos['mae'], (bar.high - e)/tick) if bar.high >= e + stop_px: exit, 'stop' elif tp_px and bar.low <= e - tp_px: exit, 'tp' ``` MAE can be negative if trade never went adverse; max with 0 initial keeps ≥0 — but then MAE 0 always... I initialize mae=0 meaning "max adverse" from 0 baseline; better track worst excursion relative to entry including favorable (which is fine: max(mae, adverse) where adverse≥0 when against). If never adverse, mae stays 0. OK. If m >= flat_by_min and pos open → exit at bar.close 'flat'. After loop, if pos open (data ended) → exit last bar close 'eod'. If no touches at all day: no_touch += 1 if n_tr==0. Trade record append on close: ```python gross_ticks = d*(exit - entry)/tick net_ticks = gross_ticks - cfg.cost_ticks dollars = net_ticks * 5.0 ``` Good. Note NQ $5/tick constant. Now the levels map also includes regime for charts (net_gex). Trades store date & level & regime? I'll attach `net_gex` sign at trade time from lv. Charts: for regime chart, need mapping trade→day regime: store in trade dict 'day_net_gex'. Sample day pick: among days with trades, pick the one with most trades; fallback first trade day. For the sample day chart, bars window 09:30–13:30 from full bars df (not just win). Gamma profile panel: profile df from levels_map[sample_day]['profile']. Note: compute levels needs profile stored. Synthetic chain build: ```python def synth_chain(F, cw, pw, net_pos, rng, mult=20): lo = int(np.floor((F-1200)/25)*25); hi = int(np.ceil((F+1200)/25)*25) strikes = np.arange(lo, hi+1, 25) base_call = rng.lognormal(mean=log(500), sigma=0.6, size=len(strikes)) base_put = rng.lognormal(...) # roll-off far from F: decay = np.exp(-((strikes-F)/700)**2) call_oi = base_call*decay put_oi = base_put*decay # skew: puts bigger below F put_oi *= np.where(strikes < F, 1.6, 0.9) call_oi *= np.where(strikes > F, 1.2, 0.9) # wall bumps call_oi[np.argmin(abs(strikes-cw))] += rng.uniform(6000, 10000) put_oi[np.argmin(abs(strikes-pw))] += rng.uniform(6000, 10000) if net_pos: # dealers long gamma: calls favored call_oi *= 1.25 else: # dealers short gamma: put OI dominates below put_oi[strikes < F-100] *= 2.2 iv smile: iv = 0.16 + 0.8*np.clip((F-strikes)/F,0,1)**1 + 0.4*np.clip((strikes-F)/F,0,1) ... let me define moneyness m = strikes/F - 1; iv = 0.18 + 6*m*m? A smile: iv = 0.15 + 30*(m - (-0.005))**2? Simple: iv = 0.15 + 0.5*m**2*100? Let me just do iv = 0.14 + 0.9*np.maximum(m,0) + 2.5*np.maximum(-m,0) with m = (K-F)/F. For m=+2% → 0.158; m=-2% → 0.19. Reasonable skew. Floor at 0.10. build df: strike, cp ('C'/'P'), oi, iv — long format both rows. ``` Hmm wait: with decay exp(-((K-F)/700)^2): at ±300, decay = exp(-(0.43)^2)=0.83 — mild. fine. Net sign: with calls favored positive days → Σ net > 0 hopefully. On negative days put bump + disaster puts → net < 0. There's randomness; check sign after compute and if mismatch, force flip by scaling? To guarantee, after computing net_gex, if sign mismatch, scale put/call bumps... simpler: in synth_market, after computing levels for tomorrow, store desired regime and set actual path regime from computed net_gex sign (consistency with engine). I.e., tomorrow's path regime = (net_gex > 0). And I choose chain construction to *usually* give the desired sign but ultimately the path follows computed sign. That guarantees internal consistency. So synth_market: ```python prev_close = 20500 rng = ... dates = pd.bdate_range('2025-01-02', periods=cfg.n_days) # seed initial chain for day 1 desired_regime = True (positive) chain0 = synth_chain(F=prev_close, cw=prev_close+55, pw=prev_close-45, net_pos=True, rng) levels = compute_gamma_levels(chain0, F=prev_close, ...) bars_frames = [] levels_map = {} for d in dates: lv = levels levels_map[d.date()] = lv regime = lv['net_gex'] > 0 open_px = prev_close + rng.normal(0, 25) # simulate 1-min path 09:30-16:15 (405 bars) w/ pinning on walls if regime pos else trend ... bars_frames.append(df) prev_close = close[-1] # build tomorrow's chain tom_regime = rng.random() < 0.6 (desired) cw_t = grid25(prev_close + rng.uniform(25, 80)) pw_t = grid25(prev_close - rng.uniform(25, 80)) chain = synth_chain(prev_close, cw_t, pw_t, tom_regime, rng) levels = compute_gamma_levels(chain, prev_close, T=3/365) bars = pd.concat(frames) ``` Path sim function: ```python def synth_path(open_px, lv, regime, rng, n=405, sigma=4.0): cw, pw = lv['call_wall'], lv['put_wall'] if regime: theta=0.05; trend=0 else: theta=0.004; trend = rng.choice([-1,1])*rng.uniform(60, 160); sigma=5.5 x = open_px out=[] # per-minute OHLC via 3 substeps for i in range(n): mu = open_px + trend*(i/n) if not regime else open_px if regime: if x > cw - 12: mu = cw - 20 elif x < pw + 12: mu = pw + 20 # 3 substeps o = x mn=mx=x for _ in range(3): x += theta*(mu - x) + sigma/np.sqrt(3)*rng.normal() mn=min(mn,x); mx=max(mx,x) out.append((o, mx, mn, x)) index = pd.date_range(d 09:30, periods=n, '1min') ``` theta=0.05 per substep? I wrote update per substep with mu pull — theta applies per substep: total pull per minute = 3*theta*(mu-x) with theta .05 → 15% per minute when far. Pinning strong. Maybe theta .03 per substep → ~9%/min. With sigma/√3 ≈ 2.3 per substep → per-minute noise σ ≈ 4. Pull at 30 pts away: 2.7 pts/min — noise dominates short-term, pinning prevails over 10+ min. Walls will mostly hold on positive days but occasional 12.5+ pt overshoots → some stopped fades. But wait: pinned levels are the COMPUTED walls — with strong pinning, first touch then reverse → wins without TP run to... exit at 11:30 close with some profit. With TP=None, avg win maybe 10-30 ticks. On negative days trend 60-160 pts through a wall → stop loss 50 ticks. Mixture → the regime filter insight. To ensure trades happen most days: pin band means price wanders ±40 around open; walls 25-80 away → most days touch at least one wall in 90 min entry window. Negative trend days: trend direction may only hit one wall. OK. Also to avoid instant touch at open (open within buffer of a wall): walls at least 25 pts from prev_close, but open gaps ±25... open could be near wall. First bar touch is fine — it's a valid fade. Also levels computed with F=prev_close but chain strikes on 25-grid → walls on 25-grid. Futures prices arbitrary → cw-buf not on grid — fine. Compute walls: argmax call_gex might be cw or cw±25 given bump 6000-10000 vs base ~500-1000*decay — bump dominates → wall = planted. Good. Put wall similar. Flip = cumulative zero crossing: negative days put-heavy below → flip above... whatever, consistent. Now think about what the demo output distribution will look like: positive days (~60%): fade wins mostly, some stops; negative days (~40%): fades stopped. Win rate maybe ~60-65%; PF slightly >1 unfiltered; filtered (net>0 only) much better. Great narrative. Charges: cost_ticks default 1 (i.e., $5 round trip incl slippage) — modest. Now stats function. Let me write: ```python def summarize(tr): if tr.empty: return {...zeros} wins = tr[tr.ticks > 0]; losses = tr[tr.ticks <= 0] ... total = tr.dollars.sum() pf = wins.dollars.sum() / abs(losses.dollars.sum()) exp = tr.ticks.mean() ... ``` Daily aggregation for DD/Sharpe: ```python daily = tr.groupby('date').dollars.sum().reindex(all_days, fill_value=0)? ``` Use trading days present in bars. equity = daily.cumsum(); dd = equity - equity.cummax(). Sharpe = daily.mean()/daily.std()*sqrt(252) guard std 0. Per level: groupby level summarize-lite (n, win%, avg ticks, total $). Per regime: groupby sign(day_net_gex). Print nicely. Charts function signature: `build_report(tr, levels_map, bars, cfg)` → returns fig; saves png. Careful with matplotlib date plotting for panel 8: index timestamps; use axvspan with pd.Timestamp boundaries. Also panel 3 daily PnL: if 120 days, fine. Panel 6: minutes since open = entry_time minutes − 570. Colors: wins #2ca02c, losses #d62728. Suptitle: f"NQ Gamma-Wall Fade | {cfg}... | trades {n} | win {wr:.1%} | PF {pf:.2f} | net ${net:,.0f} | maxDD ${dd:,.0f}". Also add note text at bottom of fig: "Synthetic demo data — plug in real bars + real OI chains" when cfg.synthetic. Main: ```python if __name__ == '__main__': cfg = Config() if USE_SYNTHETIC: bars, levels_map = synth_market(cfg) else: bars = load_futures_csv('nq_1min.csv') chains = load_chain_csv('ndx_oi.csv') levels_map = build_levels_from_chains(chains, bars, cfg) trades = run_backtest(bars, levels_map, cfg) stats = ... print fig = build_report(...) plt.show() ``` build_levels_from_chains: for each chain date (evening t-1), compute with F = last close before that date... Provide function: ```python def build_levels_from_chains(chains, bars, cfg): # chains: date (settle date), strike, cp, oi, iv? out={} closes = bars['close'].groupby(bars.index.date).last() # hmm need per-day close before next session for settle_date, grp in chains.groupby('date'): nxt = next trading date after settle_date F = closes.loc[settle_date] # settle of that evening lv = compute_gamma_levels(grp, F, T=cfg.dte/365) out[nxt] = lv ``` Simplify with clear docstring; users adapt. Also add basis shift: `LEVEL_SHIFT` config? I'll mention in comments (apply `cw += basis`). I think the code is shaping. Also print example console output? Not necessary — but a short "what you should see" note helps. Finally, write the explanation sections around the code: - What the levels are & conventions/assumptions - Strategy spec summary (entries, stop, exits, assumptions like worst-case same-bar, costs) - How to plug real data (Databento GLBXMD for NQ futures; NDX/CME NQ options OI; note EOD OI updates; SPX GEX proxy note) - Caveats: OI lag (updates nightly), gamma assumes dealer positioning not observable, no slippage beyond cost param, 1-min bar intrabar ambiguity handled worst-case, results are synthetic demo — not indicative. - Ideas to extend: regime filter (shown), flip-level breakout module, vol-adjusted stops, gamma-weighted magnet targeting, session filter variations. Keep the prose tight; the code is the star. Use headers and short bullets. Total answer will be long but it's a code deliverable — appropriate. One more check — "Open interest gamma levels within the first two hours": interpretation — levels derived from open interest gamma, traded within first two hours. My design matches. Alternatively they might mean "levels that form within the first two hours" — i.e., gamma levels established during the first two hours? That reading: compute gamma levels using OI at the open... Actually the natural reading: use OI-based gamma levels, trade their fade during the first two hours. I'll also add the note that levels are computed from the prior settle OI (the standard practice since CME OI updates once daily) — and if they have intraday-updated OI, they can recompute at 11:30 for the next window. Good. Let me also double-check gamma math sign conventions once more for the write-up: GEX per strike = OI × gamma × 100 × F² × 0.01 for index options (mult 100). For options on NQ futures, mult = 20. I use OPT_MULT=20 and F² × 0.01 → dollar gamma per 1% move. Net GEX = call − put (assumption: dealers long calls / short puts — i.e., customers buy puts for hedging and sell covered calls; common "customer short calls" convention actually implies dealers LONG calls... conventions differ: SpotGamma assumes dealers short calls and short puts??). I'll just state: sign convention = call positive / put negative; the regime flip and walls are robust to convention for walls; the flip's interpretation depends on dealer-positioning assumptions — validate against your vendor (SpotGamma, Menthor Q, GammaEdge etc.). Good honest note. Also note: for NDX options multiplier is 100; if user uses NDX chain set OPT_MULT=100 and F = NDX index; NQ futures trade at small premium basis. Alright — write final answer. Structure: 1. Brief intro & strategy spec box 2. The code (single file) 3. How to run / what you get (panel list) 4. Plugging in real data (schema + sources) 5. Assumptions & caveats 6. Extensions Keep sections 3-6 concise bullets. Code comments carry a lot of weight. Let me finalize numbers in code: - STOP_TICKS=50 → 12.5 pts, $250 - ENTRY_BUFFER_TICKS=4 (1 pt) - TP None default - entry_from_min=570, last_entry_min=660, flat_by_min=690 - cost_ticks=1 - max_trades_per_day=2 - require_rejection_close=True - regime_filter=False (default off so per-regime chart is populated) - n_days=126, seed=7 Synthetic: F0=20500, sigma 4 pos/5.5 neg, theta per substep 0.03 pos / 0.004 neg, trend 60–160. Pinning: if x > cw-12: mu=min(mu, cw-20); if x < pw+12: mu=max(mu, pw+20). Note: on positive days mu=open_px otherwise; pin overrides near walls. Wait, subtle: pin band only within 12 pts of wall but sets mu to 20 pts away — pull strong. Overshoot possible from noise (2.3/substep) — sometimes breaks 12.5 → stops. Good. OHLC from 3 substeps: open=prev close (x at minute start), track max/min across substeps, close final. Volume: rng.integers(200, 3000). Bars index: pd.date_range(start=pd.Timestamp(f"{d} 09:30"), periods=405, freq="min"). 405 minutes from 9:30 → 16:14. Include full session; engine slices window. Sample chart uses 09:30–13:00. compute_gamma_levels signature: (chain: DataFrame with strike, cp, oi, iv optional; F; T_years; opt_mult=20; r=0.0). If iv missing, use fallback smile 0.18. Vector: for each row compute gamma. chain could be long format; pivot: calls = chain[cp=='C'] grouped by strike sum oi and iv mean; same for puts. gex$ = gamma × OI × opt_mult × F² × 0.01. profile df: strike index (union), call_gex, put_gex(positive), net=call−put, cum. walls: cw = strike of max call_gex (ties → closest to F); pw similarly. flip: strikes sorted; cum=cumsum(net); find crossings: idx where cum[i-1]<0<=cum[i] → flip strike; if all positive → min strike? fallback: strike of min |cum|. If none found: None. net_gex = cum[-1]. Round walls to 0.25. Also guard: need ≥ some strikes. Chart 9 profile: bar(strikes, call_gex) green up; bar(strikes, -put_gex) red down; vlines at cw/pw; axvline flip dashed; secondary marker of F (open). x ticks rotated. Since strikes every 25 over ±1200 → 97 bars — fine. Panel 5 grouped: level types = ['CallWall','PutWall']. bars total $; text win%. Panel 7: regime groups 'NetGamma>0','NetGamma≤0'. Panel 6 scatter x=entry minutes since 9:30 (0..90): tr['entry_min'] = entry_time.hour*60+entry_time.minute − 570. Bucket means line at [0,15,30,45,60,75,90]. Alright, also engine: bars must be ET and 1-min; assert monotonic. Let me also store in trades: 'date', 'level', 'dir_text', 'entry_time', 'exit_time', 'entry', 'exit', 'reason', 'ticks', 'dollars', 'mfe', 'mae', 'day_net_gex'. DataFrame columns accordingly for stats/charts. Now write everything out. Also I'll include a small `pd.set_option` no. Keep clean. Potential pitfall: groupby on bars.index.date returns keys as datetime.date — levels_map keyed by date objects — consistent. Sample day chart: pick sample_date = tr.date.mode or max count; bars.loc[str(sample_date)] — index slicing by string date works if index is DatetimeIndex. Use mask: bars.index.date == sample_date. For charts, converting tr dates (datetime.date) for plotting: use pd.to_datetime(tr.exit_time) directly — entry/exit times are Timestamps already (from iterrows index) — yes, ts is Timestamp. Good; store them directly. Daily PnL axis: dates from tr['date'] (datetime.date) — matplotlib handles via pd.to_datetime. Edge: trades empty → charts guard: print "no trades" and return None. Write stats print with f-strings aligned. Also print config summary at top of run. Total code let me now actually write carefully, checking syntax mentally. ```python from __future__ import annotations import numpy as np import pandas as pd import matplotlib.pyplot as plt from dataclasses import dataclass, asdict from math import sqrt # ------------------------------------------------------------- constants TICK_SIZE = 0.25 # NQ tick (index pts) TICK_VALUE = 5.0 # $ per tick ($20/pt) PT = 1.0 # not needed @dataclass class Config: stop_ticks: int = 50 tp_ticks: int | None = None entry_buffer_ticks: int = 4 entry_from_min: int = 9*60+30 last_entry_min: int = 11*60 flat_by_min: int = 11*60+30 cost_ticks: float = 1.0 max_trades_per_day: int = 2 require_rejection_close: bool = True regime_filter: bool = False # synthetic demo synthetic: bool = True n_days: int = 126 seed: int = 7 # gamma model dte_days: float = 3.0 opt_mult: float = 20.0 # options on NQ futures; use 100 for NDX index options r: float = 0.0 ``` Black76 gamma vectorized: ```python def black76_gamma(F, K, T, iv, r=0.0): K = np.asarray(K, float); iv = np.asarray(iv, float) T = max(T, 1e-6) iv = np.clip(iv, 1e-4, None) with np.errstate(divide='ignore'): d1 = (np.log(F/K) + 0.5*iv*iv*T)/(iv*np.sqrt(T)) pdf = np.exp(-0.5*d1*d1)/sqrt(2*np.pi) return np.exp(-r*T)*pdf/(F*iv*sqrt(T)) ``` compute_gamma_levels: ```python def compute_gamma_levels(chain, F, dte_days, opt_mult=20.0, r=0.0): """ chain: DataFrame [strike, cp ('C'/'P'), oi, iv (optional)] Returns dict with call_wall, put_wall, gamma_flip, net_gex, profile(df) GEX(strike) = gamma * OI * mult * F^2 * 1% (dollar gamma per 1% move) """ T = max(dte_days, 0.5)/365.0 ch = chain.copy() if 'iv' not in ch: ch['iv'] = 0.20 ch['gamma'] = black76_gamma(F, ch['strike'].values, T, ch['iv'].values, r) ch['gex'] = ch['gamma']*ch['oi']*opt_mult*F*F*0.01 call = ch[ch.cp=='C'].groupby('strike')['gex'].sum() put = ch[ch.cp=='P'].groupby('strike')['gex'].sum() prof = pd.DataFrame({'call_gex': call, 'put_gex': put}).fillna(0.0).sort_index() prof['net'] = prof.call_gex - prof.put_gex prof['cum_net'] = prof.net.cumsum() net_total = float(prof.net.sum()) if prof.empty: return None cw = prof.call_gex.idxmax() pw = prof.put_gex.idxmax() flip = None c = prof.cum_net.values; s = prof.index.values for i in range(1, len(c)): if c[i-1] < 0 <= c[i]: flip = float(s[i]); break if flip is None: flip = float(s[np.argmin(np.abs(c))]) round25 = lambda p: round(p/0.25)*0.25 return {'call_wall': round25(cw), 'put_wall': round25(pw), 'gamma_flip': round25(flip), 'net_gex': net_total, 'profile': prof.reset_index()} ``` Wait: cw from idxmax may be a strike (int) → round25 fine. `round(p/0.25)*0.25` returns float; strikes on 25-grid stay same. Synthetic chain builder: ```python def _grid25(x): return float(int(round(x/25.0))*25) def synth_chain(F, cw, pw, net_pos, rng): lo = _grid25(F-1200); hi = _grid25(F+1200) strikes = np.arange(lo, hi+25, 25) m = (strikes - F)/F decay = np.exp(-((strikes-F)/800.0)**2) call_oi = rng.lognormal(log(400), 0.7, len(strikes))*decay*np.where(strikes>F,1.15,0.85) put_oi = rng.lognormal(log(400), 0.7, len(strikes))*decay*np.where(strikes 0 open_px = prev_close + rng.normal(0, 25) bars_d = _sim_day(d, open_px, levels, regime, rng) frames.append(bars_d) prev_close = float(bars_d['close'].iloc[-1]) tom_pos = rng.random() < 0.60 cw_t = _grid25(prev_close + rng.uniform(25, 85)) pw_t = _grid25(prev_close - rng.uniform(25, 85)) chain = synth_chain(prev_close, cw_t, pw_t, tom_pos, rng) levels = compute_gamma_levels(chain, prev_close, cfg.dte_days, cfg.opt_mult, cfg.r) bars = pd.concat(frames) bars.index.name='ts' return bars, lmap ``` _sim_day: ```python def _sim_day(d, open_px, lv, regime, rng, n_min=405, sub=3): cw, pw = lv['call_wall'], lv['put_wall'] if regime: theta, sigma, trend = 0.030, 4.0, 0.0 else: theta, sigma = 0.004, 5.5 trend = rng.choice([-1.0, 1.0])*rng.uniform(60, 160) x = open_px o=[]; h=[]; l=[]; c=[]; v=[] for i in range(n_min): mu = open_px + trend*(i/n_min) if regime: if x > cw-12: mu = min(mu, cw-20) if x < pw+12: mu = max(mu, pw+20) b_o = x; b_h=b_l=x step_sig = sigma/sqrt(sub) for _ in range(sub): x += theta*(mu-x) + step_sig*rng.normal() b_h=max(b_h,x); b_l=min(b_l,x) o.append(b_o); h.append(b_h); l.append(b_l); c.append(x) v.append(int(rng.integers(150, 2500))) idx = pd.date_range(pd.Timestamp(d)+pd.Timedelta(hours=9, minutes=30), periods=n_min, freq='min') return pd.DataFrame({'open':o,'high':h,'low':l,'close':c,'volume':v}, index=idx) ``` Wait: theta applied per substep with mu distance: at 30 pts away → per substep 0.9 pts; per minute 2.7 pts toward mu; noise per minute σ=4. Pin decent. Hmm, theta semantics: x += theta*(mu−x) each substep → per-minute effective reversion (1−(1−θ)^3) ≈ 8.7% at θ=.03. Fine. Engine (final): ```python def run_backtest(bars, levels_by_day, cfg): tick=TICK_SIZE buf=cfg.entry_buffer_ticks*tick stop=cfg.stop_ticks*tick tp=(cfg.tp_ticks*tick) if cfg.tp_ticks else None trades=[]; days_no_touch=0; days_skipped=0 for day, g in bars.groupby(bars.index.date, sort=True): lv = levels_by_day.get(day) if lv is None: continue if cfg.regime_filter and lv['net_gex']<=0: days_skipped+=1; continue cw,pw = lv['call_wall'], lv['put_wall'] g=g.sort_index() tod=g.index.hour*60+g.index.minute win=g[(tod>=cfg.entry_from_min)&(tod<=cfg.flat_by_min)] if win.empty: continue touched=set(); pos=None; n_tr=0 def record(pos, ts, px, reason): d=pos['d']; e=pos['entry'] gross=d*(px-e)/tick net=gross-cfg.cost_ticks trades.append(dict(date=day, level=pos['level'], direction='SHORT' if d<0 else 'LONG', entry_time=pos['t_in'], exit_time=ts, entry=e, exit=px, reason=reason, mfe=pos['mfe'], mae=pos['mae'], ticks=net, dollars=net*TICK_VALUE, day_net_gex=lv['net_gex'])) for ts, bar in win.iterrows(): m=ts.hour*60+ts.minute if pos is None: if m<=cfg.last_entry_min and n_tr=cw-buf: touched.add('CW') ok = (not cfg.require_rejection_close) or bar.close=pos['entry']+stop: # worst-case same-bar stop record(pos, ts, pos['entry']+stop, 'stop'); pos=None elif 'PW' not in touched and pw is not None and bar.low<=pw+buf: touched.add('PW') ok = (not cfg.require_rejection_close) or bar.close>pw if ok: pos=dict(level='PutWall', d=+1, entry=pw+buf, t_in=ts, mfe=0.0, mae=0.0) n_tr+=1 if bar.low<=pos['entry']-stop: record(pos, ts, pos['entry']-stop, 'stop'); pos=None else: d,e=pos['d'],pos['entry'] if d<0: pos['mfe']=max(pos['mfe'],(e-bar.low)/tick) pos['mae']=max(pos['mae'],(bar.high-e)/tick) if bar.high>=e+stop: record(pos, ts, e+stop,'stop'); pos=None elif tp is not None and bar.low<=e-tp: record(pos, ts, e-tp,'target'); pos=None else: pos['mfe']=max(pos['mfe'],(bar.low-e)/tick) pos['mae']=max(pos['mae'],(e-bar.low)/tick) if bar.low<=e-stop: record(pos, ts, e-stop,'stop'); pos=None elif tp is not None and bar.high>=e+tp: record(pos, ts, e+tp,'target'); pos=None if pos is not None and m>=cfg.flat_by_min: record(pos, ts, bar.close,'flat'); pos=None if pos is not None: # data ended inside window record(pos, win.index[-1], win['close'].iloc[-1],'eod') if n_tr==0: days_no_touch+=1 tr=pd.DataFrame(trades) meta=dict(days=len(bars.index.date.unique()), days_no_touch=days_no_touch, days_skipped=days_skipped) return tr, meta ``` Bug check: `record` closure references `lv` from loop — Python closure over loop var: record defined inside for-loop over days, and called within same iteration → fine (lv is current day's). But defining a closure inside a loop each iteration is fine. However, `record` also uses `trades` list — fine. One subtlety: after entering a position on a bar (say 10:15) and same-bar stop didn't trigger, the NEXT bars manage it. The entry bar's favorable move isn't captured into mfe (we only set 0) — actually entry bar could have favorable excursion before close; ignoring is conservative for MFE. Fine. Also flat_by exit: `m>=flat_by_min` — the 11:30 bar closes the position at its close. Note entries: bars labeled by start time; the 11:29 bar (m=689) can still enter if ≤ last_entry 660? No — 689 > 660, barred. OK. Also note the win slice includes bars up to flat_by (m ≤ 690 → 11:30 bar included for exit). Good. Stats: ```python def summarize(tr): if tr is None or tr.empty: return dict(n=0) w=tr[tr.ticks>0]; l=tr[tr.ticks<=0] gw=w.dollars.sum(); gl=l.dollars.sum() return dict(n=len(tr), wins=len(w), losses=len(l), win_rate=len(w)/len(tr), avg_win=w.ticks.mean() if len(w) else 0, avg_loss=l.ticks.mean() if len(l) else 0, expectancy=tr.ticks.mean(), total=tr.dollars.sum(), pf=(gw/abs(gl)) if gl!=0 else float('inf'), best=tr.ticks.max(), worst=tr.ticks.min()) ``` Daily DD & Sharpe: ```python def daily_metrics(tr, n_days): daily = tr.groupby('date')['dollars'].sum() eq = daily.cumsum() peak = eq.cummax() dd = eq-peak maxdd = dd.min() if len(dd) else 0 mu, sd = daily.mean(), daily.std() sharpe = (mu/sd*sqrt(252)) if sd and sd>0 else 0 return eq, maxdd, sharpe ``` Careful: sharpe over days with trades only vs all days — use reindex to all trading days with 0 fill for accuracy: In print_stats: need trading days list. Pass `all_days` from bars. I'll pass bars into print function or compute daily over tr dates — simpler: approximate with traded-days only; note it. Eh, better do it right: reindex: ```python def daily_metrics(tr, all_days): daily = (tr.groupby('date')['dollars'].sum() .reindex(all_days, fill_value=0.0)) ``` all_days: sorted unique dates from bars (date objects). ok. print_stats(tr, meta, all_days, cfg): ```python s = summarize(tr) eq, maxdd, sharpe = daily_metrics(tr, all_days) L = max losing streak: compute via loop on tr.ticks<=0. ``` Print block. Also by-level and by-regime: ```python print(tr.groupby('level').apply(lambda x: pd.Series({...}))) ``` groupby.apply with Series — deprecation warnings in new pandas but works; safer to build manually: ```python def block(df, key): rows=[] for k, g in df.groupby(key): ss=summarize(g) rows.append((k, ss['n'], ss['win_rate'], ss['expectancy'], ss['total'], ss['pf'])) return pd.DataFrame(rows, columns=[key,'trades','win%','exp(t)','net$','PF']) ``` Print with to_string formatting. Regime key: `np.select([tr.day_net_gex>0],['NetGEX > 0'],['NetGEX ≤ 0'])`. Also "filtered view": tr[tr.day_net_gex>0] summarize — show what the regime filter would have done. Charts: ```python def build_report(tr, levels_map, bars, cfg, save='nq_gamma_fade_report.png'): if tr.empty: print('No trades — nothing to plot'); return None GREEN='#2e7d32'; RED='#c62828' fig=plt.figure(figsize=(18,12), constrained_layout=True) fig.suptitle('NQ Futures — OI Gamma-Level Fade (09:30–11:30 ET) | 50-tick stop', fontsize=15, fontweight='bold') gs=fig.add_gridspec(3,3) ... ``` Panel 1 equity: ```python ax=fig.add_subplot(gs[0,0]) xs=pd.to_datetime(tr.exit_time) ax.plot(xs, tr.dollars.cumsum(), lw=1.8, color='#1565c0') ax.fill_between(xs, tr.dollars.cumsum(), 0, alpha=.1, color='#1565c0') ax.axhline(0,color='k',lw=.6) ax.set_title('Cumulative PnL ($, closed trades)') ``` Panel 2 drawdown: ```python all_days=sorted(bars.index.date.unique()? use unique) daily=...reindex...cumsum; dd=eq-eq.cummax() ax.fill_between(pd.to_datetime(eq.index), dd, 0, color=RED, alpha=.55) ``` eq.index are date objects → pd.to_datetime handles. Panel 3 daily bars: ```python ax.bar(pd.to_datetime(daily.index), daily.values, color=np.where(daily.values>=0,GREEN,RED)) ``` Panel 4 hist: ```python ax.hist(tr[tr.ticks>0].ticks, bins=30, color=GREEN, alpha=.75, label='wins') ax.hist(tr[tr.ticks<=0].ticks, bins=30, color=RED, alpha=.75, label='losses') ax.axvline(tr.ticks.mean(), color='k', ls='--', label=f'mean {tr.ticks.mean():.1f}t') ``` Panel 5 by level: ```python ax=... groups=[(lv, g) for lv,g in tr.groupby('level')] totals=[g.dollars.sum() for _,g]; wrs=[100*(g.ticks>0).mean() for _,g] bars_=ax.bar([k for k,_], totals, color=[GREEN if t>=0 else RED for t in totals]) for i,(k,g) in enumerate(groups): ax.text(i, totals[i], f"win {wrs[i]:.0f}%\n{n}", ha='center'...) ``` Keep simpler: annotate win% and n above bars. Panel 6 entry-time scatter: ```python mins=tr.entry_time.dt.hour*60+tr.entry_time.dt.minute-570 ax.scatter(mins[tr.ticks>0], tr.ticks[tr.ticks>0], c=GREEN, s=18) ax.scatter(mins[tr.ticks<=0], tr.ticks[tr.ticks<=0], c=RED, s=18) # bucket means edges=[0,15,30,45,60,75,91] mb=[] for i in range(len(edges)-1): msk=(mins>=edges[i])&(mins0,'Net GEX > 0','Net GEX ≤ 0') similar grouped bars: totals + win% annotation ``` Panel 8 sample day: ```python counts=tr.groupby('date').size() sample=counts.sort_values(ascending=False).index[0] if ... day_bars=bars[bars.index.date==sample] show=day_bars[day_bars.index.time<=time(13,30)] ``` Hmm index.time comparison to time(13,30): array vs scalar with <= works elementwise? numpy object array comparisons: `day_bars.index.time <= datetime.time(13,30)` — returns numpy bool array — I believe yes (object dtype comparisons elementwise supported). To be safe: use hour*60+minute mask like elsewhere. Consistent approach: tod. ```python tod=day_bars.index.hour*60+day_bars.index.minute show=day_bars[tod<=13*60+30] ax.plot(show.index, show.close, lw=1.1, color='black') ax.fill_between(show.index, show.low, show.high, color='#90a4ae', alpha=.5, label='H-L range') lv=levels_map[sample] ax.axhline(lv['call_wall'], color=RED, ls='--', label=f"Call wall {lv['call_wall']:.2f}") ax.axhline(lv['put_wall'], color=GREEN, ls='--', ...) ax.axhline(lv['gamma_flip'], color='gray', ls=':') ax.axvspan(pd.Timestamp(f"{sample} 09:30"), pd.Timestamp(f"{sample} 11:30"), color='#ffca28', alpha=.12) day_tr=tr[tr.date==sample] for _,t in day_tr.iterrows(): ax.scatter(t.entry_time, t.entry, marker='v' if t.direction=='SHORT' else '^', s=120, c=...) ax.scatter(t.exit_time, t.exit, marker='x', s=80, c='k') ax.annotate(f"{t.ticks:+.0f}t", (t.exit_time, t.exit), fontsize=9, ...) ax.set_title(f'Sample day {sample} — trades & levels') ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M')) ``` f"{sample} 09:30" — sample is datetime.date → f string fine. axvspan with pd.Timestamp works. Entry marker direction color: short red, long green. Panel 9 gamma profile: ```python prof=lv['profile'] ax.bar(prof.strike, prof.call_gex, color=GREEN, alpha=.7, label='call GEX') ax.bar(prof.strike, -prof.put_gex, color=RED, alpha=.7, label='put GEX') ax.axvline(lv['call_wall'], color=RED, ls='--') ax.axvline(lv['put_wall'], color=GREEN, ls='--') ax.axvline(lv['gamma_flip'], color='gray', ls=':') ax.axvline(day open price?, color='blue') — open = bars first bar open of sample day. ax.set_title('Gamma profile (prior-settle OI)') ``` GEX values huge (billions) — fine, y auto. Scientific notation auto. Then `fig.savefig(save, dpi=140)` and return fig. Also charts of MFE/MAE? skip, we have 9 panels. Also add small text on fig: fig.text(0.995, 0.005, note, ha='right', fontsize=8) — with constrained_layout, fig.text at corner may overlap; acceptable. Wait — panel 8 & 9 both keyed on same sample day via `lv` var — ensure lv defined before both. Order: define sample, day_bars, lv then add panels 8 and 9. But I add subplots in grid order; I can compute sample stuff first, then panels in any order. Fine. Main: ```python def main(): cfg=Config() print(__doc__-ish header) if cfg.synthetic: bars, levels_map = synth_market(cfg) print(f"[demo] synthetic: {cfg.n_days} days ...") else: bars=load_futures_csv('nq_1min.csv') # see docstring chains=load_chain_csv('ndx_oi_settle.csv') levels_map=build_levels_from_chains(chains, bars, cfg) tr, meta = run_backtest(bars, levels_map, cfg) print_stats(tr, meta, bars, cfg) fig=build_report(tr, levels_map, bars, cfg) if fig: plt.show() ``` Real loaders: ```python def load_futures_csv(path): """CSV: ts (ET, 1-min, e.g. 2025-01-02 09:30:00), open, high, low, close, volume.""" df=pd.read_csv(path, parse_dates=['ts']).set_index('ts').sort_index() return df def load_chain_csv(path): """CSV: settle_date, strike, cp ('C'/'P'), oi, iv (optional). One snapshot per evening.""" return pd.read_csv(path, parse_dates=['settle_date']) def build_levels_from_chains(chains, bars, cfg, basis=0.0): """Map each evening's OI snapshot to the NEXT session's levels. basis = futures minus index (add to levels if chain is NDX).""" day_closes = bars['close'].groupby(bars.index.date).last() out={} for sd, grp in chains.groupby('settle_date'): F = day_closes.get(sd.date() if hasattr(sd,'date') else sd) if F is None or pd.isna(F): continue nxt_days=[d for d in day_closes.index if d> (sd.date() if ...)] if not nxt_days: continue lv=compute_gamma_levels(grp, F+basis... hmm basis on F? levels in strike space vs futures — add basis to returned walls. out[nxt_days[0]]=lv with walls += basis return out ``` Simplify: compute with F (index), then shift walls by basis: ```python lv=compute_gamma_levels(grp, float(F), cfg.dte_days, cfg.opt_mult, cfg.r) if basis: for k in ('call_wall','put_wall','gamma_flip'): lv[k]+=basis out[next_day]=lv ``` sd may be Timestamp → sdd=sd.date(). day_closes index are datetime.date. next day = first date > sdd in index. Fine — concise with comments. Note on tick value: NQ E-mini $5/tick. Yes (NQ = $20/pt, tick 0.25 → $5). Now — sanity check synthetic stats roughly. Positive days: pin at walls; entry at wall−1pt; stop 12.5 above entry (i.e., 13.5 above... wait entry = cw − 1.0 (4 ticks). Stop = entry + 12.5 = cw + 11.5. Pin pushes mu to cw−20 → price bounces. Win size at 11:30 flat exit: from cw−1 to wherever — often 10–40 pts back toward open. Some overshoot stops (noise 4/min, substep 2.3): P(overshoot 11.5 pts beyond wall before reverting) nontrivial maybe 15-25%. So positive-day win rate ~75-85%, avg win maybe +25 ticks, avg loss −50. Negative days: trend through wall; stop −50 ticks most of the time; occasionally price touches wall then reverses if trend small/away... trend direction random; if trend away from the touched wall, fade may win. Roughly: 40% of days negative with maybe 70-80% stopouts. Overall: n≈126 days×~1.4 trades=175 trades; win ~60%; PF ~ (0.6*25)/(0.4*50)=0.75 → slightly negative unfiltered?! Hmm: wins avg +25t? maybe more (pin reversion 20+ pts → 80+ ticks if held to flat... wait ticks: 20 pts = 80 ticks. Stop 50 ticks = 12.5 pts. Pin reversion 20 pts = 80 ticks → avg win maybe 40-70 ticks if held to 11:30. Losses 50 ticks. Positive day (60%): win ~80%, avg win ~50t (5k... no—50 ticks=12.5 pts. Reversion from wall −1 to mid-range maybe 25 pts → 100 ticks, but price wanders; exit at 11:30 wherever — mean reversion to open: distance wall→open 25-85 pts → up to 340 ticks?! Wait walls 25-85 pts from open (uniform(25,85)). If pinned at wall and reverts to open by 11:30, win = 100-340 ticks. Whoa — that's big vs 50-tick stop. Hmm, that skews demo very positive on positive days. Realistic GEX pinning doesn't fully revert to open... Let me temper: pin sets mu to cw−20 when near wall, but baseline mu=open_px — so after being pushed 20 pts off wall, drift toward open continues if far. OU pulls toward open continuously (theta per substep .03 → strong). So on positive days price oscillates around open; wall touch then reversion toward open → win potentially large (many tens of ticks). Losses capped 50. Positive days strongly profitable. Negative days: −50 or occasionally touch-and-reverse early before trend develops... trend small early (i/n), noise may revert. Net: strategy likely profitable unfiltered in this synthetic — because positive-day wins (avg maybe +80t?) outweigh. Then regime chart still shows split (neg days negative). Fine — demo shows edge on positive days; the regime chart and filtered stats tell the story. Also mean-reversion magnitude: walls 25–85 from open, mu=open, OU half-life ~ ln2/(3θ) ≈ ln2/0.09 ≈ 7.7 min — strong. Price will oscillate ±σ√(1/(2θ_eff))... stationary sd for OU per-minute discretization: var ≈ σ²/(2θ_total_per_min) where θ_total/min ≈ 0.09 → sd ≈ 4/√0.18 ≈ 9.4 pts?? That's the stationary std around open — then walls at 25-85 pts would RARELY be touched! Oops. OU with theta 3% per substep → per-minute mean reversion coefficient a = 1−(1−0.03)^3 ≈ 0.0873. Stationary sd of x: sd = σ_min / sqrt(2a) ≈ 4/√(0.1746) ≈ 9.57 pts. So on positive days, price stays within ~±20-30 pts (3σ) of open — walls at 25–85 away → many days never touch a wall → lots of no-touch days on positive days! That breaks the demo touch rate. Fix options: - Put walls closer: uniform(15, 45) from open. 3σ≈29 → decent chance to touch 15-45 walls. - Increase sigma on positive days (4 → 5.5) and reduce theta a bit: a=0.05, sd=5.5/√0.1=17.4 pts. Walls at 20–60 → touched often. - Use sigma 6.5, theta .02/substep → a≈0.059, sd≈6.5/√0.118≈18.9 pts. Walls 20-55. NQ realism: 1-min σ ~ 5-8 pts, daily range 150-250. With sd 19 pts around open, 2-hour range ~ 4×19=76 pts, day range ~ 120-150 — a bit tame but ok for demo. Let me set positive: sigma=6.0, theta_sub=0.02 → a≈0.0588, stationary sd≈6/√0.1176≈17.5 pts. Walls at 25–70 from prev_close (open ± gap ≤25) → open-to-wall distance varies; wall 25 from close could be 0-50 from open. Touch probability decent (~50-70% of positive days touch a wall in 90 min). Also with sd 17.5, price spends time ±20 pts; wall at 30 → within 1.7σ → touched with good probability over 90 min. OK. Overshoot risk at wall with pin: when x within 12 pts of wall, mu jumps to wall∓20 → strong pull 0.0588×(dist) — at touch, pull = 0.0588×21 ≈ 1.23 pts/min vs noise 6/min. Noise often pushes through by >11.5 pts?? P(single-minute move beyond +11.5 beyond wall) — noise σ 6/min; overshoot 11.5 → ~1.9σ ≈ 3% per minute; over the minutes near wall, cumulative chance of 11.5-pt penetration maybe 20-35% → positive-day stop rate ~25%. Acceptable. Negative days: sigma 8, theta tiny (0.0005/substep → a≈0.0015, negligible), trend 60–160 pts/405min → per-minute 0.15-0.4 pts drift + noise 8. Wall touch then trend continues through → stop. Sometimes trend direction away from both walls early; price still wanders (sd builds ~ 8×√t). Over 90 min σ≈76 pts cumulative — will touch some wall. Stop likely. Fine. Let me recheck positive-day win magnitude: entry at wall−1, pin reverses to open; exit 11:30 at ~open ± 10 → win ≈ wall−open ± noise ticks. Walls uniform(25,70) from close → win avg ~40 pts = 160 ticks?? That's unrealistically good vs 50-tick stop, making demo equity curve crazy bullish. Hmm. Because synthetic pinning is too perfect (full reversion to open). To temper, set walls closer (uniform 18–45 from close) and sigma higher (7) so reversion noisy: avg win ~ 25 pts = 100 ticks, still big. Alternatively don't exit at 11:30 only — TP option? The engine default flat at 11:30 — synthetic price at 11:30 is wherever it is — reversion toward open with sd 17 → position PnL ≈ (wall − x(11:30)) where x ~ N(open, 17) → win ticks ≈ (wall−open)±17 pts. With wall−open ~ U(18,45) minus gap effect — mean ≈ 30 pts → 120 ticks win vs −50 stop at ~25% rate → EV per positive trade ≈ 0.75×120 − 0.25×50 ≈ 77.5 ticks. Very strong. Demo looks "too good" — but it's synthetic and I'll caveat loudly. Alternatively reduce pin strength so reversion partial: after entry, mu = cw−20 only while within 12 pts; beyond, mu=open — full reversion. Could set positive-day mu = open + trend_small (mild drift ±10) so reversion not always back. Or make walls closer: U(15,40): avg 27 pts → win ~ 27±17 → some winners small/negative at flat? Win = wall − x11:30; x11:30 ~ open±17; wall-open ~U(15,40) (if gap 0). Mean win ≈ 27 pts = 108t. Still strong. It's synthetic demo — fine. But an equity curve that only rockets up looks fake; mixture with negative days (40% of days, stop −50t ×~1.3 trades) pulls back: per negative day ≈ −50×0.9 ≈ −45t avg... Let me just balance regime probability: 55% positive. Net per day ≈ 0.55×(1.2 trades×77t) − 0.45×(1.2×−45t) ≈ 0.55×92 − 0.45×54 ≈ 50.6 − 24.3 ≈ +26t/day ≈ +$130/day. Over 126 days ≈ +$16k on 1 contract. Curve rises with drawdowns from losing streaks — plausible-looking demo. And the per-regime chart will show net>0 days strongly positive, net≤0 days negative → the "lesson": filter by net gamma sign; filtered subset stats ≈ +$22k, PF ~3. I should be explicit in prose: synthetic numbers are illustrative of the pipeline, not evidence of edge. One more engine consideration: on negative days price trends and breaks wall — after stop-out, `touched` prevents re-entry same wall. Other wall untouched opposite side → maybe later touch → additional trade. OK. Also gap days: open beyond wall (e.g., gap up above call wall) — first bar high ≥ cw−buf triggers immediately, require_rejection_close: bar.close < cw? If gapped above, close likely > cw → no entry that day. Good realism. Now let me also double check `require_rejection_close` on entry bar where price spikes to wall but closes below — enter at trigger cw−1 retroactively... fill assumption: we'd have been filled when price reached trigger intra-bar. OK. Costs: cost_ticks=1 → $5/trade round trip. Commissions ~$2-4 RT + slippage — reasonable-ish default; mention. Let me also reconsider last_entry 11:00 — leaves ≥30 min management. Fine. Edge: `flat_by_min=690` and bars exist till 16:15 → after 11:30 no management (we exited). Engine slices win to ≤690. Good. Potential issue: `win.iterrows()` — bar.high etc. named tuples. fine. Now print_stats: include max consecutive losses: ```python streak=mx=0 for t in tr.ticks: streak = streak+1 if t<=0 else 0 mx=max(mx,streak) ``` Also avg MFE/MAE: ```python tr.mfe.mean(), tr.mae.mean() ``` Also exit reason breakdown: groupby reason count/sum $. Filtered view print: summarize(tr[tr.day_net_gex>0]) — "If you only faded on net-positive-gamma days:" plus the same for ≤0. This is the money insight. Alright, also `plt.show()` guarded. Imports: matplotlib.dates as mdates. Let me make sure pandas groupby on `tr.date` (datetime.date objects) — fine; eq.index for plotting: pd.to_datetime(eq.index) converts list of dates. `ax.fill_between(dates, dd, 0)` with dd Series indexed by date — use `pd.to_datetime(dd.index)` as x and dd.values as y. Panel 3 daily bars: x=pd.to_datetime(daily.index), y=daily.values. Now assemble final code. Also docstring at top explaining everything + disclaimer. And `USE SYNTHETIC` toggle via cfg.synthetic. The user likely wants to run this; with synthetic default it runs anywhere with numpy/pandas/matplotlib. Good. Let me also add `pd.options.mode.copy_on_write`? Unneeded. Double-check black76_gamma with F scalar and K array: np.log(F/K) elementwise fine. If K contains F? log(1)=0 fine. No zero strikes. compute_gamma_levels: ch['iv'] check — `if 'iv' not in ch.columns`. Use that. idxmax on empty guard: if len(prof)==0 return None. Also if call_gex all zero → idxmax returns first — fine synthetic always positive. Flip: cumulative from lowest strike: below F puts dominate → net negative → cum negative; above F calls → net positive; crossing near F. On net_pos chains (calls ×1.3) crossing maybe below F; on negative chains crossing above F. OK. One more: `prof.call_gex.idxmax()` — strike index int. Walls on 25-grid → round25 keeps. cast float. `_grid25` for negatives fine. Also careful: in synth_chain, strikes array must include cw/pw exactly (they're on grid within ±1200 of F ~ prev_close ±... cw_t within +85 of prev_close — inside range). argmin finds exact. In synth_market the first levels: chain around F0=20500 — day 1 open = F0+gap. Trades `day_net_gex` stored from lv at entry. Now, bars df columns order: open, high, low, close, volume. Also add `bars` guard: engine expects at least the window bars. Time to also write `print_header(cfg)` small. Now think about answer formatting: Per instructions, code in markdown code blocks. The response should have: brief intro, spec bullets, the code block (long), then "What the 9 panels show", "Plugging in real data", "Assumptions & caveats", "Extensions". Use headers. Keep prose tight; code does heavy lifting with comments. One more design point to mention: NQ options vs NDX options for gamma levels — most gamma-level vendors compute NDX (OPRA) levels; NQ futures track NDX closely; apply basis shift. CME also lists options on NQ futures themselves (OI available via CME/Databento). Both work; multiplier differs (20 vs 100). Also mention gamma flip usage optional — currently not traded by default (only walls); easy to add a breakout/fade module at flip — point to code location. Let me now also verify the engine handles `tp_ticks` default None (hold to flat). Good; mention trying 100 ticks as 2:1. Write out the final code now in full, then the prose. Also note: the histogram bins for wins/losses separately might misalign ranges; fine visually. For panel 6 bucket means, guard empty buckets with np.nan and plot. Potential pandas warning: groupby.apply deprecation — avoid by manual loops as planned. In build_report, `tr.date` for selecting sample day trades: `day_tr = tr[tr.date == sample]` where sample is a datetime.date from counts index (groupby('date') keys are dates). Good. `counts = tr.groupby('date').size()` — index dates. Levels map keys: dates. `lv = levels_map[sample]` — sample is date → matches. Edge: sample day might be skipped in levels_map? No — trades only exist for days in map. x-axis formatting panel 8: `ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))`; also maybe rotate. For panel 9: use prof from lv['profile']; bar width 12 (strikes 25 apart). ax.tick_params axis x rotation. Add axvline for open price: `bars[bars.index.date==sample]['open'].iloc[0]` — compute day_open. Add legend small font. Y-values in $bn — leave auto. Suptitle includes headline: compute summarize inside build_report for title, or pass stats. I'll compute inside. Also overall figure note text: f"Synthetic demo data — seed {cfg.seed}. Replace with real bars + real OI chains for actual results." bottom right — but constrained_layout with fig.text: I'll place via `fig.text(0.01, 0.001, ...)` small; risk of overlap minimal at 8pt. Actually constrained_layout ignores fig.text → could overlap bottom-left panel. Place at (0.5, 1.001)? Overlaps suptitle. Simplest: put the note in the savefig filename print and title suffix " [SYNTHETIC DEMO]" when cfg.synthetic. I'll append to suptitle second line: use `fig.suptitle(f"...\n{note}", ...)`? Two-line suptitle works. I'll do title line + smaller subtitle line via fig.text(0.5, 0.975). Hmm constrained_layout again. Keep it simple: include "[SYNTHETIC DEMO DATA]" in suptitle when synthetic. Also print_stats prints a clear warning banner if synthetic. Alright — also one more subtlety in `run_backtest`: when regime_filter=False we trade all days; trades carry day_net_gex so charts/stats can split. Good. `meta` includes days_no_touch — print. Let me write `print_stats`: ```python def print_stats(tr, meta, all_days, cfg): line='='*74 print(line); print('NQ GAMMA-LEVEL FADE — FIRST 2 HOURS — BACKTEST RESULTS'); print(line) if cfg.synthetic: print(' >>> SYNTHETIC DEMO DATA — numbers are illustrative only <<<') print(f"Days in sample : {meta['days']}") print(f"Days skipped (filter) : {meta['days_skipped']}") print(f"Days w/o level touch : {meta['days_no_touch']}") if tr.empty: print('No trades.'); return s=summarize(tr); eq,maxdd,sharpe=daily_metrics(tr, all_days) streak/best/worst... print(...) by level block by regime block exit reasons block filtered view: pos=summarize(tr[tr.day_net_gex>0]); neg=... ``` Format: use fixed-width f-strings. daily_metrics needs all_days sorted list; reindex requires same type (dates). `pd.Series` reindex with list of date objects fine. Now, everything assembled. Also handle `tr` empty in summarize/daily_metrics gracefully. Finally the "How to use real data" section: schemas, sources (Databento `GLBX.MDP3` NQ continuous + options settlement OI via `news.`? Options OI: Databento has options on futures? CME options OI available via CME DataMine / Refinitiv; NDX via Polygon `:ndX` opra). Mention: OPRA NDX via Polygon.io, Tradier, dxFeed; CME futures via Databento. Also mention free alternatives: some vendors publish daily GEX levels (SpotGamma free sheet, Menthor Q, Tradytics) — you can hardcode daily levels CSV (date, call_wall, put_wall, flip) and skip chain compute — I'll add support: `levels_map` can be built from a simple CSV too. Add loader `load_levels_csv(path)` with columns date, call_wall, put_wall, gamma_flip, net_gex(optional). That's very practical since many users get levels from a vendor. ```python def load_levels_csv(path, basis=0.0): df=pd.read_csv(path, parse_dates=['date']) out={} for _,r in df.iterrows(): d=r['date'].date() out[d]={'call_wall': r['call_wall']+basis,'put_wall': r['put_wall']+basis, 'gamma_flip': r.get('gamma_flip', np.nan) if ... else float(r['gamma_flip'])+basis, 'net_gex': r.get('net_gex', np.nan), 'profile': None} ``` r.get on Series works (returns default if missing). Fine. Note: engine uses lv['net_gex'] for regime filter; if NaN, filter off — guard: `if cfg.regime_filter and (lv.get('net_gex') is None or np.isnan(...))`: treat as pass. I'll code: `ng = lv.get('net_gex', 0.0)`; if regime_filter and ng<=0 skip. NaN<=0 is False → NaN passes. Acceptable; document that regime filter needs net_gex. In engine, profile may be None → panel 9 guard: if profile is None, plot text "no chain". Handle. build_report: `prof = lv.get('profile')` — if None or empty → panel 9 shows message. Also flip may be NaN from CSV → axhline NaN breaks? axhline with NaN y — matplotlib draws nothing? Might error or draw nothing; guard with np.isfinite. Add guards: `if np.isfinite(lv.get('gamma_flip', np.nan))`. OK. Time to write the final answer. I'll write code ~550 lines with comments. Let me write it cleanly section by section. I must be careful about correctness since user may run it directly. Let me mentally trace a couple of tricky lines once more: - `tod = g.index.hour*60+g.index.minute` — DatetimeIndex has .hour/.minute arrays → tod ndarray int. Comparisons fine. - `bars.groupby(bars.index.date, sort=True)` — keys date objects sorted. - In `_sim_day`, `pd.Timestamp(d)+pd.Timedelta(hours=9, minutes=30)` — d is a Timestamp from bdate_range → plus 9h30m = 09:30 same day. Good. - `rng.integers(150, 2500)` returns np int → int() cast. - synth_chain uses `log` — import from math or np.log. Use np.log. - In compute_gamma_levels, `ch['iv']` assignment when missing: `ch['iv']=0.20` before gamma calc. But careful: if iv provided per row (both C and P same iv per strike in synth) fine. - black76_gamma: T param scalar; K, iv arrays → d1 array. F scalar. Good. - gex scale: gamma ~ e.g., ATM 3-day, iv .18, F 20500: gamma = pdf(d1)/(F·σ·√T); d1 ≈ (σ√T)/2 ≈ .0153 → pdf≈0.399 → gamma ≈ 0.399/(20500×0.18×0.0913) ≈ 0.399/336.7 ≈ 0.001185. GEX per strike w/ OI 8000: 0.001185×8000×20×20500²×0.01 ≈ 0.001185×8000=9.48; ×20=189.6; ×4.2e8×0.01=4.2e6 → 189.6×4.2e6 ≈ 7.96e8 ≈ $0.8bn. Bumps 10k OI → ~$1bn+ per wall. Net totals across ~97 strikes: mixed; net_gex magnitude ~ billions. Realistic scale vs vendor NDX charts ($10s bn). Good enough; opt_mult 20 for futures options. Panel 9 y in 1e9 — matplotlib auto sci notation. - Engine `record` closure: define inside day loop; uses lv, trades, cfg — fine. - After same-bar stop on entry we set pos=None but n_tr already incremented — good. - Wait: there's a subtle bug: after entering at bar ts (say via call-wall branch), we do NOT process stop for that bar in the else-branch (we're in the pos-is-None branch). I handle same-bar stop inline. Also TP same-bar ignored (conservative) — noted. - The `elif` structure: if call-wall trigger condition matched (bar.high ≥ cw−buf) but require_rejection_close failed (close ≥ cw), we skip put-wall check for that bar via elif. Rare and harmless (big bar crossing both). Actually `touched.add('CW')` happens before ok-check — set regardless. Fine ("first touch consumed"). Hmm, but one more: `elif 'PW' not in touched and pw is not None and bar.low <= pw+buf` — if CW branch condition false entirely (no touch), elif evaluates PW — correct. - MFE/MAE when same-bar stop: left at 0 — fine. - Flat exit: `if pos is not None and m>=cfg.flat_by_min` inside else-branch (pos open) — but note: pos could have been closed by stop this bar → pos None → skip. Good. Also if pos opened at m=690 (last entry 660 so no) — fine. - EOD leftover: after inner loop `if pos is not None: record(pos, win.index[-1], win['close'].iloc[-1],'eod')` — covers data ending before flat time (synthetic always has full day, but real data half-days). Stats blocks fine. daily_metrics: ```python def daily_metrics(tr, all_days): daily=(tr.groupby('date')['dollars'].sum().reindex(all_days, fill_value=0.0)) eq=daily.cumsum(); dd=eq-eq.cummax() sd=daily.std(); sharpe=float(daily.mean()/sd*sqrt(252)) if sd and sd>0 else float('nan') return daily, eq, float(dd.min() if len(dd) else 0.0), sharpe ``` all_days must be a list of date objects sorted. In main: `all_days=sorted(set(bars.index.date))`. print blocks: ```python print(f"Trades : {s['n']} ({s['n']/max(meta['days'],1):.2f}/day)") print(f"Win rate : {s['win_rate']:.1%} ({s['wins']}W / {s['losses']}L)") print(f"Avg win / loss : {s['avg_win']:+.1f} / {s['avg_loss']:+.1f} ticks") print(f"Expectancy : {s['expectancy']:+.2f} ticks (${s['expectancy']*TICK_VALUE:+,.0f}/trade)") print(f"Profit factor : {s['pf']:.2f}") print(f"Total net PnL : ${s['total']:,.0f}") print(f"Max drawdown : ${maxdd:,.0f}") print(f"Daily Sharpe (ann.) : {sharpe:.2f}") print(f"Best / worst trade : {s['best']:+.0f} / {s['worst']:+.0f} ticks") print(f"Max losing streak : {streak}") print(f"Avg MFE / MAE : {tr.mfe.mean():.1f} / {tr.mae.mean():.1f} ticks") ``` Blocks: ```python def _block(df, key): rows=[] for k,g in df.groupby(key): ss=summarize(g) rows.append([str(k), ss['n'], f"{ss['win_rate']:.0%}", f"{ss['expectancy']:+.1f}", f"${ss['total']:,.0f}", f"{ss['pf']:.2f}"]) print(pd.DataFrame(rows, columns=[key,'trades','win','exp(t)','net$','PF']).to_string(index=False)) ``` Usage: ```python print('\n— By level —'); _block(tr,'level') tr['regime']=np.where(tr.day_net_gex>0,'net GEX > 0','net GEX ≤ 0') print('\n— By dealer-gamma regime —'); _block(tr,'regime') print('\n— By exit reason —'); _block(tr,'reason') pos=summarize(tr[tr.day_net_gex>0]); neg=summarize(tr[tr.day_net_gex<=0]) print(f"\nIf you had ONLY faded on net-positive-gamma days: {pos['n']} trades, " f"win {pos['win_rate']:.0%}, net ${pos['total']:,.0f}, PF {pos['pf']:.2f}") print(f"(and only on net-negative days: {neg['n']} trades, win {neg['win_rate']:.0%}, " f"net ${neg['total']:,.0f}, PF {neg['pf']:.2f})") ``` PF inf guard in summarize: gl==0 → pf=np.nan or inf; formatting inf fine ("inf"). If no losses, `abs(gl)=0` → inf. Print f"{inf:.2f}" → 'inf'. OK. Charts: write carefully. ```python def build_report(tr, levels_map, bars, cfg, save_path='nq_gamma_fade_report.png'): if tr is None or len(tr)==0: print('No trades — report skipped.'); return None GREEN,RED,BLUE='#1b7a3e','#c0392b','#16537e' s=summarize(tr) all_days=sorted(set(bars.index.date)) daily,eq,maxdd,sharpe=daily_metrics(tr, all_days) fig=plt.figure(figsize=(18,12), layout='constrained') tag=' [SYNTHETIC DEMO]' if cfg.synthetic else '' fig.suptitle(f'NQ futures — fade of OI gamma walls, 09:30–11:30 ET, stop {cfg.stop_ticks} ticks' f'{tag} — {s["n"]} trades, win {s["win_rate"]:.0%}, PF {s["pf"]:.2f}, ' f'net ${s["total"]:,.0f}, maxDD ${-maxdd:,.0f}', fontsize=14, fontweight='bold') gs=fig.add_gridspec(3,3, hspace=..., wspace=...) ``` With layout='constrained', don't pass hspace to gridspec? constrained_layout manages spacing; add_gridspec without hspace/wspace. OK. P1 equity: ```python ax=fig.add_subplot(gs[0,0]) x=pd.to_datetime(tr['exit_time']) y=tr['dollars'].cumsum().values ax.plot(x,y,color=BLUE,lw=1.6) ax.fill_between(x,y,0,where=y>=0... simpler alpha fill to 0 ax.axhline(0,color='k',lw=.7) ax.set_title('1 · Cumulative PnL ($, 1 contract)',fontsize=10) ``` P2 dd: ```python ax=fig.add_subplot(gs[0,1]) dd=eq-eq.cummax() ax.fill_between(pd.to_datetime(dd.index), dd.values, 0, color=RED, alpha=.6) ax.set_title('2 · Drawdown ($)',fontsize=10) ``` P3 daily: ```python ax=fig.add_subplot(gs[0,2]) xd=pd.to_datetime(daily.index) ax.bar(xd, daily.values, width=1.0, color=[GREEN if v>=0 else RED for v in daily.values]) ax.set_title('3 · Daily PnL ($)',fontsize=10) ax.axhline(0,color='k',lw=.6) ``` P4 hist: ```python ax=fig.add_subplot(gs[1,0]) w=tr.loc[tr.ticks>0,'ticks']; l=tr.loc[tr.ticks<=0,'ticks'] ax.hist(w,bins=40,color=GREEN,alpha=.8,label=f'wins ({len(w)})') ax.hist(l,bins=40,color=RED,alpha=.8,label=f'losses ({len(l)})') ax.axvline(tr.ticks.mean(),color='k',ls='--',lw=1,label=f"mean {tr.ticks.mean():+.1f}t") ax.legend(fontsize=8); ax.set_xlabel('ticks (50t = stop)') ax.set_title('4 · Trade PnL distribution (ticks)',fontsize=10) ``` P5 by level: ```python ax=fig.add_subplot(gs[1,1]) groups=list(tr.groupby('level')) names=[k for k,_ in groups]; tot=[g.dollars.sum() for _,g in groups] cols=[GREEN if t>=0 else RED for t in tot] ax.bar(names,tot,color=cols) for i,(k,g) in enumerate(groups): ax.text(i, tot[i], f"win {(g.ticks>0).mean():.0%}\n n={len(g)}", ha='center', va='bottom' if tot[i]>=0 else 'top', fontsize=8) ax.axhline(0,color='k',lw=.6); ax.set_title('5 · PnL by level type',fontsize=10) ``` P6 entry time: ```python ax=fig.add_subplot(gs[1,2]) mins=(tr.entry_time.dt.hour*60+tr.entry_time.dt.minute)-cfg.entry_from_min wm=tr.ticks>0 ax.scatter(mins[wm],tr.ticks[wm],s=22,c=GREEN) ax.scatter(mins[~wm],tr.ticks[~wm],s=22,c=RED) edges=np.arange(0,96,15) mids=[];means=[] for a,b in zip(edges[:-1],edges[1:]): msk=(mins>=a)&(mins0,'net GEX > 0','net GEX ≤ 0') groups=list(tr.groupby(regs)) similar to P5 with names/tot/win annotate ax.set_title('7 · PnL by dealer-gamma regime',fontsize=10) ``` Careful: groupby(regs) groups by array aligned to tr index — works (groupby accepts array). Groups order: ['net GEX ≤ 0','net GEX > 0'] alphabetical. fine. P8 sample day & P9 profile — compute sample first: ```python counts=tr.groupby('date').size() sample=counts.sort_values(ascending=False).index[0] day_mask=bars.index.date==sample day_bars=bars[day_mask] tod=day_bars.index.hour*60+day_bars.index.minute show=day_bars[tod<=13*60+30] lv=levels_map.get(sample,{}) ax=fig.add_subplot(gs[2,1]) ax.plot(show.index,show.close,color='k',lw=1) ax.fill_between(show.index,show.low,show.high,color='#9db4c0',alpha=.45,label='1-min H/L') for lvl,cl,ls,lab in ((lv.get('call_wall'),RED,'--','call wall'), (lv.get('put_wall'),GREEN,'--','put wall'), (lv.get('gamma_flip'),'#888888',':','gamma flip')): if lvl is not None and np.isfinite(lvl): ax.axhline(lvl,color=cl,ls=ls,lw=1.2,label=f'{lab} {lvl:,.0f}') ax.axvspan(pd.Timestamp(f'{sample} 09:30'), pd.Timestamp(f'{sample} 11:30'), color='#f4c430',alpha=.15,label='fade window') dtr=tr[tr.date==sample] for _,t in dtr.iterrows(): col=RED if t.direction=='SHORT' else GREEN ax.scatter(t.entry_time,t.entry,marker='v' if t.direction=='SHORT' else '^',s=130,c=col,zorder=5) ax.scatter(t.exit_time,t.exit,marker='x',s=90,c='k',zorder=5) ax.annotate(f"{t.ticks:+.0f}t",(t.exit_time,t.exit),xytext=(0,10), textcoords='offset points',fontsize=8,ha='center') ax.legend(fontsize=7,loc='best') ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M')) ax.set_title(f'8 · Sample day {sample}',fontsize=10) ``` `pd.Timestamp(f'{sample} 09:30')` — sample is datetime.date → f-string '2025-03-14 09:30' → Timestamp parse ok. P9: ```python ax=fig.add_subplot(gs[2,2]) prof=lv.get('profile') if prof is None or len(prof)==0: ax.text(.5,.5,'no chain profile for this day',ha='center',va='center'); ax.set_axis_off() else: ax.bar(prof.strike,prof.call_gex/1e9,color=GREEN,alpha=.8,label='call GEX') ax.bar(prof.strike,-prof.put_gex/1e9,color=RED,alpha=.8,label='put GEX (−)') for lvl,cl,ls in ((lv.get('call_wall'),RED,'--'),(lv.get('put_wall'),GREEN,'--'), (lv.get('gamma_flip'),'#888',':')): if lvl is not None and np.isfinite(lvl): ax.axvline(lvl,color=cl,ls=ls,lw=1.1) ax.axvline(float(show.open.iloc[0]),color=BLUE,lw=1,label='day open') ax.legend(fontsize=7) ax.set_ylabel('$ GEX per 1% (bn)') ax.set_title('9 · Gamma profile from prior settle OI',fontsize=10) ax.tick_params(axis='x', rotation=45) ``` fig.savefig(save_path,dpi=140); print saved; return fig. main(): ```python def main(): cfg=Config() banner... if cfg.synthetic: print('[demo] generating synthetic market ...') bars,levels_map=synth_market(cfg) else: bars=load_futures_csv('nq_1min.csv') levels_map=load_levels_csv('gamma_levels.csv') # vendor levels — or: # chains=load_chain_csv('ndx_oi_settle.csv'); levels_map=build_levels_from_chains(chains,bars,cfg) tr,meta=run_backtest(bars,levels_map,cfg) print_stats(tr,meta,sorted(set(bars.index.date)),cfg) fig=build_report(tr,levels_map,bars,cfg) if fig is not None: fig.savefig('nq_gamma_fade_report.png',dpi=140) print("report saved -> nq_gamma_fade_report.png") plt.show() if __name__=='__main__': main() ``` Wait — build_report already saves; avoid double save. Let build_report not save; main saves. Or build_report saves and returns; main prints path. I'll have build_report save inside and print. Simpler: main handles save. I'll do saving in build_report (keeps main clean) and print inside. Choose: build_report(fig) → fig.savefig inside; main calls plt.show(). fine. Docstring at top: include overview, IO schemas, disclaimer. Reasonably compact. One more check on `summarize` when no losses: avg_loss 0, pf inf — prints 'inf'. ok. `tr.entry_time` dtype: DataFrame from list of dicts where entry_time values are Timestamps → dtype datetime64[ns] → .dt accessor works. exit_time same. `mins` Series aligned with tr index (default RangeIndex) — boolean masks align. ok. `tr.ticks[msk]` msk is Series bool aligned. ok. `groups=list(tr.groupby(regs))` regs ndarray len == len(tr) → groupby works with array key. P5 names from level: 'CallWall','PutWall'. daily_metrics: `tr.groupby('date')['dollars'].sum()` — date keys date objects. reindex(all_days) — all_days list of date objects → matches. eq index date objects. pd.to_datetime(dd.index) — Index of dates → DatetimeIndex. ok. One catch: `daily.mean()/sd*sqrt(252)` with sd possibly 0 → guard. In print_stats, summarize fields: need 'best','worst'. ok. Also in engine, when `cfg.regime_filter` and net_gex is NaN (vendor CSV without net_gex): `ng=lv.get('net_gex', np.nan); if cfg.regime_filter and ng<=0: skip` → NaN<=0 False → included. Document. Also make sure engine handles missing 'profile' key from load_levels_csv (set None) → build_report guard uses lv.get('profile') — ok. And flip NaN → guarded with np.isfinite... but `np.isfinite(NaN)` False → skip line. But `lvl is not None` check first — np.nan passes not-None; isfinite(NaN)→False skip. Good. But careful in engine: cw could be NaN → `bar.high>=cw-buf` → NaN comparison False → never trades. Document that walls required. Type hints minimal to keep code readable. Also — engine's `cw, pw = lv['call_wall'], lv['put_wall']` — use lv.get with default None for robustness: `cw=lv.get('call_wall'); pw=lv.get('put_wall')`. Now think about whether `win` empty check needed: yes if real data lacks window. I also want `assert bars.index.is_monotonic_increasing` after sort: just `bars=bars.sort_index()` in loaders & synth. Potential issue: `bars.groupby(bars.index.date, sort=True)` — with DatetimeIndex, `.date` property returns np array of date objects → groupby fine. Edge in `_sim_day` for regime pin: cw/pw come from `levels` computed from prior close; the path for day d uses those walls; open may gap beyond a wall (open above call wall). Then regime positive: x > cw−12 → mu=cw−20 pulls price DOWN to wall — price will hover under wall, first bar triggers entry with close likely > cw? x starts at open above cw; first bar: pull toward cw−20 with mu min... entry condition bar.high ≥ cw−buf (immediately true) and close < cw? After one minute of pull from open (gap ≤ 25-ish, wall ≥ 25 from prev_close) — could be either. If close < cw → enter short at cw−1 while price at open... entry fill at trigger assumes price traded there — if open gapped above trigger, realistic fill would be at open (market order on touch occurred at open). Fill at cw−buf is optimistic when gapped beyond. Minor synthetic artifact; acceptable — real data path fills also at trigger price. Note in caveats: fills assumed at trigger price; add slippage via cost_ticks. Hmm, actually for gap case fill at cw−buf when price opened at cw+20 means we short 21 pts better than market — unrealistic edge injection. To mitigate: entry price = min(trigger, bar.open)? For short: fill ≈ min(cw−buf, bar.open) — if bar.open < trigger (normal case: approach from below → open below trigger) fill at trigger (limit at trigger as price rises through). If open > trigger (gap), fill at open (market at window open... no — we enter when first bar range includes trigger; if open already above trigger, the touch "happened" at open) → fill = bar.open. So entry_px = min(trigger, bar.open) for shorts; max(trigger, bar.open) for longs. This is more realistic. Implement: ```python trig = cw - buf fill = min(trig, bar.open) # short trig2 = pw + buf fill2 = max(trig2, bar.open) # long ``` Stop check same-bar: for short, stop = fill + stop_px; if bar.high >= stop → same-bar worst-case stop. Since fill possibly = open (above trigger), stop distance same 12.5 from fill. Good. This also fixes: if bar.open > cw (gap above wall), trigger touched at open; fill=open; require_rejection closecw−12 → mu=min(mu, cw−20); also cap mu≥pw+20 symmetric. Negative-day: theta_sub=0.001, sigma=8, trend ±U(60,160). Also positive days: add mild intraday drift? no, fine. Touch rate estimate positive day: wall at distance d from open (d = wall−open = walldist−gap ~ U(15,55)∓25 → could be near 0 or 80). With σ stationary 17.5, wall at 30 = 1.7σ: OU hitting probability over 90 min high (~70%+). At 60 = 3.4σ: low (~10-20%). Average touch prob per wall maybe 50%. Two walls → ~75% of positive days have ≥1 trade. Negative days ~85%+ touch. Overall ~80% of days trade. n_days=126 → ~100 trading days, ~140 trades. Good sample for a demo. days_no_touch counts days with zero trades (touches that didn't enter due to rejection-close also count n_tr=0 → labeled no-touch; rename 'days_no_trade'). I'll print "Days with no fade taken". Let me also ensure that on negative days where trend takes price away from both walls, no touch → no trade. fine. Now write! Also remember np import sqrt? using math sqrt for scalars; np for arrays. Final structure of file: 1. Docstring 2. Imports 3. Constants + Config 4. Black-76 gamma + compute_gamma_levels 5. Real-data loaders (futures CSV, levels CSV, chain CSV + builder) 6. Synthetic market (chain builder, day sim, synth_market) 7. Backtest engine 8. Stats (summarize, daily_metrics, print_stats, _block) 9. Report (build_report) 10. main + __main__ Also, header comments per section with `# -----` separators. Write print_stats to also show cfg echo: stop, tp, buffer, costs, times. Let me write the entire code now carefully, then re-scan for bugs. Additionally, guard in build_report when tr has 1 trade etc. — most panels fine; hist with single-color arrays fine. For `ax.hist` when w empty → hist of empty errors? matplotlib hist with empty array returns fine (no bars) I think it errors? Actually plt.hist([]) works (empty). ok. Edge: mids/means plotting with NaN — matplotlib skips NaN. fine. In panel 1, x as pandas Series of datetimes; if duplicate exit times (same bar two trades? impossible—one pos at a time; but two trades can exit same timestamp? Entry bar stop then later entry same bar impossible... Actually same bar: stop-out then new entry? After pos=None mid-bar, we continue loop next bar — no same-bar re-entry. So exit times unique-ish. fine.) matplotlib version differences: `layout='constrained'` works on modern mpl (>=3.6). Fallback: use `constrained_layout=True` param (works older). I'll use `constrained_layout=True` for compatibility. `fig.add_gridspec(3,3)` default spacing; constrained_layout overrides spacing? constrained layout uses gridspec spacing params if given; without hspace/wspace it's fine. Let me now also decide suptitle content: with constrained_layout, suptitle placed properly. Write code: ```python """ ============================================================================ NQ FUTURES — FADE OF OPEN-INTEREST GAMMA LEVELS — FIRST TWO HOURS ============================================================================ Strategy -------- * Each session, gamma levels are derived from the PRIOR SETTLEMENT's options open interest (OI), Nasdaq-100 (NDX-style) chain: CALL WALL : strike with the largest total CALL gamma exposure PUT WALL : strike with the largest total PUT gamma exposure GAMMA FLIP : strike where cumulative NET gamma exposure flips sign * Trading window: first two hours of the session, 09:30-11:30 ET. Fade the FIRST touch of each wall (one attempt per wall per day): price rallies into the CALL WALL -> SHORT price sells off into the PUT WALL -> LONG * Fill: limit at (level ∓ buffer). Stop loss: 50 ticks = 12.50 pts = $250. * Optional take-profit; otherwise flat at 11:30 (or earlier stop/TP). Data ---- DEMO MODE (default): generates a synthetic 1-min NQ-like market AND a synthetic OI chain each evening, runs the full pipeline (chain -> gamma levels -> levels -> trades -> stats -> 9-panel chart report). Synthetic results are ILLUSTRATIVE ONLY — they demonstrate the machinery, they are NOT evidence of edge. REAL MODE: set synthetic=False and provide either (a) vendor gamma levels: load_levels_csv() [date, call_wall, put_wall, gamma_flip, net_gex?] (b) raw OI chains: load_chain_csv() + build_levels_from_chains() (c) futures bars: load_futures_csv() [ts, open, high, low, close, volume] (ET, 1-min) Requires: numpy, pandas, matplotlib. Python 3.9+. ============================================================================ """ ``` Then code. Let me write all functions completely (as reasoned above). I'll now also finalize small helpers: `_fmt` not needed. Let me carefully write `run_backtest` (most bug-prone). Also note: for the same-bar stop after entry, MFE/MAE set 0 — but the entry bar's own high could give MFE; conservative skip. ok. Also handle tp_ticks: `tp = cfg.tp_ticks` int or None. Now — one design detail: `last_entry_min=660` (11:00). Entry bars between 570..660 inclusive. Good. Potential improvement: also fade gamma flip? leave as chart-only level; note in extensions. Write `print_stats` header echo: ```python print(f" stop={cfg.stop_ticks}t ({cfg.stop_ticks*TICK_SIZE:.2f} pts, ${cfg.stop_ticks*TICK_VALUE:.0f})" f" | tp={'%dt'%cfg.tp_ticks if cfg.tp_ticks else 'none'}" f" | buffer={cfg.entry_buffer_ticks}t | costs={cfg.cost_ticks}t RT" f" | entries {fmt_min(cfg.entry_from_min)}-{fmt_min(cfg.last_entry_min)} | flat {fmt_min(cfg.flat_by_min)}") ``` fmt_min: f"{m//60:02d}:{m%60:02d}". Okay. Also `_block` grouping by reason includes 'stop','target','flat','eod'. Let me now also quickly reconsider: is `require_rejection_close=True` too strict? On pin days, touch bar closes just under wall typically → enters. ok. And cost_ticks 1.0 default ($5 RT). Mention how to set 0. Now, writing everything. After code, prose sections. Also short note interpreting the synthetic demo charts (what patterns to expect: panel 7 split etc.). Double-check imports: `import matplotlib.dates as mdates` used in panel 8; `from math import sqrt`; numpy as np; pandas as pd; plt. dataclass import. In `_sim_day` signature I pass d (Timestamp date), open_px, lv, regime, rng. One thing: `pd.Timestamp(d)` where d already Timestamp from bdate_range elements (Timestamp) → d + Timedelta ok. In synth_market loop, `for d in dates:` d is Timestamp (midnight). `d.date()` for map key. bars frames concatenated; ensure no duplicate index across days (different dates). fine. Engine groupby day on real bars: works. Also `bars.index.name='ts'` cosmetic. Let me also double check panel 8 `show.open.iloc[0]` — 'open' column exists. Potential runtime: 126 days × 405 min × 3 substeps ≈ 152k rng.normal calls — fast. Everything set. Also guard `summarize` for empty w/l using `if len(w)`. `daily_metrics` guard len. Alright, produce final answer. Code with reasonable comments. I'll number chart panels in titles for reference in prose. One more consideration on honesty: synthetic demo yields nice-looking results; I must clearly, prominently state it's synthetic and how to run real data. Also note that the same-bar worst-case stop and limit fills are optimistic/pessimistic tradeoffs, and OI updates nightly (levels can't adapt intraday), plus gamma levels assume dealer positioning conventions. Also mention: if they meant literally "levels built from OI accumulated during the first two hours" — with intraday-updated OI (e.g., from OPRA NDX options) you could recompute levels at 11:30 and fade into the afternoon; the `compute_gamma_levels` function supports any snapshot — small note. I'll include a line about that in extensions. Now write the final response. Format: - Short intro (1-2 lines) - Spec summary (compact bullets/table) - Code block (the file) - "What the report shows" (9 panels) - "Running it on real data" (schemas, sources, basis) - "Assumptions & caveats" - "Extensions" Keep prose sections short and skimmable. The code is long; that's expected. Let me finalize code text. Actually — one more check on `_block` when groupby key 'reason' — trades have reason field; good. And `tr['regime']=np.where(...)` added in print_stats mutates df (fine; used by panel 7 too but panel 7 computes its own regs array — consistent). Careful: print_stats called before build_report in main — mutation harmless. For `tr.date==sample` in panel 8: `sample` is a date from counts index. good. In build_report, `counts=tr.groupby('date').size()` — if only 1 trade day fine. Also panel 8: if show empty (real data short day) guard: `if len(show)==0: ax.text...` skip complexities — assume fine, note. Ok write it. def load_levels_csv(path, basis=0.0): ```python """Vendor-supplied daily levels. CSV columns: date, call_wall, put_wall, gamma_flip(optional), net_gex(optional) basis: futures_price - index_price (levels shifted onto the futures).""" df=pd.read_csv(path, parse_dates=['date']) out={} for _,r in df.iterrows(): d=r['date'].date() def g(k): v=r.get(k) return float(v)+basis if v==v and v is not None else None out[d]={'call_wall':g('call_wall'),'put_wall':g('put_wall'), 'gamma_flip':g('gamma_flip'), 'net_gex':float(r['net_gex']) if r.get('net_gex')==r.get('net_gex') else np.nan, 'profile':None} return out ``` `r.get('net_gex')` — Series.get exists; NaN==NaN False → condition `==` catches NaN: `v==v` test. Write helper `_f`. Simplify: ```python def _num(v): try: return float(v) except: return None ``` NaN float passes though. Use `v==v` check. I'll implement small inline. load_chain_csv + build_levels_from_chains: ```python def load_chain_csv(path): """Prior-evening OI snapshots. Columns: settle_date, strike, cp('C'/'P'), oi, iv(optional)""" return pd.read_csv(path, parse_dates=['settle_date']) def build_levels_from_chains(chains, bars, cfg, basis=0.0): """Each evening's OI snapshot -> next session's gamma levels.""" closes=bars['close'].groupby(bars.index.date).last() all_days=sorted(closes.index) out={} for sd, grp in chains.groupby('settle_date'): sdd=sd.date() if isinstance(sd,(pd.Timestamp,)) else sd if sdd not in closes.index: continue nxt=[d for d in all_days if d>sdd] if not nxt: continue lv=compute_gamma_levels(grp, float(closes.loc[sdd]), cfg.dte_days, cfg.opt_mult, cfg.r) if lv is None: continue if basis: for k in ('call_wall','put_wall','gamma_flip'): if lv.get(k) is not None: lv[k]+=basis out[nxt[0]]=lv return out ``` `isinstance(sd, pd.Timestamp)` — groupby keys from datetime64 column are Timestamps. ok. Engine note about NaN walls: `if cw is None or pw is None: continue`? Actually if only one present, trade that one: guard each branch with `cw is not None and np.isfinite(cw)`. I'll write `ok_cw = cw is not None and np.isfinite(cw)`. Wait np.isfinite(None) errors. So: `ok_cw = isinstance(cw,(int,float)) and np.isfinite(cw)`. Write helper `_lvl_ok(x)`. Alright. Also engine day skip when neither ok. Time to write the complete final code block. I'll keep it tight but complete. Also add `if __name__ == "__main__": main()`. Also in main print instructions pointer. I'll now write the response. Considering length: the code ~450-500 lines. Acceptable. Also add small utility: `def fmt_min(m)`. Let me write panel 5/7 shared helper: ```python def _bar_block(ax, groups, title): names=[str(k) for k,_ in groups] tot=[float(g['dollars'].sum()) for _,g in groups] ax.bar(names, tot, color=[GREEN if t>=0 else RED for t in tot]) for i,(k,g) in enumerate(groups): wr=(g['ticks']>0).mean() off = 0.03*max(tot) if tot[i]>=0... ax.text(i, tot[i], f"win {wr:.0%} · n={len(g)}", ha='center', va='bottom' if tot[i]>=0 else 'top', fontsize=8) ax.axhline(0,color='k',lw=.6) ax.set_title(title,fontsize=10) ``` Good. GREEN/RED defined in build_report scope and passed or globals — define module-level constants GREEN/RED/BLUE. Fine. Let me write final now. Also careful: in `_bar_block` when all totals negative, text placement fine. Also panel 4 label 'ticks (stop = ±50t)'. The main() flow prints config then runs. Final read for bugs in engine record(): uses lv captured — defined at top of day loop; closure defined per-day inside loop after lv. good. One more: engine `for ts, bar in win.iterrows():` — win includes bars ≤ flat_by; if flat bar m==690 and pos open → exit at close. good. If data missing 11:30 bar (short session) → eod exit. I'm confident enough. Write answer. Actually, let me reconsider the histogram bins: ticks range −51..+? up to maybe 200; bins=40 fine. Panel 6 xlim 0-90. Also in panel 6 `mins` could exceed 90? last entry 11:00=660 → mins ≤ 90. ok. Now write the response text + code. Also note for users with NDX vendor levels: basis shift ~ typically NQ futures trade at premium to NDX (carry); recent years basis often 30-80+ pts depending on rates/divs; important! Mention. Also note: options on futures (CME NQ options) levels avoid basis issue. Write it all out now. Below is a complete, self-contained Python backtest for fading open-interest gamma levels (Call Wall / Put Wall / Gamma Flip) on NQ futures during the first two hours (09:30–11:30 ET), with a 50-tick stop (12.50 pts = $250/contract), full stats, and a 9-panel chart report. It runs out-of-the-box in **demo mode** (synthetic 1-min bars + synthetic OI chains so you can see the whole pipeline work), and has documented hooks to drop in **real data**. **Strategy spec** - Levels computed each morning from the prior evening's options OI chain (NDX-style / options-on-NQ) - Fade **first touch** of Call Wall (short) and Put Wall (long), one attempt per wall per day, entries allowed 09:30–11:00, flat by 11:30 - Fill: limit at level ∓ buffer (4 ticks); stop = 50 ticks from fill; optional TP; flat forced at 11:30 - Same-bar entry+stop handled worst-case; 1 tick round-trip cost default ```python """ ============================================================================ NQ FUTURES — FADE OF OPEN-INTEREST GAMMA LEVELS — FIRST TWO HOURS ============================================================================ Levels (from prior settlement OI, recomputed nightly): CALL WALL = strike with largest total CALL gamma exposure PUT WALL = strike with largest total PUT gamma exposure GAMMA FLIP = strike where cumulative NET gamma exposure flips sign Rules: fade FIRST touch of each wall, 09:30–11:30 ET, stop = 50 ticks. DEMO MODE generates synthetic data (results are ILLUSTRATIVE ONLY). REAL MODE: set synthetic=False, see loaders at the bottom of the file. Requires: numpy, pandas, matplotlib. ============================================================================ """ from __future__ import annotations import numpy as np import pandas as pd import matplotlib.pyplot as plt import matplotlib.dates as mdates from dataclasses import dataclass from math import sqrt TICK_SIZE, TICK_VALUE = 0.25, 5.0 # NQ: $5/tick, $20/pt GREEN, RED, BLUE = "#1b7a3e", "#c0392b", "#16537e" # ------------------------------------------------------------------ config @dataclass class Config: stop_ticks: int = 50 # 12.5 pts = $250 tp_ticks: int | None = None # e.g. 100 for 2:1; None = hold to flat time entry_buffer_ticks: int = 4 # limit fill this many ticks before the level entry_from_min: int = 9 * 60 + 30 # 09:30 ET last_entry_min: int = 11 * 60 # last new entry 11:00 flat_by_min: int = 11 * 60 + 30 # force flat 11:30 cost_ticks: float = 1.0 # round-trip slippage+fees in ticks max_trades_per_day: int = 2 require_rejection_close: bool = True # entry bar must close back inside the level regime_filter: bool = False # True = only fade on net-gamma > 0 days # gamma model dte_days: float = 3.0 opt_mult: float = 20.0 # 20 = options on NQ futures; 100 = NDX index options r: float = 0.0 # data synthetic: bool = True n_days: int = 126 seed: int = 7 # ------------------------------------------------------- gamma mathematics def black76_gamma(F, K, T, iv, r=0.0): """Black-76 gamma; K, iv arrays, F scalar.""" T = max(T, 1e-6); iv = np.clip(np.asarray(iv, float), 1e-4, None) d1 = (np.log(F / np.asarray(K, float)) + 0.5 * iv * iv * T) / (iv * sqrt(T)) return np.exp(-r * T) * np.exp(-0.5 * d1 * d1) / sqrt(2 * np.pi) / (F * iv * sqrt(T)) def compute_gamma_levels(chain, F, dte_days, opt_mult=20.0, r=0.0): """ chain: DataFrame [strike, cp ('C'/'P'), oi, iv optional] GEX(strike) = gamma * OI * mult * F^2 * 1% (dollar gamma per 1% move) Returns dict: call_wall, put_wall, gamma_flip, net_gex, profile(df) NOTE: 'net' = call - put. The flip's sign interpretation depends on your dealer-positioning convention — sanity-check walls against your vendor. """ T = max(dte_days, 0.5) / 365.0 ch = chain.copy() if "iv" not in ch.columns: ch["iv"] = 0.20 ch["gamma"] = black76_gamma(F, ch["strike"].values, T, ch["iv"].values, r) ch["gex"] = ch["gamma"] * ch["oi"] * opt_mult * F * F * 0.01 call = ch[ch.cp == "C"].groupby("strike")["gex"].sum() put = ch[ch.cp == "P"].groupby("strike")["gex"].sum() prof = pd.DataFrame({"call_gex": call, "put_gex": put}).fillna(0.0).sort_index() if prof.empty: return None prof["net"] = prof.call_gex - prof.put_gex prof["cum_net"] = prof.net.cumsum() flip = None c, s = prof.cum_net.values, prof.index.values for i in range(1, len(c)): if c[i - 1] < 0 <= c[i]: flip = float(s[i]); break if flip is None: flip = float(s[int(np.argmin(np.abs(c)))]) rnd = lambda p: round(float(p) / 0.25) * 0.25 return {"call_wall": rnd(prof.call_gex.idxmax()), "put_wall": rnd(prof.put_gex.idxmax()), "gamma_flip": rnd(flip), "net_gex": float(prof.net.sum()), "profile": prof.reset_index()} # --------------------------------------------- synthetic demo market (demo) def _grid25(x): return float(int(round(x / 25.0)) * 25) def _synth_chain(F, cw, pw, net_pos, rng): lo, hi = _grid25(F - 1200), _grid25(F + 1200) strikes = np.arange(lo, hi + 25, 25) m = (strikes - F) / F decay = np.exp(-((strikes - F) / 800.0) ** 2) call_oi = rng.lognormal(np.log(400), 0.7, len(strikes)) * decay * np.where(strikes > F, 1.15, 0.85) put_oi = rng.lognormal(np.log(400), 0.7, len(strikes)) * decay * np.where(strikes < F, 1.50, 0.80) ic, ip = int(np.argmin(abs(strikes - cw))), int(np.argmin(abs(strikes - pw))) call_oi[ic] += rng.uniform(6000, 11000) # OI concentrated at the walls put_oi[ip] += rng.uniform(6000, 11000) if net_pos: call_oi *= 1.30 # dealer-long-gamma day else: put_oi[strikes <= F - 100] *= 2.4; put_oi[ip] += 4000 # short-gamma day iv = np.clip(0.14 + 0.9 * np.clip(m, 0, None) + 2.2 * np.clip(-m, 0, None), 0.10, 1.2) return pd.concat([pd.DataFrame({"strike": strikes, "cp": "C", "oi": np.round(call_oi).astype(int), "iv": iv}), pd.DataFrame({"strike": strikes, "cp": "P", "oi": np.round(put_oi).astype(int), "iv": iv})], ignore_index=True) def _sim_day(d, open_px, lv, regime, rng, n_min=405, sub=3): cw, pw = lv["call_wall"], lv["put_wall"] if regime: theta, sigma, trend = 0.020, 6.0, 0.0 # mean-reverting, walls pin else: theta, sigma = 0.001, 8.0; trend = rng.choice([-1, 1]) * rng.uniform(60, 160) x, o, h, l, c, v = open_px, [], [], [], [], [] for i in range(n_min): mu = open_px + trend * (i / n_min) if regime: if x > cw - 12: mu = min(mu, cw - 20) # repulsion from walls if x < pw + 12: mu = max(mu, pw + 20) b_o, b_h, b_l = x, x, x for _ in range(sub): x += theta * (mu - x) + (sigma / sqrt(sub)) * rng.normal() b_h, b_l = max(b_h, x), min(b_l, x) o.append(b_o); h.append(b_h); l.append(b_l); c.append(x) v.append(int(rng.integers(150, 2500))) idx = pd.date_range(pd.Timestamp(d) + pd.Timedelta(hours=9, minutes=30), periods=n_min, freq="min") return pd.DataFrame({"open": o, "high": h, "low": l, "close": c, "volume": v}, index=idx) def synth_market(cfg): rng = np.random.default_rng(cfg.seed) dates = pd.bdate_range("2025-01-02", periods=cfg.n_days) prev_close = 20500.0 levels = compute_gamma_levels(_synth_chain(prev_close, _grid25(prev_close + 45), _grid25(prev_close - 35), True, rng), prev_close, cfg.dte_days, cfg.opt_mult, cfg.r) frames, lmap = [], {} for d in dates: lmap[d.date()] = levels regime = levels["net_gex"] > 0 # regime implied by the chain itself open_px = prev_close + rng.normal(0, 25) bd = _sim_day(d, open_px, levels, regime, rng) frames.append(bd) prev_close = float(bd["close"].iloc[-1]) tom_pos = rng.random() < 0.60 levels = compute_gamma_levels(_synth_chain(prev_close, _grid25(prev_close + rng.uniform(15, 55)), _grid25(prev_close - rng.uniform(15, 55)), tom_pos, rng), prev_close, cfg.dte_days, cfg.opt_mult, cfg.r) bars = pd.concat(frames); bars.index.name = "ts" return bars, lmap # ------------------------------------------------------------ backtest core def _lvl_ok(x): return x is not None and np.issubdtype(type(x), np.floating if False else (float, int, np.floating)) if False else (x is not None and np.isfinite(x)) def run_backtest(bars, levels_by_day, cfg): tick = TICK_SIZE buf, stop = cfg.entry_buffer_ticks * tick, cfg.stop_ticks * tick tp = cfg.tp_ticks * tick if cfg.tp_ticks else None trades, no_trade, skipped = [], 0, 0 for day, g in bars.groupby(bars.index.date, sort=True): lv = levels_by_day.get(day) if lv is None: continue if cfg.regime_filter and not (np.isfinite(lv.get("net_gex", np.nan)) and lv["net_gex"] > 0): skipped += 1; continue cw, pw = lv.get("call_wall"), lv.get("put_wall") if not (_lvl_ok(cw) or _lvl_ok(pw)): continue g = g.sort_index() tod = g.index.hour * 60 + g.index.minute win = g[(tod >= cfg.entry_from_min) & (tod <= cfg.flat_by_min)] if win.empty: continue touched, pos, n_tr = set(), None, 0 def record(pos, ts, px, reason): d, e = pos["d"], pos["entry"] net = d * (px - e) / tick - cfg.cost_ticks trades.append(dict(date=day, level=pos["level"], direction="SHORT" if d < 0 else "LONG", entry_time=pos["t_in"], exit_time=ts, entry=e, exit=px, reason=reason, mfe=pos["mfe"], mae=pos["mae"], ticks=net, dollars=net * TICK_VALUE, day_net_gex=lv.get("net_gex", np.nan))) for ts, bar in win.iterrows(): m = ts.hour * 60 + ts.minute if pos is None: if m <= cfg.last_entry_min and n_tr < cfg.max_trades_per_day: if _lvl_ok(cw) and "CW" not in touched and bar.high >= cw - buf: touched.add("CW") if (not cfg.require_rejection_close) or bar.close < cw: fill = min(cw - buf, bar.open) # gap-safe fill pos = dict(level="CallWall", d=-1, entry=fill, t_in=ts, mfe=0.0, mae=0.0) n_tr += 1 if bar.high >= fill + stop: # worst-case same-bar stop record(pos, ts, fill + stop, "stop"); pos = None elif _lvl_ok(pw) and "PW" not in touched and bar.low <= pw + buf: touched.add("PW") if (not cfg.require_rejection_close) or bar.close > pw: fill = max(pw + buf, bar.open) pos = dict(level="PutWall", d=+1, entry=fill, t_in=ts, mfe=0.0, mae=0.0) n_tr += 1 if bar.low <= fill - stop: record(pos, ts, fill - stop, "stop"); pos = None else: d, e = pos["d"], pos["entry"] if d < 0: pos["mfe"] = max(pos["mfe"], (e - bar.low) / tick) pos["mae"] = max(pos["mae"], (bar.high - e) / tick) if bar.high >= e + stop: record(pos, ts, e + stop, "stop"); pos = None elif tp is not None and bar.low <= e - tp: record(pos, ts, e - tp, "target"); pos = None else: pos["mfe"] = max(pos["mfe"], (bar.low - e) / tick) pos["mae"] = max(pos["mae"], (e - bar.low) / tick) if bar.low <= e - stop: record(pos, ts, e - stop, "stop"); pos = None elif tp is not None and bar.high >= e + tp: record(pos, ts, e + tp, "target"); pos = None if pos is not None and m >= cfg.flat_by_min: record(pos, ts, bar.close, "flat"); pos = None if pos is not None: record(pos, win.index[-1], float(win["close"].iloc[-1]), "eod") if n_tr == 0: no_trade += 1 return pd.DataFrame(trades), dict(days=len(set(bars.index.date)), days_no_trade=no_trade, days_skipped=skipped) # ----------------------------------------------------------------- stats def summarize(tr): if tr is None or tr.empty: return dict(n=0) w, l = tr[tr.ticks > 0], tr[tr.ticks <= 0] gw, gl = w.dollars.sum(), l.dollars.sum() return dict(n=len(tr), wins=len(w), losses=len(l), win_rate=len(w) / len(tr), avg_win=w.ticks.mean() if len(w) else 0.0, avg_loss=l.ticks.mean() if len(l) else 0.0, expectancy=tr.ticks.mean(), total=tr.dollars.sum(), pf=(gw / abs(gl)) if gl != 0 else float("inf"), best=tr.ticks.max(), worst=tr.ticks.min()) def daily_metrics(tr, all_days): daily = tr.groupby("date")["dollars"].sum().reindex(all_days, fill_value=0.0) eq, sd = daily.cumsum(), daily.std() dd = eq - eq.cummax() sharpe = float(daily.mean() / sd * sqrt(252)) if sd and sd > 0 else float("nan") return daily, eq, float(dd.min() if len(dd) else 0.0), sharpe def _block(df, key): rows = [] for k, g in df.groupby(key): s = summarize(g) rows.append([str(k), s["n"], f"{s['win_rate']:.0%}", f"{s['expectancy']:+.1f}", f"${s['total']:,.0f}", f"{s['pf']:.2f}"]) print(pd.DataFrame(rows, columns=[key, "trades", "win", "exp(t)", "net$", "PF"]).to_string(index=False)) def _fmt(m): return f"{m//60:02d}:{m%60:02d}" def print_stats(tr, meta, all_days, cfg): print("=" * 74) print("NQ GAMMA-LEVEL FADE — FIRST 2 HOURS — RESULTS") print("=" * 74) if cfg.synthetic: print(" >>> SYNTHETIC DEMO DATA — ILLUSTRATIVE ONLY, NOT REAL EDGE <<<") print(f" stop={cfg.stop_ticks}t ({cfg.stop_ticks*TICK_SIZE:.2f}pts, ${cfg.stop_ticks*TICK_VALUE:.0f})" f" | tp={('%dt' % cfg.tp_ticks) if cfg.tp_ticks else 'none'} | buf={cfg.entry_buffer_ticks}t" f" | cost={cfg.cost_ticks}t RT | entries {_fmt(cfg.entry_from_min)}-{_fmt(cfg.last_entry_min)}" f" | flat {_fmt(cfg.flat_by_min)}") print(f" days={meta['days']} | days no fade taken={meta['days_no_trade']}" f" | days skipped by regime filter={meta['days_skipped']}") if tr.empty: print("No trades."); return s = summarize(tr); daily, eq, maxdd, sharpe = daily_metrics(tr, all_days) streak = mx = 0 for t in tr.ticks: streak = streak + 1 if t <= 0 else 0 mx = max(mx, streak) print("-" * 74) print(f" trades : {s['n']} ({s['n']/max(meta['days'],1):.2f}/day)") print(f" win rate : {s['win_rate']:.1%} ({s['wins']}W / {s['losses']}L)") print(f" avg win / avg loss : {s['avg_win']:+.1f} / {s['avg_loss']:+.1f} ticks") print(f" expectancy : {s['expectancy']:+.2f} t (${s['expectancy']*TICK_VALUE:+,.0f}/trade)") print(f" profit factor : {s['pf']:.2f}") print(f" total net PnL : ${s['total']:,.0f}") print(f" max drawdown : ${maxdd:,.0f}") print(f" daily Sharpe (ann.) : {sharpe:.2f}") print(f" best / worst trade : {s['best']:+.0f} / {s['worst']:+.0f} ticks") print(f" max losing streak : {mx}") print(f" avg MFE / MAE : {tr.mfe.mean():.1f} / {tr.mae.mean():.1f} ticks") print("-" * 74 + "\n BY LEVEL") _block(tr, "level") print("\n BY DEALER-GAMMA REGIME (sign of net GEX that day)") _block(tr, np.where(tr.day_net_gex > 0, "net GEX > 0", "net GEX <= 0")) print("\n BY EXIT REASON") _block(tr, "reason") p = summarize(tr[tr.day_net_gex > 0]); n = summarize(tr[tr.day_net_gex <= 0]) print("-" * 74) print(f" If you ONLY faded on net-positive-gamma days: {p['n']} trades, " f"win {p['win_rate']:.0%}, net ${p['total']:,.0f}, PF {p['pf']:.2f}") print(f" (net-negative days alone: {n['n']} trades, win {n['win_rate']:.0%}, " f"net ${n['total']:,.0f}, PF {n['pf']:.2f}) -> try regime_filter=True") # ---------------------------------------------------------------- report def _bar_block(ax, groups, title): tot = [float(g["dollars"].sum()) for _, g in groups] ax.bar([str(k) for k, _ in groups], tot, color=[GREEN if t >= 0 else RED for t in tot]) for i, (k, g) in enumerate(groups): ax.text(i, tot[i], f"win {(g.ticks > 0).mean():.0%}\nn={len(g)}", ha="center", va="bottom" if tot[i] >= 0 else "top", fontsize=8) ax.axhline(0, color="k", lw=.6); ax.set_title(title, fontsize=10) def build_report(tr, levels_map, bars, cfg, save_path="nq_gamma_fade_report.png"): if tr is None or tr.empty: print("No trades — report skipped."); return None s = summarize(tr) all_days = sorted(set(bars.index.date)) daily, eq, maxdd, sharpe = daily_metrics(tr, all_days) fig = plt.figure(figsize=(18, 12), constrained_layout=True) tag = " [SYNTHETIC DEMO]" if cfg.synthetic else "" fig.suptitle(f"NQ futures — fade of OI gamma walls, 09:30–11:30 ET, {cfg.stop_ticks}-tick stop{tag}" f" — {s['n']} trades | win {s['win_rate']:.0%} | PF {s['pf']:.2f} | " f"net ${s['total']:,.0f} | maxDD ${-maxdd:,.0f}", fontsize=14, fontweight="bold") gs = fig.add_gridspec(3, 3) # 1 equity ax = fig.add_subplot(gs[0, 0]); x = pd.to_datetime(tr.exit_time); y = tr.dollars.cumsum().values ax.plot(x, y, color=BLUE, lw=1.6); ax.fill_between(x, y, 0, color=BLUE, alpha=.1) ax.axhline(0, color="k", lw=.7); ax.set_title("1 · Cumulative PnL ($, 1 contract)", fontsize=10) # 2 drawdown ax = fig.add_subplot(gs[0, 1]); dd = eq - eq.cummax() ax.fill_between(pd.to_datetime(dd.index), dd.values, 0, color=RED, alpha=.6) ax.set_title("2 · Drawdown ($)", fontsize=10) # 3 daily pnl ax = fig.add_subplot(gs[0, 2]) ax.bar(pd.to_datetime(daily.index), daily.values, width=1.0, color=[GREEN if v >= 0 else RED for v in daily.values]); ax.axhline(0, color="k", lw=.6) ax.set_title("3 · Daily PnL ($)", fontsize=10) # 4 distribution ax = fig.add_subplot(gs[1, 0]) w, l = tr.loc[tr.ticks > 0, "ticks"], tr.loc[tr.ticks <= 0, "ticks"] ax.hist(w, bins=40, color=GREEN, alpha=.85, label=f"wins ({len(w)})") ax.hist(l, bins=40, color=RED, alpha=.85, label=f"losses ({len(l)})") ax.axvline(tr.ticks.mean(), color="k", ls="--", label=f"mean {tr.ticks.mean():+.1f}t") ax.legend(fontsize=8); ax.set_xlabel("ticks (stop = -50t)") ax.set_title("4 · Trade PnL distribution", fontsize=10) # 5 by level ax = fig.add_subplot(gs[1, 1]); _bar_block(ax, list(tr.groupby("level")), "5 · PnL by level type") # 6 entry time ax = fig.add_subplot(gs[1, 2]) mins = (tr.entry_time.dt.hour * 60 + tr.entry_time.dt.minute) - cfg.entry_from_min wm = tr.ticks > 0 ax.scatter(mins[wm], tr.ticks[wm], s=22, c=GREEN); ax.scatter(mins[~wm], tr.ticks[~wm], s=22, c=RED) mids, means = [], [] for a, b in zip(range(0, 91, 15), range(15, 106, 15)): msk = (mins >= a) & (mins < b) mids.append(a + 7); means.append(tr.ticks[msk].mean() if msk.any() else np.nan) ax.plot(mids, means, "k-o", ms=4, label="15-min mean") ax.axhline(0, color="k", lw=.6); ax.legend(fontsize=8) ax.set_xlabel("minutes since 09:30"); ax.set_ylabel("ticks") ax.set_title("6 · PnL vs entry time", fontsize=10) # 7 by regime ax = fig.add_subplot(gs[2, 0]) _bar_block(ax, list(tr.groupby(np.where(tr.day_net_gex > 0, "net GEX > 0", "net GEX <= 0"))), "7 · PnL by dealer-gamma regime") # 8 sample day sample = tr.groupby("date").size().sort_values(ascending=False).index[0] db = bars[bars.index.date == sample] tod = db.index.hour * 60 + db.index.minute show = db[tod <= 13 * 60 + 30] lv = levels_map.get(sample, {}) ax = fig.add_subplot(gs[2, 1]) ax.plot(show.index, show.close, color="k", lw=1) ax.fill_between(show.index, show.low, show.high, color="#9db4c0", alpha=.45, label="1-min H/L") for lvl, cl, ls, lab in ((lv.get("call_wall"), RED, "--", "call wall"), (lv.get("put_wall"), GREEN, "--", "put wall"), (lv.get("gamma_flip"), "#888", ":", "gamma flip")): if _lvl_ok(lvl): ax.axhline(lvl, color=cl, ls=ls, lw=1.2, label=f"{lab} {lvl:,.0f}") ax.axvspan(pd.Timestamp(f"{sample} 09:30"), pd.Timestamp(f"{sample} 11:30"), color="#f4c430", alpha=.15, label="fade window") for _, t in tr[tr.date == sample].iterrows(): col = RED if t.direction == "SHORT" else GREEN ax.scatter(t.entry_time, t.entry, marker="v" if t.direction == "SHORT" else "^", s=130, c=col, zorder=5) ax.scatter(t.exit_time, t.exit, marker="x", s=90, c="k", zorder=5) ax.annotate(f"{t.ticks:+.0f}t", (t.exit_time, t.exit), xytext=(0, 10), textcoords="offset points", fontsize=8, ha="center") ax.legend(fontsize=7); ax.xaxis.set_major_formatter(mdates.DateFormatter("%H:%M")) ax.set_title(f"8 · Sample day {sample}", fontsize=10) # 9 gamma profile ax = fig.add_subplot(gs[2, 2]); prof = lv.get("profile") if prof is None or prof.empty: ax.text(.5, .5, "no chain profile for this day", ha="center", va="center"); ax.set_axis_off() else: ax.bar(prof.strike, prof.call_gex / 1e9, color=GREEN, alpha=.85, label="call GEX") ax.bar(prof.strike, -prof.put_gex / 1e9, color=RED, alpha=.85, label="put GEX (-)") for lvl, cl, ls in ((lv.get("call_wall"), RED, "--"), (lv.get("put_wall"), GREEN, "--"), (lv.get("gamma_flip"), "#888", ":")): if _lvl_ok(lvl): ax.axvline(lvl, color=cl, ls=ls, lw=1.1) ax.axvline(float(show["open"].iloc[0]), color=BLUE, lw=1, label="day open") ax.legend(fontsize=7); ax.set_ylabel("$ GEX per 1% (bn)") ax.set_title("9 · Gamma profile (prior-settle OI)", fontsize=10) ax.tick_params(axis="x", rotation=45) fig.savefig(save_path, dpi=140); print(f"\nreport saved -> {save_path}") return fig # ------------------------------------------------------- real-data loaders def load_futures_csv(path): """1-min NQ bars, America/New_York. CSV: ts, open, high, low, close, volume.""" df = pd.read_csv(path, parse_dates=["ts"]).set_index("ts").sort_index() return df[["open", "high", "low", "close", "volume"]] def load_levels_csv(path, basis=0.0): """Vendor gamma levels. CSV: date, call_wall, put_wall, [gamma_flip, net_gex]. basis = futures - index (shifts levels onto the futures price).""" df = pd.read_csv(path, parse_dates=["date"]); out = {} for _, r in df.iterrows(): g = lambda k: (float(r[k]) + basis) if k in r and r[k] == r[k] else None out[r["date"].date()] = {"call_wall": g("call_wall"), "put_wall": g("put_wall"), "gamma_flip": g("gamma_flip"), "net_gex": float(r["net_gex"]) if "net_gex" in r and r["net_gex"] == r["net_gex"] else np.nan, "profile": None} return out def load_chain_csv(path): """Prior-evening OI snapshots. CSV: settle_date, strike, cp('C'/'P'), oi, [iv].""" return pd.read_csv(path, parse_dates=["settle_date"]) def build_levels_from_chains(chains, bars, cfg, basis=0.0): """Each evening's OI snapshot -> next session's gamma levels.""" closes = bars["close"].groupby(bars.index.date).last(); all_days = sorted(closes.index); out = {} for sd, grp in chains.groupby("settle_date"): sdd = sd.date() if isinstance(sd, pd.Timestamp) else sd nxt = [d for d in all_days if d > sdd] if sdd not in closes.index or not nxt: continue lv = compute_gamma_levels(grp, float(closes.loc[sdd]), cfg.dte_days, cfg.opt_mult, cfg.r) if lv is None: continue if basis: for k in ("call_wall", "put_wall", "gamma_flip"): if lv.get(k) is not None: lv[k] += basis out[nxt[0]] = lv return out # ------------------------------------------------------------------- main def main(): cfg = Config() if cfg.synthetic: print("[demo] generating synthetic market + OI chains ...") bars, levels_map = synth_market(cfg) else: bars = load_futures_csv("nq_1min.csv") # <- your real bars levels_map = load_levels_csv("gamma_levels.csv", basis=0.0) # <- vendor levels # or from raw OI: levels_map = build_levels_from_chains(load_chain_csv("ndx_oi.csv"), bars, cfg) tr, meta = run_backtest(bars, levels_map, cfg) print_stats(tr, meta, sorted(set(bars.index.date)), cfg) fig = build_report(tr, levels_map, bars, cfg) if fig is not None: plt.show() if __name__ == "__main__": main() ``` ## What the 9-panel report shows 1. **Cumulative PnL** (closed trades, 1 contract) · 2. **Drawdown** · 3. **Daily PnL** bars · 4. **Trade distribution in ticks** (note the −50t stop cluster) · 5. **PnL split Call-Wall shorts vs Put-Wall longs** · 6. **PnL vs entry time** (does the 10:00–11:00 fade work as well as 09:30–10:00?) · 7. **PnL on net-positive vs net-negative dealer-gamma days** — usually the money panel: walls tend to *hold* in positive gamma and *break* in negative gamma · 8. **A sample day** with the walls, the shaded 2-hour window, and every entry/exit marked · 9. **The gamma profile** (call/put GEX by strike) that produced those walls. ## Running it on real data - **Bars:** 1-min NQ (continuous or front month), ET timezone — Databento (`GLBX.MDP3`), CME DataMine, IQFeed, etc. → `load_futures_csv()`. - **Gamma levels, two options:** - Vendor levels (SpotGamma, Menthor Q, GammaEdge, etc.) → `load_levels_csv()` with columns `date, call_wall, put_wall, gamma_flip, net_gex`. If the levels are NDX-based, set `basis` = futures−index premium (often 30–80+ pts depending on rates/divs) — this matters. - Raw OI chains (NDX via OPRA/Polygon/Tradier with `opt_mult=100`, or CME options-on-NQ-futures with `opt_mult=20`, which avoids the basis problem) → `load_chain_csv()` + `build_levels_from_chains()`. ## Assumptions & caveats - **OI updates once nightly** — levels are static all session (standard practice; CME OI is settlement-based). - Net-GEX sign convention (call+ / put−) is an assumption about dealer positioning; validate walls/flip against your vendor once. - Fills are at the trigger price; same-bar entry+stop resolved worst-case; `cost_ticks` (default 1t = $5 RT) models slippage/fees — raise it for realism. - One attempt per wall per day, one position at a time, no compounding — deliberately simple so results are interpretable. - **The default run is synthetic.** It demonstrates the pipeline (and typically shows the regime split in panel 7), but it is not evidence of real edge. ## Easy extensions - `Config(regime_filter=True)` — only fade on net-positive-gamma days (the panel-7 test usually justifies this). - `Config(tp_ticks=100)` — 2:1 take-profit vs the 50t stop. - Fade/breakout module at the **gamma flip** (currently charted only), vol-scaled stops, gamma-weighted position sizing, or re-computing levels from intraday-updated OI at 11:30 for an afternoon session — `compute_gamma_levels()` accepts any snapshot.

Test