""" Step 4: Backtest core — single combo → PnL. Tests one parameter combination against cached kline data. Usage: import pickle from backtest_core import run_backtest with open("data_cache_7d.pkl", "rb") as f: cache = pickle.load(f) params = { "z_entry": 2.0, "z_max": 3.5, "natr_min": 0.75, "natr_max": 2.5, "chop_min": 50, "tp_pct": 2.0, "sl_pct": 1.0, } result = run_backtest(cache["symbols"], params) # result = {"trades": 42, "wins": 28, "losses": 14, "pnl": 12.5, "wr": 66.7, "pf": 2.1} """ import numpy as np def run_backtest(symbols_data: dict, params: dict) -> dict: """ Run backtest for ONE parameter combination across all symbols. Entry logic (per bar): - |Z| > z_entry AND |Z| < z_max - NATR >= natr_min AND NATR <= natr_max - CHOP >= chop_min - Z < 0 → LONG, Z > 0 → SHORT Exit: TP% or SL% from entry price (whichever hits first on subsequent bars). Uses HIGH/LOW of each bar to check SL/TP (realistic: intra-bar wicks). Returns dict with trade stats. """ z_entry = params["z_entry"] z_max = params["z_max"] natr_min = params["natr_min"] natr_max = params["natr_max"] chop_min = params["chop_min"] tp_pct = params["tp_pct"] sl_pct = params["sl_pct"] total_wins = 0 total_losses = 0 total_pnl = 0.0 gross_win = 0.0 gross_loss = 0.0 all_trades = [] for sym, d in symbols_data.items(): z = d["z"] natr = d["natr"] chop = d["chop"] c = d["c"] h = d["h"] l = d["l"] n = len(c) i = 0 while i < n - 1: # Check entry conditions at bar i zi = z[i] ni = natr[i] ci_chop = chop[i] if abs(zi) <= z_entry or abs(zi) >= z_max: i += 1 continue if ni < natr_min or ni > natr_max: i += 1 continue if ci_chop < chop_min: i += 1 continue # Determine side if zi < 0: side = "LONG" else: side = "SHORT" entry_price = c[i] if entry_price <= 0: i += 1 continue # Calculate TP/SL prices if side == "LONG": tp_price = entry_price * (1 + tp_pct / 100) sl_price = entry_price * (1 - sl_pct / 100) else: tp_price = entry_price * (1 - tp_pct / 100) sl_price = entry_price * (1 + sl_pct / 100) # Scan forward for exit exit_pnl = None exit_bar = i + 1 for j in range(i + 1, n): if side == "LONG": # Check SL first (worst case — wick hits both) if l[j] <= sl_price: exit_pnl = -sl_pct exit_bar = j break if h[j] >= tp_price: exit_pnl = tp_pct exit_bar = j break else: # SHORT if h[j] >= sl_price: exit_pnl = -sl_pct exit_bar = j break if l[j] <= tp_price: exit_pnl = tp_pct exit_bar = j break if exit_pnl is None: # No exit found — trade still open at end of data, skip break # Record trade if exit_pnl > 0: total_wins += 1 gross_win += exit_pnl else: total_losses += 1 gross_loss += abs(exit_pnl) total_pnl += exit_pnl # Cooldown: skip 6 bars (30 min on 5m) after exit to avoid re-entry i = exit_bar + 6 continue # end while for this symbol total_trades = total_wins + total_losses wr = (total_wins / total_trades * 100) if total_trades > 0 else 0 pf = (gross_win / gross_loss) if gross_loss > 0 else (999 if gross_win > 0 else 0) return { "trades": total_trades, "wins": total_wins, "losses": total_losses, "pnl": round(total_pnl, 2), "wr": round(wr, 1), "pf": round(pf, 2), "gross_win": round(gross_win, 2), "gross_loss": round(gross_loss, 2), }