Community Scripts

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 02:01:39
# Model            : Gradient Boosting
# Feature Eng.     : BB (20,2.0), ATR 14 + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/USDJPY_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # ── Bollinger Bands (period=20, std_dev=2.0) ──────────────────────────────
    bb_period = 20
    bb_std    = 2.0

    bb_mid   = close.rolling(bb_period).mean()
    bb_sigma = close.rolling(bb_period).std(ddof=0)
    bb_upper = bb_mid + bb_std * bb_sigma
    bb_lower = bb_mid - bb_std * bb_sigma

    df["bb_mid"]   = bb_mid
    df["bb_upper"] = bb_upper
    df["bb_lower"] = bb_lower

    # bb_width: normalised band width (volatility proxy)
    df["bb_width"] = (bb_upper - bb_lower) / bb_mid

    # bb_pct: position of close within the band [0, 1]
    band_range = bb_upper - bb_lower
    df["bb_pct"] = (close - bb_lower) / band_range

    # Distance from close to mid in units of band width
    df["bb_dist_mid"] = (close - bb_mid) / bb_mid

    # ── ATR (period=14) ───────────────────────────────────────────────────────
    atr_period = 14
    prev_close = close.shift(1)
    tr = pd.concat([
        high - low,
        (high - prev_close).abs(),
        (low  - prev_close).abs()
    ], axis=1).max(axis=1)

    atr  = tr.ewm(span=atr_period, min_periods=atr_period, adjust=False).mean()
    natr = atr / close

    df["atr"]  = atr
    df["natr"] = natr

    # ── Momentum / trend features ─────────────────────────────────────────────
    # Rate of change at multiple horizons
    for n in [1, 4, 8, 16]:
        df[f"roc_{n}"] = close.pct_change(n)

    # RSI (14)
    rsi_period = 14
    delta  = close.diff()
    gain   = delta.clip(lower=0)
    loss   = (-delta).clip(lower=0)
    avg_gain = gain.ewm(span=rsi_period, min_periods=rsi_period, adjust=False).mean()
    avg_loss = loss.ewm(span=rsi_period, min_periods=rsi_period, adjust=False).mean()
    rs  = avg_gain / (avg_loss + 1e-10)
    rsi = 100 - (100 / (1 + rs))
    df["rsi_14"] = rsi

    # RSI derived: distance from 50 (centred, normalised)
    df["rsi_dev"] = (rsi - 50) / 50

    # ── MACD (12, 26, 9) ──────────────────────────────────────────────────────
    ema12 = close.ewm(span=12, adjust=False).mean()
    ema26 = close.ewm(span=26, adjust=False).mean()
    macd_line   = ema12 - ema26
    macd_signal = macd_line.ewm(span=9, adjust=False).mean()
    macd_hist   = macd_line - macd_signal

    df["macd_line"]   = macd_line
    df["macd_signal"] = macd_signal
    df["macd_hist"]   = macd_hist

    # ── Trend (SMA 50) ────────────────────────────────────────────────────────
    sma50 = close.rolling(50).mean()
    df["sma_50"]        = sma50
    df["close_vs_sma50"] = (close - sma50) / sma50   # normalised distance

    # ── Volume / candle structure features ────────────────────────────────────
    body      = (close - open_).abs()
    candle_rng = high - low
    df["body_ratio"]  = body / (candle_rng + 1e-10)   # body as fraction of range
    df["upper_wick"]  = (high  - pd.concat([close, open_], axis=1).max(axis=1)) / (candle_rng + 1e-10)
    df["lower_wick"]  = (pd.concat([close, open_], axis=1).min(axis=1) - low)   / (candle_rng + 1e-10)
    df["candle_dir"]  = np.where(close > open_, 1.0, -1.0)  # bullish / bearish bar

    # ── Lagged bb_pct & rsi (to give the model recent history) ───────────────
    for lag in [1, 2, 3]:
        df[f"bb_pct_lag{lag}"] = df["bb_pct"].shift(lag)
        df[f"rsi_lag{lag}"]    = df["rsi_14"].shift(lag)
        df[f"macd_hist_lag{lag}"] = df["macd_hist"].shift(lag)

    # ── Volatility regime flag ────────────────────────────────────────────────
    natr_ma = natr.rolling(50).mean()
    df["vol_regime"] = np.where(natr > natr_ma, 1.0, 0.0)   # 1 = high-vol regime

    # ── BB squeeze detection ──────────────────────────────────────────────────
    bb_width_ma = df["bb_width"].rolling(50).mean()
    df["bb_squeeze"] = np.where(df["bb_width"] < bb_width_ma, 1.0, 0.0)

    # ── Mean-reversion signal strength ────────────────────────────────────────
    # Positive → oversold (close below lower band), Negative → overbought
    df["mr_signal"] = 0.5 - df["bb_pct"]   # centred: +0.5 at lower band, -0.5 at upper

    # ── Fill NaN from warm-up ─────────────────────────────────────────────────
    df = df.bfill().ffill()

    return df

# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "USD/JPY BB Mean-Reversion + ATR Gradient Boost",
        "model_type":       "GradientBoostingClassifier",
        "model_params":     {
            "n_estimators":      500,
            "max_depth":         4,
            "learning_rate":     0.03,
            "subsample":         0.8,
            "min_samples_leaf":  20,
            "max_features":      "sqrt",
            "validation_fraction": 0.1,
            "n_iter_no_change":  30,
            "tol":               1e-4,
            "random_state":      42,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   None,
        "min_atr":          None,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective": (
            "Maximise Sharpe ratio via a Gradient Boosting classifier trained on "
            "Bollinger Band position (bb_pct), normalised bandwidth (bb_width), "
            "ATR/NATR, RSI, MACD histogram, candle structure, and lagged features. "
            "GBM chosen for its ability to capture non-linear interactions between "
            "volatility (ATR) and mean-reversion (BB) signals. n_iter_no_change "
            "acts as early stopping to prevent overfitting on the 15-min USDJPY series. "
            "SL=0.5% / TP=1.0% gives a 1:2 risk-reward; threshold=0.55 reduces noise trades."
        ),
        "notes": (
            "Bollinger Bands are the primary mean-reversion anchor; ATR/NATR filter "
            "entries to adequate volatility bars. RSI and MACD provide momentum context "
            "to avoid fading strong trends. Lagged features (up to 3 bars) give the model "
            "short-term regime memory without look-ahead. vol_regime and bb_squeeze flags "
            "allow the model to differentiate trending vs. ranging conditions automatically. "
            "No session filter applied — USDJPY is liquid across Asian and European sessions."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 02:56:13
# Model            : XGBoost
# Feature Eng.     : SMA (20,50,200) + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/EURUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # ── SMA core features (required) ──────────────────────────────────────
    for period in [20, 50, 200]:
        sma = close.rolling(period).mean()
        df[f"sma_{period}"]    = sma
        df[f"dm_sma_{period}"] = (close - sma) / sma

    # ── SMA slope (momentum of the moving average itself) ─────────────────
    for period in [20, 50, 200]:
        df[f"sma_{period}_slope"] = df[f"sma_{period}"].diff(5) / df[f"sma_{period}"].shift(5)

    # ── SMA crossover signals ─────────────────────────────────────────────
    df["sma_20_50_cross"]  = df["sma_20"] - df["sma_50"]
    df["sma_50_200_cross"] = df["sma_50"] - df["sma_200"]
    df["sma_20_200_cross"] = df["sma_20"] - df["sma_200"]

    # ── Price vs SMA alignment score (how many SMAs price is above) ───────
    above_20  = np.where(close > df["sma_20"],  1, -1)
    above_50  = np.where(close > df["sma_50"],  1, -1)
    above_200 = np.where(close > df["sma_200"], 1, -1)
    df["sma_alignment"] = (above_20 + above_50 + above_200).astype(float)

    # ── Returns at multiple horizons ──────────────────────────────────────
    for lag in [1, 2, 4, 8, 16]:
        df[f"ret_{lag}"] = close.pct_change(lag)

    # ── Log returns ───────────────────────────────────────────────────────
    df["log_ret_1"] = np.log(close / close.shift(1))
    df["log_ret_4"] = np.log(close / close.shift(4))

    # ── ATR (14-period) ───────────────────────────────────────────────────
    tr1 = high - low
    tr2 = (high - close.shift(1)).abs()
    tr3 = (low  - close.shift(1)).abs()
    true_range = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
    atr_14 = true_range.rolling(14).mean()
    df["atr_14"]  = atr_14
    df["natr_14"] = atr_14 / close

    # ── ATR ratio (current TR vs average — volatility burst) ──────────────
    df["atr_ratio"] = true_range / atr_14

    # ── Bollinger Bands (20, 2) ───────────────────────────────────────────
    bb_mid  = close.rolling(20).mean()
    bb_std  = close.rolling(20).std()
    bb_upper = bb_mid + 2.0 * bb_std
    bb_lower = bb_mid - 2.0 * bb_std
    bb_width = (bb_upper - bb_lower) / bb_mid
    df["bb_pct_b"]  = (close - bb_lower) / (bb_upper - bb_lower + 1e-12)
    df["bb_width"]  = bb_width
    df["bb_zscore"] = (close - bb_mid) / (bb_std + 1e-12)

    # ── RSI (14) ──────────────────────────────────────────────────────────
    delta  = close.diff()
    gain   = delta.clip(lower=0).rolling(14).mean()
    loss   = (-delta.clip(upper=0)).rolling(14).mean()
    rs     = gain / (loss + 1e-12)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # ── RSI momentum ─────────────────────────────────────────────────────
    df["rsi_14_diff"] = df["rsi_14"].diff(2)

    # ── MACD (12, 26, 9) ─────────────────────────────────────────────────
    ema12      = close.ewm(span=12, adjust=False).mean()
    ema26      = close.ewm(span=26, adjust=False).mean()
    macd_line  = ema12 - ema26
    signal_line = macd_line.ewm(span=9, adjust=False).mean()
    df["macd_line"]   = macd_line
    df["macd_signal"] = signal_line
    df["macd_hist"]   = macd_line - signal_line
    df["macd_hist_diff"] = df["macd_hist"].diff(1)

    # ── Stochastic %K / %D (14, 3) ───────────────────────────────────────
    low_14  = low.rolling(14).min()
    high_14 = high.rolling(14).max()
    stoch_k = 100 * (close - low_14) / (high_14 - low_14 + 1e-12)
    stoch_d = stoch_k.rolling(3).mean()
    df["stoch_k"] = stoch_k
    df["stoch_d"] = stoch_d
    df["stoch_kd_diff"] = stoch_k - stoch_d

    # ── Williams %R (14) ─────────────────────────────────────────────────
    df["williams_r"] = -100 * (high_14 - close) / (high_14 - low_14 + 1e-12)

    # ── CCI (20) ─────────────────────────────────────────────────────────
    typical_price = (high + low + close) / 3
    tp_sma  = typical_price.rolling(20).mean()
    tp_mad  = typical_price.rolling(20).apply(lambda x: np.mean(np.abs(x - x.mean())), raw=True)
    df["cci_20"] = (typical_price - tp_sma) / (0.015 * tp_mad + 1e-12)

    # ── Rate of Change (10) ───────────────────────────────────────────────
    df["roc_10"] = (close - close.shift(10)) / (close.shift(10) + 1e-12) * 100

    # ── Volume / candle-body features (no volume data assumed) ────────────
    df["body_size"]   = (close - open_).abs() / (high - low + 1e-12)
    df["upper_wick"]  = (high - np.maximum(close, open_)) / (high - low + 1e-12)
    df["lower_wick"]  = (np.minimum(close, open_) - low)  / (high - low + 1e-12)
    df["is_bullish"]  = np.where(close > open_, 1.0, 0.0)

    # ── Rolling volatility (realised) ────────────────────────────────────
    df["vol_8"]  = df["log_ret_1"].rolling(8).std()
    df["vol_20"] = df["log_ret_1"].rolling(20).std()
    df["vol_ratio"] = df["vol_8"] / (df["vol_20"] + 1e-12)

    # ── High-low range relative to SMA ───────────────────────────────────
    df["hl_range_sma20"] = (high - low) / (df["sma_20"] + 1e-12)

    # ── Price position within recent n-bar range ──────────────────────────
    for n in [8, 20]:
        roll_low  = low.rolling(n).min()
        roll_high = high.rolling(n).max()
        df[f"price_pos_{n}"] = (close - roll_low) / (roll_high - roll_low + 1e-12)

    # ── Lagged returns as autoregressive features ─────────────────────────
    for lag in [1, 2, 3, 4, 8]:
        df[f"lag_ret_{lag}"] = df["ret_1"].shift(lag)

    # ── Distance from 20-bar high/low ────────────────────────────────────
    df["dist_high_20"] = (high.rolling(20).max() - close) / (close + 1e-12)
    df["dist_low_20"]  = (close - low.rolling(20).min())  / (close + 1e-12)

    # ── Fill NaN from warm-up ─────────────────────────────────────────────
    df = df.bfill().ffill()

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "EUR/USD SMA Trend + Multi-Indicator XGBoost",
        "model_type":       "XGBClassifier",
        "model_params":     {
            "n_estimators":     500,
            "max_depth":        4,
            "learning_rate":    0.03,
            "subsample":        0.8,
            "colsample_bytree": 0.7,
            "min_child_weight": 3,
            "gamma":            0.1,
            "reg_alpha":        0.05,
            "reg_lambda":       1.0,
            "objective":        "binary:logistic",
            "random_state":     42,
            "n_jobs":           -1,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [6, 18],
        "min_atr":          None,
        "trend_filter":     "sma_200",
        "target_horizon":   4,
        "objective":        (
            "Maximize risk-adjusted return (Sharpe/Calmar) on EUR/USD 15-min data. "
            "SMA triple-stack (20/50/200) provides trend context; supplementary "
            "momentum (RSI, MACD, Stochastic), volatility (ATR, BB), and "
            "mean-reversion (CCI, Williams %R) features give the XGBoost model a "
            "rich multi-regime signal set. XGBoost chosen for its ability to rank "
            "feature importance and handle non-linear interactions. Shallow trees "
            "(max_depth=4) with high n_estimators and low learning_rate reduce "
            "overfitting. 2:1 reward:risk (SL 0.5% / TP 1.0%) ensures positive "
            "expectancy even at moderate win rates. Session filter 06-18 UTC "
            "concentrates trades in liquid London/NY overlap."
        ),
        "notes":            (
            "trend_filter=sma_200 aligns trades with the dominant trend — longs "
            "only above the 200-SMA, shorts only below — acting as a regime gate "
            "to suppress counter-trend noise. signal_threshold=0.55 slightly above "
            "0.50 to reduce false positives without starving signal count. "
            "colsample_bytree=0.7 introduces randomisation across features to "
            "decorrelate trees and improve generalisation on forex data."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 01:54:56
# Model            : Gradient Boosting
# Feature Eng.     : BB (20,2.0), RSI 14, Stochastic (14,3) + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/NZDUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # ── Bollinger Bands (20, 2) ──────────────────────────────────────────────
    bb_period = 20
    bb_std    = 2.0
    bb_mid    = close.rolling(bb_period).mean()
    bb_std_   = close.rolling(bb_period).std(ddof=0)
    bb_upper  = bb_mid + bb_std * bb_std_
    bb_lower  = bb_mid - bb_std * bb_std_

    df["bb_mid"]   = bb_mid
    df["bb_upper"] = bb_upper
    df["bb_lower"] = bb_lower
    df["bb_width"] = (bb_upper - bb_lower) / bb_mid
    df["bb_pct"]   = (close - bb_lower) / (bb_upper - bb_lower)

    # ── RSI (14) ─────────────────────────────────────────────────────────────
    rsi_period = 14
    delta      = close.diff()
    gain       = delta.clip(lower=0)
    loss       = -delta.clip(upper=0)
    avg_gain   = gain.ewm(com=rsi_period - 1, min_periods=rsi_period).mean()
    avg_loss   = loss.ewm(com=rsi_period - 1, min_periods=rsi_period).mean()
    rs         = avg_gain / avg_loss.replace(0, np.nan)
    df["rsi"]  = 100 - (100 / (1 + rs))

    # ── Stochastic Oscillator (K=14, D=3) ────────────────────────────────────
    stoch_k_period = 14
    stoch_d_period = 3
    lowest_low   = low.rolling(stoch_k_period).min()
    highest_high = high.rolling(stoch_k_period).max()
    stoch_range  = (highest_high - lowest_low).replace(0, np.nan)
    df["stoch_k"] = 100 * (close - lowest_low) / stoch_range
    df["stoch_d"] = df["stoch_k"].rolling(stoch_d_period).mean()
    df["stoch_kd_diff"] = df["stoch_k"] - df["stoch_d"]

    # ── ATR (14) — for normalised volatility / min_atr filter ────────────────
    atr_period = 14
    tr = pd.concat([
        high - low,
        (high - close.shift(1)).abs(),
        (low  - close.shift(1)).abs()
    ], axis=1).max(axis=1)
    atr = tr.ewm(com=atr_period - 1, min_periods=atr_period).mean()
    df["atr"]  = atr
    df["natr"] = atr / close          # normalised ATR used by min_atr filter

    # ── Price momentum / rate-of-change ──────────────────────────────────────
    df["roc_4"]  = close.pct_change(4)    # 1-hour momentum on 15-min bars
    df["roc_8"]  = close.pct_change(8)    # 2-hour momentum
    df["roc_16"] = close.pct_change(16)   # 4-hour momentum

    # ── EMA trend context ─────────────────────────────────────────────────────
    df["ema_20"]  = close.ewm(span=20,  adjust=False).mean()
    df["ema_50"]  = close.ewm(span=50,  adjust=False).mean()
    df["ema_100"] = close.ewm(span=100, adjust=False).mean()
    df["sma_50"]  = close.rolling(50).mean()   # used by trend_filter

    df["ema_cross_20_50"]  = df["ema_20"]  - df["ema_50"]
    df["ema_cross_50_100"] = df["ema_50"]  - df["ema_100"]
    df["close_vs_ema20"]   = (close - df["ema_20"]) / df["ema_20"]

    # ── Candlestick body / wick features ─────────────────────────────────────
    df["body"]       = (close - open_).abs()
    df["candle_dir"] = np.where(close >= open_, 1.0, -1.0)
    df["upper_wick"] = high - pd.concat([close, open_], axis=1).max(axis=1)
    df["lower_wick"] = pd.concat([close, open_], axis=1).min(axis=1) - low
    df["body_ratio"] = df["body"] / (high - low).replace(0, np.nan)

    # ── Volume-proxy: realised range rolling stats ────────────────────────────
    df["hl_range"]      = high - low
    df["hl_range_ma8"]  = df["hl_range"].rolling(8).mean()
    df["hl_range_ratio"]= df["hl_range"] / df["hl_range_ma8"]

    # ── RSI derived signals ───────────────────────────────────────────────────
    df["rsi_overbought"]  = np.where(df["rsi"] > 70, 1.0, 0.0)
    df["rsi_oversold"]    = np.where(df["rsi"] < 30, 1.0, 0.0)
    df["rsi_momentum"]    = df["rsi"].diff(4)

    # ── Stochastic derived signals ────────────────────────────────────────────
    df["stoch_overbought"] = np.where(df["stoch_k"] > 80, 1.0, 0.0)
    df["stoch_oversold"]   = np.where(df["stoch_k"] < 20, 1.0, 0.0)

    # ── BB squeeze: width vs rolling mean of width ────────────────────────────
    df["bb_width_ma20"]  = df["bb_width"].rolling(20).mean()
    df["bb_squeeze"]     = np.where(df["bb_width"] < df["bb_width_ma20"], 1.0, 0.0)

    # ── Interaction features ──────────────────────────────────────────────────
    df["rsi_bb_pct"]      = df["rsi"] * df["bb_pct"]
    df["stoch_k_bb_pct"]  = df["stoch_k"] * df["bb_pct"]
    df["rsi_stoch_diff"]  = df["rsi"] - df["stoch_k"]

    # ── Lagged features (avoids look-ahead) ──────────────────────────────────
    for lag in [1, 2, 3, 4]:
        df[f"rsi_lag{lag}"]     = df["rsi"].shift(lag)
        df[f"stoch_k_lag{lag}"] = df["stoch_k"].shift(lag)
        df[f"bb_pct_lag{lag}"]  = df["bb_pct"].shift(lag)
        df[f"roc4_lag{lag}"]    = df["roc_4"].shift(lag)

    # ── Fill NaN from warm-up ─────────────────────────────────────────────────
    df = df.bfill().ffill()
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "NZD/USD Stoch+BB+RSI Gradient Boosting Mean-Revert",
        "model_type":       "GradientBoostingClassifier",
        "model_params":     {
            "n_estimators":     400,
            "max_depth":        4,
            "learning_rate":    0.04,
            "subsample":        0.8,
            "min_samples_leaf": 20,
            "max_features":     "sqrt",
            "validation_fraction": 0.1,
            "n_iter_no_change": 30,
            "tol":              1e-4,
            "random_state":     42,
        },
        "signal_threshold": 0.56,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [7, 20],
        "min_atr":          0.0002,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective": (
            "Maximise risk-adjusted return (Sharpe / Calmar) on NZD/USD 15-min. "
            "GradientBoostingClassifier selected for its strong generalisation on "
            "structured tabular data with noisy financial features. n_estimators=400 "
            "with early stopping (n_iter_no_change=30) prevents overfitting. "
            "max_depth=4 keeps trees shallow to reduce variance. subsample=0.8 + "
            "max_features=sqrt add stochasticity for robustness. SL 0.5% / TP 1.0% "
            "gives a minimum 2:1 reward-risk ratio. Session filter 07-20 UTC covers "
            "Sydney open through NY overlap, maximising NZD/USD liquidity. "
            "Reverse on opposite signal keeps the model continuously positioned in "
            "the highest-confidence direction. min_atr filter avoids flat/illiquid "
            "periods where the model edges degrade."
        ),
        "notes": (
            "Features: Bollinger Bands (20,2) width & %B, RSI(14), Stochastic K/D "
            "(14,3), ATR(14)/NATR, EMA cross (20/50/100), SMA50 trend context, "
            "price ROC (4/8/16 bars), candlestick body/wick ratios, HL range "
            "normalisation, BB squeeze flag, RSI/Stoch overbought-oversold flags, "
            "interaction terms (RSI*%B, StochK*%B), and 4 lags each of RSI, StochK, "
            "%B and ROC4. Threshold 0.56 slightly above 0.50 to filter marginal "
            "signals without sacrificing too many trades."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 03:32:34
# Model            : XGBoost
# Feature Eng.     : RSI 14, MACD (12,26,9) + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/EURUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # ── RSI 14 ──────────────────────────────────────────────────────────────
    period = 14
    delta = close.diff()
    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)
    avg_gain = gain.ewm(com=period - 1, min_periods=period).mean()
    avg_loss = loss.ewm(com=period - 1, min_periods=period).mean()
    rs = avg_gain / avg_loss.replace(0, np.nan)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # RSI-derived features
    df["rsi_overbought"] = np.where(df["rsi_14"] > 70, 1, 0)
    df["rsi_oversold"]   = np.where(df["rsi_14"] < 30, 1, 0)
    df["rsi_centered"]   = df["rsi_14"] - 50.0

    # RSI momentum (change over last 3 bars)
    df["rsi_slope"] = df["rsi_14"].diff(3)

    # ── MACD (12, 26, 9) ────────────────────────────────────────────────────
    ema_12 = close.ewm(span=12, adjust=False).mean()
    ema_26 = close.ewm(span=26, adjust=False).mean()
    macd_line   = ema_12 - ema_26
    signal_line = macd_line.ewm(span=9, adjust=False).mean()
    macd_hist   = macd_line - signal_line

    df["macd_line"]   = macd_line
    df["signal_line"] = signal_line
    df["macd_hist"]   = macd_hist

    # MACD-derived features
    df["macd_above_signal"] = np.where(macd_line > signal_line, 1, 0)
    df["macd_hist_slope"]   = macd_hist.diff(2)
    df["macd_hist_sign"]    = np.where(macd_hist > 0, 1, -1)

    # ── Additional price-based features ─────────────────────────────────────
    # ATR (14)
    tr = pd.concat([
        high - low,
        (high - close.shift(1)).abs(),
        (low  - close.shift(1)).abs()
    ], axis=1).max(axis=1)
    df["atr_14"] = tr.ewm(com=13, min_periods=14).mean()
    df["natr_14"] = df["atr_14"] / close

    # Normalised price position within recent range (20-bar)
    roll_high = high.rolling(20).max()
    roll_low  = low.rolling(20).min()
    denom = (roll_high - roll_low).replace(0, np.nan)
    df["price_position_20"] = (close - roll_low) / denom

    # Bollinger Bands (20, 2)
    sma_20 = close.rolling(20).mean()
    std_20 = close.rolling(20).std()
    bb_upper = sma_20 + 2 * std_20
    bb_lower = sma_20 - 2 * std_20
    bb_width  = (bb_upper - bb_lower) / sma_20.replace(0, np.nan)
    df["bb_pct_b"]  = (close - bb_lower) / (bb_upper - bb_lower).replace(0, np.nan)
    df["bb_width"]  = bb_width

    # SMA trend features
    sma_50  = close.rolling(50).mean()
    sma_200 = close.rolling(200).mean()
    df["sma_50"]          = sma_50
    df["price_vs_sma50"]  = (close - sma_50) / sma_50.replace(0, np.nan)
    df["price_vs_sma200"] = (close - sma_200) / sma_200.replace(0, np.nan)
    df["sma_trend"]       = np.where(sma_50 > sma_200, 1, -1)

    # Momentum / returns
    df["ret_1"]  = close.pct_change(1)
    df["ret_3"]  = close.pct_change(3)
    df["ret_8"]  = close.pct_change(8)
    df["ret_16"] = close.pct_change(16)

    # Candle body / wick features
    body       = (close - open_).abs()
    candle_rng = (high - low).replace(0, np.nan)
    df["body_ratio"]  = body / candle_rng
    df["upper_wick"]  = (high - pd.concat([close, open_], axis=1).max(axis=1)) / candle_rng
    df["lower_wick"]  = (pd.concat([close, open_], axis=1).min(axis=1) - low) / candle_rng
    df["candle_dir"]  = np.where(close >= open_, 1, -1)

    # Volatility regime: rolling std of returns (20-bar)
    df["vol_regime"] = df["ret_1"].rolling(20).std()

    # RSI × MACD interaction
    df["rsi_macd_interact"] = df["rsi_centered"] * df["macd_hist"]

    # Volume of MACD histogram change (acceleration)
    df["macd_hist_accel"] = df["macd_hist"].diff(1)

    # ── Fill NaN from warm-up ────────────────────────────────────────────────
    df = df.bfill().ffill()

    return df

# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "EUR/USD RSI+MACD Momentum Scalper (XGBoost)",
        "model_type":       "XGBClassifier",
        "model_params":     {
            "n_estimators":     400,
            "max_depth":        4,
            "learning_rate":    0.04,
            "subsample":        0.75,
            "colsample_bytree": 0.75,
            "min_child_weight": 5,
            "gamma":            0.1,
            "reg_alpha":        0.05,
            "reg_lambda":       1.5,
            "objective":        "binary:logistic",
            "tree_method":      "hist",
            "random_state":     42,
            "n_jobs":           -1,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [7, 17],
        "min_atr":          0.0002,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective": (
            "Maximize risk-adjusted return (Sharpe/Calmar). "
            "XGBoost with regularisation (alpha, lambda, gamma, min_child_weight) "
            "to reduce overfitting on 15-min EUR/USD data. "
            "Shallow trees (max_depth=4) and column/row subsampling prevent "
            "memorisation of noise. Horizon=4 bars (1 hour) balances signal "
            "quality vs trade frequency. Session filter [7,17] UTC focuses on "
            "liquid London/NY overlap. SL=0.5%, TP=1.0% gives 1:2 R/R. "
            "Threshold=0.55 filters marginal predictions while keeping enough trades."
        ),
        "notes": (
            "Features: RSI-14 (centred, slope, OB/OS flags), MACD(12,26,9) "
            "(line, signal, histogram, slope, acceleration, interaction with RSI), "
            "Bollinger Bands (pct_b, width), SMA-50/200 trend offsets, "
            "ATR/NATR, 20-bar price position, momentum returns (1/3/8/16 bars), "
            "candle anatomy (body ratio, upper/lower wick), volatility regime. "
            "All features are look-ahead free and normalised where possible."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 01:52:32
# Model            : XGBoost
# Feature Eng.     : BB (20,2.0), RSI 14, Stochastic (14,3) + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/USDCHF_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # ── RSI 14 ──────────────────────────────────────────────────────────────
    period_rsi = 14
    delta = close.diff()
    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)
    avg_gain = gain.ewm(com=period_rsi - 1, min_periods=period_rsi).mean()
    avg_loss = loss.ewm(com=period_rsi - 1, min_periods=period_rsi).mean()
    rs = avg_gain / avg_loss.replace(0, np.nan)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # ── Bollinger Bands (20, 2) ──────────────────────────────────────────────
    bb_period = 20
    bb_std = 2.0
    bb_mid = close.rolling(bb_period).mean()
    bb_std_val = close.rolling(bb_period).std(ddof=0)
    bb_upper = bb_mid + bb_std * bb_std_val
    bb_lower = bb_mid - bb_std * bb_std_val
    df["bb_mid"] = bb_mid
    df["bb_upper"] = bb_upper
    df["bb_lower"] = bb_lower
    df["bb_width"] = (bb_upper - bb_lower) / bb_mid
    bb_range = (bb_upper - bb_lower).replace(0, np.nan)
    df["bb_pct"] = (close - bb_lower) / bb_range

    # ── Stochastic Oscillator (K=14, D=3) ───────────────────────────────────
    stoch_k_period = 14
    stoch_d_period = 3
    lowest_low = low.rolling(stoch_k_period).min()
    highest_high = high.rolling(stoch_k_period).max()
    stoch_range = (highest_high - lowest_low).replace(0, np.nan)
    df["stoch_k"] = 100 * (close - lowest_low) / stoch_range
    df["stoch_d"] = df["stoch_k"].rolling(stoch_d_period).mean()
    df["stoch_kd_diff"] = df["stoch_k"] - df["stoch_d"]

    # ── Additional derived features ──────────────────────────────────────────

    # RSI momentum & zone flags
    df["rsi_lag1"] = df["rsi_14"].shift(1)
    df["rsi_momentum"] = df["rsi_14"] - df["rsi_lag1"]
    df["rsi_oversold"] = np.where(df["rsi_14"] < 30, 1, 0)
    df["rsi_overbought"] = np.where(df["rsi_14"] > 70, 1, 0)

    # BB squeeze: width below rolling 20-bar median of bb_width
    bb_width_median = df["bb_width"].rolling(20).median()
    df["bb_squeeze"] = np.where(df["bb_width"] < bb_width_median, 1, 0)

    # BB position zone
    df["bb_below_lower"] = np.where(close < bb_lower, 1, 0)
    df["bb_above_upper"] = np.where(close > bb_upper, 1, 0)

    # Stochastic zone flags
    df["stoch_oversold"] = np.where(df["stoch_k"] < 20, 1, 0)
    df["stoch_overbought"] = np.where(df["stoch_k"] > 80, 1, 0)

    # Price momentum (rate of change)
    df["roc_4"] = close.pct_change(4)
    df["roc_8"] = close.pct_change(8)
    df["roc_16"] = close.pct_change(16)

    # ATR (14-bar) for volatility context
    atr_period = 14
    tr = pd.concat([
        high - low,
        (high - close.shift(1)).abs(),
        (low - close.shift(1)).abs()
    ], axis=1).max(axis=1)
    df["atr_14"] = tr.ewm(com=atr_period - 1, min_periods=atr_period).mean()
    df["natr_14"] = df["atr_14"] / close

    # EMA crossover signals
    ema_fast = close.ewm(span=8, min_periods=8).mean()
    ema_slow = close.ewm(span=21, min_periods=21).mean()
    df["ema_fast"] = ema_fast
    df["ema_slow"] = ema_slow
    df["ema_cross"] = ema_fast - ema_slow
    df["ema_cross_sign"] = np.where(df["ema_cross"] > 0, 1, -1)

    # SMA 50 trend context
    df["sma_50"] = close.rolling(50).mean()
    df["close_vs_sma50"] = (close - df["sma_50"]) / df["sma_50"]

    # Candle body and direction
    df["candle_body"] = (close - open_).abs()
    df["candle_range"] = (high - low).replace(0, np.nan)
    df["body_ratio"] = df["candle_body"] / df["candle_range"]
    df["candle_dir"] = np.where(close >= open_, 1, -1)

    # Volume-proxy: range relative to rolling average range
    df["rel_range"] = (high - low) / (high - low).rolling(20).mean()

    # Lag features for RSI, stoch_k, bb_pct
    for lag in [1, 2, 3]:
        df[f"rsi_14_lag{lag}"] = df["rsi_14"].shift(lag)
        df[f"stoch_k_lag{lag}"] = df["stoch_k"].shift(lag)
        df[f"bb_pct_lag{lag}"] = df["bb_pct"].shift(lag)
        df[f"ema_cross_lag{lag}"] = df["ema_cross"].shift(lag)

    # Divergence proxy: price making new high but RSI not
    price_high_4 = close.rolling(4).max()
    rsi_high_4 = df["rsi_14"].rolling(4).max()
    df["bearish_div_proxy"] = np.where(
        (close >= price_high_4.shift(1)) & (df["rsi_14"] < rsi_high_4.shift(1)), 1, 0
    )
    price_low_4 = close.rolling(4).min()
    rsi_low_4 = df["rsi_14"].rolling(4).min()
    df["bullish_div_proxy"] = np.where(
        (close <= price_low_4.shift(1)) & (df["rsi_14"] > rsi_low_4.shift(1)), 1, 0
    )

    # Combined confluence signals
    df["long_confluence"] = np.where(
        (df["rsi_14"] < 45) & (df["stoch_k"] < 50) & (df["bb_pct"] < 0.5), 1, 0
    )
    df["short_confluence"] = np.where(
        (df["rsi_14"] > 55) & (df["stoch_k"] > 50) & (df["bb_pct"] > 0.5), 1, 0
    )

    # Fill NaN from warm-up
    df = df.bfill().ffill()
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "USD/CHF Stoch+BB+RSI Mean-Reversion (XGBoost)",
        "model_type": "XGBClassifier",
        "model_params": {
            "n_estimators": 400,
            "max_depth": 4,
            "learning_rate": 0.04,
            "subsample": 0.8,
            "colsample_bytree": 0.75,
            "min_child_weight": 5,
            "gamma": 0.1,
            "reg_alpha": 0.05,
            "reg_lambda": 1.5,
            "objective": "binary:logistic",
            "tree_method": "hist",
            "random_state": 42,
            "n_jobs": -1,
        },
        "signal_threshold": 0.55,
        "direction": "both",
        "stop_loss": 0.005,
        "take_profit": 0.01,
        "cooldown": 0,
        "max_positions": 1,
        "on_opposite": "reverse",
        "session_filter": [7, 17],
        "min_atr": None,
        "trend_filter": None,
        "target_horizon": 4,
        "objective": (
            "Maximize risk-adjusted return (Sharpe/Calmar) on USD/CHF 15-min data. "
            "Uses Stochastic (14,3), Bollinger Bands (20,2), and RSI-14 as core features "
            "with confluence signals, divergence proxies, and EMA crossover context. "
            "XGBoost chosen for its strong performance on tabular data with regularization "
            "parameters (gamma, alpha, lambda) tuned to reduce overfitting on short date "
            "ranges. SL=0.5%/TP=1.0% gives 1:2 R:R ratio. Session filter [7,17] UTC targets "
            "London/NY overlap for higher-quality moves. Signal threshold 0.55 filters noise "
            "while preserving trade frequency."
        ),
        "notes": (
            "Feature set combines mean-reversion indicators (RSI, Stochastic, BB percentile) "
            "with trend context (EMA cross, SMA50 distance) and volatility measures (ATR, "
            "BB width/squeeze). Lag features (1-3 bars) capture recent indicator momentum. "
            "Bullish/bearish divergence proxies add signal quality. Shallow trees (max_depth=4) "
            "with high n_estimators and slow learning rate reduce variance. Colsample and "
            "subsample add stochastic regularization."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 02:04:57
# Model            : XGBoost
# Feature Eng.     : SMA (20,50,200), BB (20,2.0), RSI 14, MACD (12,26,9), ATR 14 + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# EUR/USD Multi-Indicator Momentum + Mean-Reversion (XGBoost)
# ============================================================

# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/EURUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):

    # ── SMA 20, 50, 200 + distance-from-close ──────────────────────────────
    for period in [20, 50, 200]:
        sma = close.rolling(period).mean()
        df[f"sma_{period}"]    = sma
        df[f"dm_sma_{period}"] = (close - sma) / sma

    # ── Bollinger Bands (20, 2) ─────────────────────────────────────────────
    bb_mid   = close.rolling(20).mean()
    bb_std   = close.rolling(20).std(ddof=0)
    bb_upper = bb_mid + 2.0 * bb_std
    bb_lower = bb_mid - 2.0 * bb_std
    df["bb_mid"]   = bb_mid
    df["bb_upper"] = bb_upper
    df["bb_lower"] = bb_lower
    df["bb_width"] = (bb_upper - bb_lower) / bb_mid
    bb_range       = bb_upper - bb_lower
    df["bb_pct"]   = np.where(bb_range != 0, (close - bb_lower) / bb_range, 0.5)

    # ── RSI 14 ──────────────────────────────────────────────────────────────
    delta  = close.diff()
    gain   = delta.clip(lower=0)
    loss   = (-delta).clip(lower=0)
    avg_gain = gain.ewm(com=13, min_periods=14, adjust=False).mean()
    avg_loss = loss.ewm(com=13, min_periods=14, adjust=False).mean()
    rs         = np.where(avg_loss != 0, avg_gain / avg_loss, 100.0)
    df["rsi_14"] = 100.0 - (100.0 / (1.0 + rs))

    # ── MACD (12, 26, 9) ────────────────────────────────────────────────────
    ema_12 = close.ewm(span=12, adjust=False).mean()
    ema_26 = close.ewm(span=26, adjust=False).mean()
    macd_line   = ema_12 - ema_26
    signal_line = macd_line.ewm(span=9, adjust=False).mean()
    df["macd_line"]   = macd_line
    df["macd_signal"] = signal_line
    df["macd_hist"]   = macd_line - signal_line

    # ── ATR 14 + NATR ───────────────────────────────────────────────────────
    prev_close = close.shift(1)
    tr = pd.concat([
        high - low,
        (high - prev_close).abs(),
        (low  - prev_close).abs()
    ], axis=1).max(axis=1)
    atr = tr.ewm(com=13, min_periods=14, adjust=False).mean()
    df["atr_14"] = atr
    df["natr"]   = np.where(close != 0, atr / close, 0.0)

    # ── Price momentum features ─────────────────────────────────────────────
    for lag in [1, 2, 4, 8]:
        df[f"ret_{lag}"] = close.pct_change(lag)

    # ── Candle body / wick features ─────────────────────────────────────────
    candle_range = (high - low).replace(0, np.nan)
    df["body_ratio"] = np.where(
        candle_range.notna(),
        (close - open_).abs() / candle_range,
        0.0
    )
    df["upper_wick"] = np.where(
        candle_range.notna(),
        (high - pd.concat([close, open_], axis=1).max(axis=1)) / candle_range,
        0.0
    )
    df["lower_wick"] = np.where(
        candle_range.notna(),
        (pd.concat([close, open_], axis=1).min(axis=1) - low) / candle_range,
        0.0
    )
    df["candle_dir"] = np.where(close >= open_, 1.0, -1.0)

    # ── Volume-proxy: normalised range ─────────────────────────────────────
    df["norm_range"] = (high - low) / close.rolling(20).mean()

    # ── RSI derived ─────────────────────────────────────────────────────────
    df["rsi_ob"] = np.where(df["rsi_14"] > 70, 1.0, 0.0)
    df["rsi_os"] = np.where(df["rsi_14"] < 30, 1.0, 0.0)
    df["rsi_mid_cross"] = np.where(df["rsi_14"] > 50, 1.0, -1.0)

    # ── Trend alignment flags ───────────────────────────────────────────────
    df["above_sma_20"]  = np.where(close > df["sma_20"],  1.0, -1.0)
    df["above_sma_50"]  = np.where(close > df["sma_50"],  1.0, -1.0)
    df["above_sma_200"] = np.where(close > df["sma_200"], 1.0, -1.0)
    df["sma_20_50_cross"] = np.where(df["sma_20"] > df["sma_50"], 1.0, -1.0)

    # ── MACD cross flag ─────────────────────────────────────────────────────
    df["macd_cross"] = np.where(df["macd_line"] > df["macd_signal"], 1.0, -1.0)

    # ── Bollinger squeeze ───────────────────────────────────────────────────
    bb_width_ma = df["bb_width"].rolling(20).mean()
    df["bb_squeeze"] = np.where(df["bb_width"] < bb_width_ma, 1.0, 0.0)

    # ── Lagged RSI and MACD hist for regime detection ───────────────────────
    df["rsi_14_lag1"]   = df["rsi_14"].shift(1)
    df["macd_hist_lag1"] = df["macd_hist"].shift(1)
    df["rsi_slope"]     = df["rsi_14"] - df["rsi_14_lag1"]
    df["macd_hist_slope"] = df["macd_hist"] - df["macd_hist_lag1"]

    # ── Rolling volatility ratio ─────────────────────────────────────────────
    vol_short = close.pct_change().rolling(8).std()
    vol_long  = close.pct_change().rolling(32).std()
    df["vol_ratio"] = np.where(vol_long != 0, vol_short / vol_long, 1.0)

    # ── Hour-of-day (session proxy) ─────────────────────────────────────────
    if hasattr(df.index, "hour"):
        df["hour_sin"] = np.sin(2 * np.pi * df.index.hour / 24.0)
        df["hour_cos"] = np.cos(2 * np.pi * df.index.hour / 24.0)
    else:
        df["hour_sin"] = 0.0
        df["hour_cos"] = 1.0

    # ── Fill any NaN from warm-up ───────────────────────────────────────────
    df = df.bfill().ffill()

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "EUR/USD SMA+RSI+MACD+BB Momentum XGBoost",
        "model_type":       "XGBClassifier",
        "model_params":     {
            "n_estimators":     600,
            "max_depth":        4,
            "learning_rate":    0.04,
            "subsample":        0.8,
            "colsample_bytree": 0.75,
            "min_child_weight": 3,
            "gamma":            0.1,
            "reg_alpha":        0.05,
            "reg_lambda":       1.5,
            "objective":        "binary:logistic",
            "random_state":     42,
            "n_jobs":           -1,
        },
        "signal_threshold": 0.54,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [6, 20],
        "min_atr":          0.0002,
        "trend_filter":     "sma_50",
        "target_horizon":   4,
        "objective":        (
            "Maximize risk-adjusted return (Sharpe/Calmar) on EUR/USD 15-min. "
            "XGBoost with moderate depth and strong regularisation to avoid "
            "overfitting on noisy FX data. 2:1 TP:SL ratio with trend filter "
            "on SMA-50 to avoid counter-trend noise. Session filter 06-20 UTC "
            "covers London + NY overlap for best liquidity."
        ),
        "notes": (
            "Features: SMA cross distances, RSI overbought/oversold flags, "
            "MACD histogram slope, Bollinger squeeze, ATR normalisation, "
            "candle body/wick ratios, momentum returns at 1/2/4/8 bars, "
            "session encoding via hour sin/cos. "
            "Threshold 0.54 keeps precision high while capturing enough trades. "
            "Reverse on opposite signal maximises capital utilisation."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 01:39:22
# Model            : XGBoost
# Feature Eng.     : EMA (9,21), RSI 14 + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/EURUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # ── EMA 9 and EMA 21 ──────────────────────────────────────────────────────
    ema_9  = close.ewm(span=9,  adjust=False).mean()
    ema_21 = close.ewm(span=21, adjust=False).mean()

    df["ema_9"]    = ema_9
    df["ema_21"]   = ema_21
    df["dm_ema_9"]  = (close - ema_9)  / ema_9
    df["dm_ema_21"] = (close - ema_21) / ema_21

    # EMA cross signal: +1 when ema_9 > ema_21, -1 otherwise
    df["ema_cross"] = np.where(ema_9 > ema_21, 1.0, -1.0)

    # EMA cross momentum: difference normalised by ema_21
    df["ema_spread"] = (ema_9 - ema_21) / ema_21

    # Rate of change of EMA spread (1-bar and 3-bar)
    df["ema_spread_chg1"] = df["ema_spread"].diff(1)
    df["ema_spread_chg3"] = df["ema_spread"].diff(3)

    # ── RSI 14 ────────────────────────────────────────────────────────────────
    delta  = close.diff(1)
    gain   = delta.clip(lower=0)
    loss   = (-delta).clip(lower=0)
    avg_gain = gain.ewm(alpha=1/14, min_periods=14, adjust=False).mean()
    avg_loss = loss.ewm(alpha=1/14, min_periods=14, adjust=False).mean()
    rs     = avg_gain / avg_loss.replace(0, np.nan)
    rsi_14 = 100 - (100 / (1 + rs))
    df["rsi_14"] = rsi_14

    # RSI normalised to [-1, 1]
    df["rsi_norm"] = (rsi_14 - 50) / 50

    # RSI momentum
    df["rsi_chg1"] = rsi_14.diff(1)
    df["rsi_chg3"] = rsi_14.diff(3)

    # RSI zone flags (overbought / oversold)
    df["rsi_ob"] = np.where(rsi_14 > 70, 1.0, 0.0)
    df["rsi_os"] = np.where(rsi_14 < 30, 1.0, 0.0)

    # ── ATR 14 (for normalisation & volatility context) ───────────────────────
    tr = pd.concat([
        high - low,
        (high - close.shift(1)).abs(),
        (low  - close.shift(1)).abs()
    ], axis=1).max(axis=1)
    atr_14 = tr.ewm(span=14, adjust=False).mean()
    df["atr_14"]  = atr_14
    df["natr_14"] = atr_14 / close  # normalised ATR

    # ── Price momentum features ───────────────────────────────────────────────
    for n in [1, 3, 5, 10, 20]:
        df[f"ret_{n}"] = close.pct_change(n)

    # ── Volatility: rolling std of returns ───────────────────────────────────
    ret1 = close.pct_change(1)
    df["vol_5"]  = ret1.rolling(5).std()
    df["vol_20"] = ret1.rolling(20).std()

    # ── Bollinger Band features (20, 2) ───────────────────────────────────────
    bb_mid  = close.rolling(20).mean()
    bb_std  = close.rolling(20).std()
    bb_up   = bb_mid + 2 * bb_std
    bb_lo   = bb_mid - 2 * bb_std
    df["bb_pct"]   = (close - bb_lo) / (bb_up - bb_lo).replace(0, np.nan)
    df["bb_width"] = (bb_up - bb_lo) / bb_mid

    # ── MACD-style: difference of EMA12 and EMA26 ────────────────────────────
    ema_12 = close.ewm(span=12, adjust=False).mean()
    ema_26 = close.ewm(span=26, adjust=False).mean()
    macd   = ema_12 - ema_26
    signal = macd.ewm(span=9, adjust=False).mean()
    df["macd"]          = macd / close
    df["macd_signal"]   = signal / close
    df["macd_hist"]     = (macd - signal) / close

    # ── High-Low channel position ─────────────────────────────────────────────
    hh20 = high.rolling(20).max()
    ll20 = low.rolling(20).min()
    df["hl_pos_20"] = (close - ll20) / (hh20 - ll20).replace(0, np.nan)

    hh5 = high.rolling(5).max()
    ll5 = low.rolling(5).min()
    df["hl_pos_5"]  = (close - ll5)  / (hh5  - ll5).replace(0, np.nan)

    # ── Bar body & shadow features ────────────────────────────────────────────
    body  = (close - open_).abs()
    range_ = (high - low).replace(0, np.nan)
    df["body_ratio"]   = body / range_
    df["upper_shadow"]  = (high - pd.concat([close, open_], axis=1).max(axis=1)) / range_
    df["lower_shadow"]  = (pd.concat([close, open_], axis=1).min(axis=1) - low)  / range_
    df["bull_bar"]     = np.where(close > open_, 1.0, 0.0)

    # ── Rolling correlation: EMA spread vs RSI (captures confluence) ──────────
    df["corr_spread_rsi"] = df["ema_spread"].rolling(10).corr(rsi_14)

    # ── Time-of-day features (hour & minute encoded cyclically) ───────────────
    if hasattr(df.index, "hour"):
        hour = df.index.hour
        df["hour_sin"] = np.sin(2 * np.pi * hour / 24)
        df["hour_cos"] = np.cos(2 * np.pi * hour / 24)
        dow = df.index.dayofweek
        df["dow_sin"]  = np.sin(2 * np.pi * dow / 5)
        df["dow_cos"]  = np.cos(2 * np.pi * dow / 5)

    # ── Fill NaN from indicator warm-up ──────────────────────────────────────
    df = df.bfill().ffill()

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "EMA Cross (9/21) + RSI Confirmation — XGBoost",
        "model_type":       "XGBClassifier",
        "model_params":     {
            "n_estimators":     400,
            "max_depth":        4,
            "learning_rate":    0.04,
            "subsample":        0.75,
            "colsample_bytree": 0.70,
            "min_child_weight": 5,
            "gamma":            0.15,
            "reg_alpha":        0.10,
            "reg_lambda":       1.50,
            "objective":        "binary:logistic",
            "random_state":     42,
            "n_jobs":           -1,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [6, 20],
        "min_atr":          0.0002,
        "trend_filter":     "sma_50",
        "target_horizon":   4,
        "objective":        (
            "Maximize risk-adjusted return (Sharpe / Calmar) on EUR/USD 15-min data. "
            "XGBoost with moderate depth (4) and heavy regularisation (gamma, alpha, lambda) "
            "to avoid overfitting on a 1-year window. "
            "EMA cross provides trend direction; RSI filters against overbought/oversold entries. "
            "Asymmetric TP/SL (2:1) boosts expectancy. Session filter restricts trading to "
            "London + NY overlap (06–20 UTC) where EUR/USD liquidity is highest. "
            "min_atr removes low-volatility bars where spreads erode edge."
        ),
        "notes":            (
            "Features: EMA 9/21 cross & spread, RSI 14, MACD histogram, Bollinger Band %B, "
            "ATR-normalised volatility, price momentum (1/3/5/10/20 bars), rolling vol, "
            "high-low channel position, candlestick body/shadow ratios, cyclical time encoding. "
            "Target horizon = 4 bars (1 hour ahead). Train/test split 70/30 (no leakage). "
            "Cooldown = 0 because on_opposite='reverse' keeps the model always positioned "
            "when high-confidence signals appear."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 03:08:55
# Model            : Gradient Boosting
# Feature Eng.     : SMA (20,50,200), BB (20,2.0), RSI 14, MACD (12,26,9), ATR 14 + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/EURUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):

    # ── SMA 20, 50, 200 + distance from close ─────────────────────────────
    for p in [20, 50, 200]:
        sma = close.rolling(p).mean()
        df[f"sma_{p}"]    = sma
        df[f"dm_sma_{p}"] = (close - sma) / sma

    # ── Bollinger Bands (20, 2) ────────────────────────────────────────────
    bb_mid   = close.rolling(20).mean()
    bb_std   = close.rolling(20).std(ddof=0)
    bb_upper = bb_mid + 2.0 * bb_std
    bb_lower = bb_mid - 2.0 * bb_std
    df["bb_width"] = (bb_upper - bb_lower) / bb_mid
    denom          = bb_upper - bb_lower
    df["bb_pct"]   = np.where(denom != 0, (close - bb_lower) / denom, 0.5)

    # ── RSI 14 ────────────────────────────────────────────────────────────
    delta    = close.diff()
    gain     = delta.clip(lower=0)
    loss     = (-delta).clip(lower=0)
    avg_gain = gain.ewm(com=13, min_periods=14).mean()
    avg_loss = loss.ewm(com=13, min_periods=14).mean()
    rs       = avg_gain / avg_loss.replace(0, np.nan)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # ── MACD (12, 26, 9) ──────────────────────────────────────────────────
    ema_fast        = close.ewm(span=12, adjust=False).mean()
    ema_slow        = close.ewm(span=26, adjust=False).mean()
    macd_line       = ema_fast - ema_slow
    signal_line     = macd_line.ewm(span=9, adjust=False).mean()
    df["macd_line"] = macd_line
    df["macd_sig"]  = signal_line
    df["macd_hist"] = macd_line - signal_line

    # ── ATR 14 + NATR ─────────────────────────────────────────────────────
    hl    = high - low
    hc    = (high - close.shift(1)).abs()
    lc    = (low  - close.shift(1)).abs()
    tr    = pd.concat([hl, hc, lc], axis=1).max(axis=1)
    atr   = tr.ewm(com=13, min_periods=14).mean()
    df["atr_14"]  = atr
    df["natr"]    = atr / close

    # ── Price momentum / rate-of-change ───────────────────────────────────
    for p in [4, 8, 16, 32]:
        df[f"roc_{p}"] = close.pct_change(p)

    # ── Candle body and wick features ─────────────────────────────────────
    body          = (close - open_).abs()
    candle_range  = (high - low).replace(0, np.nan)
    df["body_ratio"]   = body / candle_range
    df["upper_wick"]   = (high - pd.concat([close, open_], axis=1).max(axis=1)) / candle_range
    df["lower_wick"]   = (pd.concat([close, open_], axis=1).min(axis=1) - low)  / candle_range
    df["body_dir"]     = np.sign(close - open_)

    # ── Volume-normalised (uses candle range as proxy if no volume col) ───
    # Rolling z-score of close
    roll_mean = close.rolling(20).mean()
    roll_std  = close.rolling(20).std(ddof=0).replace(0, np.nan)
    df["close_zscore_20"] = (close - roll_mean) / roll_std

    # ── RSI divergence proxy ──────────────────────────────────────────────
    df["rsi_delta_4"]  = df["rsi_14"].diff(4)
    df["price_delta_4"] = close.pct_change(4)
    df["rsi_price_div"] = df["rsi_delta_4"] - (df["price_delta_4"] * 100)

    # ── MACD histogram slope ──────────────────────────────────────────────
    df["macd_hist_slope"] = df["macd_hist"].diff(2)

    # ── SMA crossover signals ─────────────────────────────────────────────
    df["sma20_vs_50"]   = np.where(df["sma_20"] > df["sma_50"],  1.0, -1.0)
    df["sma50_vs_200"]  = np.where(df["sma_50"] > df["sma_200"], 1.0, -1.0)

    # ── Volatility regime (ATR percentile proxy) ──────────────────────────
    atr_roll_min = atr.rolling(96).min()
    atr_roll_max = atr.rolling(96).max()
    atr_range    = (atr_roll_max - atr_roll_min).replace(0, np.nan)
    df["atr_pctile_96"] = (atr - atr_roll_min) / atr_range

    # ── Stochastic oscillator %K, %D ──────────────────────────────────────
    low_14  = low.rolling(14).min()
    high_14 = high.rolling(14).max()
    stoch_k = 100 * (close - low_14) / (high_14 - low_14).replace(0, np.nan)
    stoch_d = stoch_k.rolling(3).mean()
    df["stoch_k"] = stoch_k
    df["stoch_d"] = stoch_d
    df["stoch_diff"] = stoch_k - stoch_d

    # ── Rolling high/low breakout distance ────────────────────────────────
    df["dist_hi_20"] = (high.rolling(20).max() - close) / close
    df["dist_lo_20"] = (close - low.rolling(20).min())  / close

    # ── Hour-of-day and day-of-week cyclical features ─────────────────────
    hour = pd.Series(df.index.hour,        index=df.index, dtype=float)
    dow  = pd.Series(df.index.dayofweek,   index=df.index, dtype=float)
    df["hour_sin"] = np.sin(2 * np.pi * hour / 24)
    df["hour_cos"] = np.cos(2 * np.pi * hour / 24)
    df["dow_sin"]  = np.sin(2 * np.pi * dow  / 5)
    df["dow_cos"]  = np.cos(2 * np.pi * dow  / 5)

    # ── Fill NaN from indicator warm-up ───────────────────────────────────
    df = df.bfill().ffill()

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "EUR/USD Gradient Boost SMA+RSI+MACD Swing",
        "model_type":       "GradientBoostingClassifier",
        "model_params":     {
            "n_estimators":       400,
            "max_depth":          4,
            "learning_rate":      0.04,
            "subsample":          0.75,
            "min_samples_leaf":   20,
            "min_samples_split":  30,
            "max_features":       "sqrt",
            "validation_fraction": 0.1,
            "n_iter_no_change":   30,
            "tol":                1e-4,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [7, 18],
        "min_atr":          0.0002,
        "trend_filter":     "sma_50",
        "target_horizon":   4,
        "objective":        (
            "Maximize risk-adjusted return (Sharpe / Calmar) on EUR/USD 15-min. "
            "GradientBoostingClassifier chosen for robustness to noisy FX features and "
            "good probability calibration. Shallow trees (depth 4), high n_estimators with "
            "early stopping prevent overfitting. Subsample=0.75 adds stochasticity. "
            "SL=0.5%, TP=1.0% gives 1:2 R:R. Session filter 07-18 UTC captures London+NY overlap. "
            "min_atr filters out flat/illiquid periods. sma_50 trend filter aligns trades with "
            "medium-term momentum. Threshold 0.55 balances precision vs recall."
        ),
        "notes":            (
            "Features: SMA(20,50,200) with distance ratios, BB(20,2) width+pct, RSI-14, "
            "MACD(12,26,9) line/signal/hist + slope, ATR-14 + NATR, ROC(4,8,16,32), "
            "candle body/wick ratios, close z-score, RSI-price divergence proxy, "
            "stochastic %K/%D, rolling high/low breakout distances, "
            "SMA crossover flags, ATR percentile regime, hour/DOW cyclical encodings. "
            "on_opposite=reverse means a strong counter-signal immediately flips the position, "
            "reducing idle time and capturing reversals within the London-NY session."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 02:35:43
# Model            : Gradient Boosting
# Feature Eng.     : SMA (20,50,200) + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/EURUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # ── SMA core features (required) ──────────────────────────────────────
    for period in [20, 50, 200]:
        sma = close.rolling(period).mean()
        df[f"sma_{period}"] = sma
        df[f"dm_sma_{period}"] = (close - sma) / sma

    # ── SMA slope (momentum of the moving average itself) ──────────────────
    for period in [20, 50, 200]:
        df[f"sma_{period}_slope"] = df[f"sma_{period}"].diff(5) / df[f"sma_{period}"].shift(5)

    # ── SMA crossover signals ──────────────────────────────────────────────
    df["sma_20_50_cross"]  = df["sma_20"] - df["sma_50"]
    df["sma_50_200_cross"] = df["sma_50"] - df["sma_200"]
    df["sma_20_200_cross"] = df["sma_20"] - df["sma_200"]

    # Sign of crossover difference (trend direction)
    df["trend_20_50"]  = np.where(df["sma_20_50_cross"]  > 0, 1, -1)
    df["trend_50_200"] = np.where(df["sma_50_200_cross"] > 0, 1, -1)

    # ── Price momentum ────────────────────────────────────────────────────
    for lag in [1, 4, 8, 16, 32]:
        df[f"return_{lag}"] = close.pct_change(lag)

    # ── Volatility features ───────────────────────────────────────────────
    # True Range
    prev_close = close.shift(1)
    tr = pd.concat([
        high - low,
        (high - prev_close).abs(),
        (low  - prev_close).abs()
    ], axis=1).max(axis=1)

    for atr_period in [14, 50]:
        atr = tr.rolling(atr_period).mean()
        df[f"atr_{atr_period}"] = atr
        df[f"natr_{atr_period}"] = atr / close

    # Rolling realised volatility
    log_ret = np.log(close / close.shift(1))
    for vol_period in [20, 50]:
        df[f"realvol_{vol_period}"] = log_ret.rolling(vol_period).std()

    # ── Bollinger Bands (20, 2σ) ──────────────────────────────────────────
    bb_mid = close.rolling(20).mean()
    bb_std = close.rolling(20).std()
    bb_upper = bb_mid + 2 * bb_std
    bb_lower = bb_mid - 2 * bb_std
    df["bb_width"]    = (bb_upper - bb_lower) / bb_mid
    df["bb_pct"]      = (close - bb_lower) / (bb_upper - bb_lower + 1e-12)
    df["bb_position"] = (close - bb_mid) / (bb_std + 1e-12)

    # ── RSI (14) ──────────────────────────────────────────────────────────
    delta = close.diff()
    gain  = delta.clip(lower=0).rolling(14).mean()
    loss  = (-delta.clip(upper=0)).rolling(14).mean()
    rs    = gain / (loss + 1e-12)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # RSI normalised to [-1, 1]
    df["rsi_14_norm"] = (df["rsi_14"] - 50) / 50

    # ── MACD (12, 26, 9) ─────────────────────────────────────────────────
    ema12 = close.ewm(span=12, adjust=False).mean()
    ema26 = close.ewm(span=26, adjust=False).mean()
    macd_line   = ema12 - ema26
    signal_line = macd_line.ewm(span=9, adjust=False).mean()
    df["macd"]          = macd_line
    df["macd_signal"]   = signal_line
    df["macd_hist"]     = macd_line - signal_line
    df["macd_hist_chg"] = df["macd_hist"].diff()

    # Normalise MACD by price
    df["macd_norm"]   = df["macd"]      / close
    df["macd_hist_norm"] = df["macd_hist"] / close

    # ── Stochastic Oscillator (14, 3) ─────────────────────────────────────
    low14  = low.rolling(14).min()
    high14 = high.rolling(14).max()
    stoch_k = 100 * (close - low14) / (high14 - low14 + 1e-12)
    stoch_d = stoch_k.rolling(3).mean()
    df["stoch_k"]    = stoch_k
    df["stoch_d"]    = stoch_d
    df["stoch_diff"] = stoch_k - stoch_d

    # ── Rate-of-change ────────────────────────────────────────────────────
    for roc_period in [5, 10, 20]:
        df[f"roc_{roc_period}"] = (close - close.shift(roc_period)) / (close.shift(roc_period) + 1e-12)

    # ── Candle body and wick features ─────────────────────────────────────
    body      = (close - open_).abs()
    candle_rng = (high - low).replace(0, np.nan)
    df["body_ratio"]       = body / candle_rng
    df["upper_wick_ratio"] = (high - pd.concat([close, open_], axis=1).max(axis=1)) / candle_rng
    df["lower_wick_ratio"] = (pd.concat([close, open_], axis=1).min(axis=1) - low)  / candle_rng
    df["candle_direction"]  = np.where(close >= open_, 1, -1)

    # ── Time-of-day features (hour) ───────────────────────────────────────
    hour = df.index.hour
    df["hour_sin"] = np.sin(2 * np.pi * hour / 24)
    df["hour_cos"] = np.cos(2 * np.pi * hour / 24)

    # ── Lagged returns as features ────────────────────────────────────────
    for lag in [1, 2, 3, 4]:
        df[f"close_lag_{lag}"] = close.shift(lag)
        df[f"ret_lag_{lag}"]   = log_ret.shift(lag)

    # ── Volume proxy: range-based ─────────────────────────────────────────
    df["range_abs"]  = high - low
    df["range_norm"] = (high - low) / close

    # ── High-Low channel position ─────────────────────────────────────────
    for ch_period in [20, 50]:
        ch_high = high.rolling(ch_period).max()
        ch_low  = low.rolling(ch_period).min()
        df[f"channel_pos_{ch_period}"] = (close - ch_low) / (ch_high - ch_low + 1e-12)

    # ── Fill NaN from warm-up ─────────────────────────────────────────────
    df = df.bfill().ffill()

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "EUR/USD SMA Trend + Multi-Indicator GBM Scalper",
        "model_type":       "GradientBoostingClassifier",
        "model_params":     {
            "n_estimators":     400,
            "max_depth":        4,
            "learning_rate":    0.04,
            "subsample":        0.75,
            "max_features":     "sqrt",
            "min_samples_leaf": 20,
            "min_samples_split": 40,
            "validation_fraction": 0.1,
            "n_iter_no_change": 30,
            "tol":              1e-4,
            "random_state":     42,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [6, 18],
        "min_atr":          None,
        "trend_filter":     "sma_50",
        "target_horizon":   4,
        "objective": (
            "Maximise risk-adjusted return (Sharpe / Calmar). "
            "GradientBoostingClassifier chosen for its strong performance on "
            "tabular financial data with moderate feature sets. "
            "Shallow trees (max_depth=4) with high n_estimators and a low "
            "learning_rate reduce overfitting. subsample=0.75 adds stochastic "
            "regularisation. Early stopping via n_iter_no_change prevents "
            "over-training on the validation split. "
            "SL=0.5%, TP=1.0% gives a 1:2 risk-reward ratio, "
            "targeting positive expectancy even at sub-60% accuracy. "
            "Session filter (06-18 UTC) restricts trading to liquid hours "
            "covering London and New York overlap for EUR/USD. "
            "SMA-50 trend filter ensures trades align with the medium-term "
            "trend, reducing counter-trend noise."
        ),
        "notes": (
            "Features include required SMA(20,50,200) distances and crossovers, "
            "RSI-14, MACD histogram, Bollinger Band position, Stochastic, ATR, "
            "realised volatility, rate-of-change, candle structure ratios, "
            "channel position, lagged returns, and cyclical time encoding. "
            "Target horizon of 4 bars (1 hour) on 15-min data balances "
            "signal frequency with meaningful directional moves."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 01:37:19
# Model            : XGBoost
# Feature Eng.     : SMA (20,50,200), BB (20,2.0), RSI 14, MACD (12,26,9), ATR 14 + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/USDCAD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):

    # ── SMA & distance features ──────────────────────────────────────────────
    for p in [20, 50, 200]:
        sma = close.rolling(p).mean()
        df[f"sma_{p}"] = sma
        df[f"dm_sma_{p}"] = (close - sma) / sma

    # SMA slope (rate of change of SMA over 5 bars)
    for p in [20, 50]:
        sma = df[f"sma_{p}"]
        df[f"sma_{p}_slope"] = sma.diff(5) / sma.shift(5)

    # SMA cross signals
    df["sma_20_50_cross"] = np.where(df["sma_20"] > df["sma_50"], 1.0, -1.0)
    df["sma_50_200_cross"] = np.where(df["sma_50"] > df["sma_200"], 1.0, -1.0)

    # ── Bollinger Bands ───────────────────────────────────────────────────────
    bb_mid = close.rolling(20).mean()
    bb_std = close.rolling(20).std()
    bb_upper = bb_mid + 2.0 * bb_std
    bb_lower = bb_mid - 2.0 * bb_std
    df["bb_mid"] = bb_mid
    df["bb_width"] = (bb_upper - bb_lower) / bb_mid
    bb_range = bb_upper - bb_lower
    df["bb_pct"] = np.where(bb_range != 0, (close - bb_lower) / bb_range, 0.5)

    # Bollinger Band squeeze: width vs its own 20-bar average
    df["bb_squeeze"] = df["bb_width"] / df["bb_width"].rolling(20).mean()

    # Price position relative to bands
    df["bb_above_upper"] = np.where(close > bb_upper, 1.0, 0.0)
    df["bb_below_lower"] = np.where(close < bb_lower, 1.0, 0.0)

    # ── RSI ───────────────────────────────────────────────────────────────────
    delta = close.diff()
    gain = delta.clip(lower=0)
    loss = (-delta).clip(lower=0)
    avg_gain = gain.ewm(alpha=1/14, adjust=False).mean()
    avg_loss = loss.ewm(alpha=1/14, adjust=False).mean()
    rs = avg_gain / avg_loss.replace(0, np.nan)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # RSI derived features
    df["rsi_norm"] = (df["rsi_14"] - 50) / 50          # centred & scaled
    df["rsi_ob"] = np.where(df["rsi_14"] > 70, 1.0, 0.0)
    df["rsi_os"] = np.where(df["rsi_14"] < 30, 1.0, 0.0)
    df["rsi_slope"] = df["rsi_14"].diff(3)

    # RSI divergence proxy: price up but RSI down (5-bar)
    price_chg_5 = close.diff(5)
    rsi_chg_5 = df["rsi_14"].diff(5)
    df["rsi_bear_div"] = np.where((price_chg_5 > 0) & (rsi_chg_5 < 0), 1.0, 0.0)
    df["rsi_bull_div"] = np.where((price_chg_5 < 0) & (rsi_chg_5 > 0), 1.0, 0.0)

    # ── MACD ──────────────────────────────────────────────────────────────────
    ema_fast = close.ewm(span=12, adjust=False).mean()
    ema_slow = close.ewm(span=26, adjust=False).mean()
    macd_line = ema_fast - ema_slow
    signal_line = macd_line.ewm(span=9, adjust=False).mean()
    df["macd_line"] = macd_line
    df["macd_signal"] = signal_line
    df["macd_hist"] = macd_line - signal_line

    # MACD normalised by close price
    df["macd_line_norm"] = macd_line / close
    df["macd_hist_norm"] = df["macd_hist"] / close

    # MACD histogram slope and sign change
    df["macd_hist_slope"] = df["macd_hist"].diff(2)
    df["macd_cross"] = np.where(macd_line > signal_line, 1.0, -1.0)

    # ── ATR ───────────────────────────────────────────────────────────────────
    tr = pd.concat([
        high - low,
        (high - close.shift(1)).abs(),
        (low  - close.shift(1)).abs()
    ], axis=1).max(axis=1)
    df["atr_14"] = tr.ewm(alpha=1/14, adjust=False).mean()
    df["natr"]   = df["atr_14"] / close

    # ATR regime: current ATR vs 50-bar rolling mean
    df["atr_regime"] = df["atr_14"] / df["atr_14"].rolling(50).mean()

    # ── Momentum / Price Action features ─────────────────────────────────────
    # Returns at multiple horizons
    for h in [1, 2, 4, 8, 16]:
        df[f"ret_{h}"] = close.pct_change(h)

    # Candle body & shadow
    body = (close - open_).abs()
    total_range = (high - low).replace(0, np.nan)
    df["body_ratio"] = body / total_range
    df["candle_dir"] = np.where(close >= open_, 1.0, -1.0)
    upper_shadow = high - pd.concat([close, open_], axis=1).max(axis=1)
    lower_shadow = pd.concat([close, open_], axis=1).min(axis=1) - low
    df["upper_shadow_ratio"] = upper_shadow / total_range
    df["lower_shadow_ratio"] = lower_shadow / total_range

    # Rolling price z-score (mean reversion signal)
    for w in [20, 50]:
        roll_mean = close.rolling(w).mean()
        roll_std  = close.rolling(w).std().replace(0, np.nan)
        df[f"zscore_{w}"] = (close - roll_mean) / roll_std

    # Volume of volatility: rolling std of returns
    df["vol_10"] = close.pct_change().rolling(10).std()
    df["vol_20"] = close.pct_change().rolling(20).std()

    # Efficiency ratio: directional move / path length (20 bars)
    direction_move = (close - close.shift(20)).abs()
    path_length = close.diff().abs().rolling(20).sum().replace(0, np.nan)
    df["efficiency_ratio"] = direction_move / path_length

    # ── Interaction / Cross features ─────────────────────────────────────────
    # RSI × MACD hist — captures momentum agreement
    df["rsi_macd_agree"] = df["rsi_norm"] * df["macd_hist_norm"]

    # BB pct × RSI — oversold/overbought near bands
    df["bb_rsi_interact"] = df["bb_pct"] * df["rsi_norm"]

    # Trend strength: distance from SMA50 scaled by ATR
    df["trend_atr_50"] = df["dm_sma_50"] / df["natr"].replace(0, np.nan)

    # ── Session / Time features ───────────────────────────────────────────────
    if hasattr(df.index, "hour"):
        hour = df.index.hour
        df["hour_sin"] = np.sin(2 * np.pi * hour / 24)
        df["hour_cos"] = np.cos(2 * np.pi * hour / 24)
        # London session flag
        df["london_session"] = np.where((hour >= 7) & (hour < 16), 1.0, 0.0)
        # NY session flag
        df["ny_session"] = np.where((hour >= 13) & (hour < 21), 1.0, 0.0)

    if hasattr(df.index, "dayofweek"):
        dow = df.index.dayofweek
        df["dow_sin"] = np.sin(2 * np.pi * dow / 5)
        df["dow_cos"] = np.cos(2 * np.pi * dow / 5)

    # ── Fill NaN from warm-up ─────────────────────────────────────────────────
    df = df.bfill().ffill()

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "USD/CAD Momentum-Reversion Hybrid (XGBoost, v2)",
        "model_type":       "XGBClassifier",
        "model_params": {
            "n_estimators":     600,
            "max_depth":        4,
            "learning_rate":    0.03,
            "subsample":        0.75,
            "colsample_bytree": 0.70,
            "min_child_weight": 5,
            "gamma":            0.2,
            "reg_alpha":        0.5,
            "reg_lambda":       2.0,
            "objective":        "binary:logistic",
            "tree_method":      "hist",
            "n_jobs":           -1,
            "random_state":     42,
        },
        "signal_threshold": 0.54,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [7, 21],
        "min_atr":          0.0002,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective": (
            "Maximise risk-adjusted return (Sharpe/Calmar). "
            "Deeper ensemble (600 trees) with aggressive regularisation "
            "(reg_alpha=0.5, reg_lambda=2, gamma=0.2, min_child_weight=5) "
            "to prevent overfitting on 15-min USDCAD. "
            "Rich feature set adds z-scores, efficiency ratio, session dummies, "
            "RSI divergence, candle shape and cross-indicator interactions "
            "beyond the prior attempt's plain indicators. "
            "0.5% SL / 1.0% TP gives 1:2 R:R; session filter restricts to "
            "liquid London+NY overlap hours."
        ),
        "notes": (
            "Prior attempt used plain RSI/MACD/BB/ATR/SMA and scored PF=0.98. "
            "This version adds: rolling z-scores (20,50), efficiency ratio, "
            "candle body/shadow ratios, multi-horizon returns, ATR regime, "
            "BB squeeze, RSI divergence proxies, time-of-day sin/cos encoding, "
            "and interaction terms (rsi_macd_agree, bb_rsi_interact, trend_atr). "
            "Model regularised more heavily to combat the short date range. "
            "Signal threshold lifted slightly to 0.54 to reduce marginal trades."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 01:23:23
# Model            : XGBoost
# Feature Eng.     : RSI 14, MACD (12,26,9) + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/GBPUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):

    # --- RSI 14 ---
    delta = close.diff()
    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)
    avg_gain = gain.ewm(com=13, min_periods=14).mean()
    avg_loss = loss.ewm(com=13, min_periods=14).mean()
    rs = avg_gain / (avg_loss + 1e-12)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # RSI derived features
    df["rsi_zscore"] = (df["rsi_14"] - df["rsi_14"].rolling(50).mean()) / (df["rsi_14"].rolling(50).std() + 1e-12)
    df["rsi_slope"] = df["rsi_14"].diff(3)
    df["rsi_above_50"] = np.where(df["rsi_14"] > 50, 1, 0)
    df["rsi_overbought"] = np.where(df["rsi_14"] > 70, 1, 0)
    df["rsi_oversold"] = np.where(df["rsi_14"] < 30, 1, 0)
    # RSI divergence proxy: price direction vs RSI direction
    price_dir_3 = np.sign(close.diff(3))
    rsi_dir_3 = np.sign(df["rsi_14"].diff(3))
    df["rsi_divergence"] = np.where(price_dir_3 != rsi_dir_3, 1, 0)

    # --- MACD (12, 26, 9) ---
    ema12 = close.ewm(span=12, adjust=False).mean()
    ema26 = close.ewm(span=26, adjust=False).mean()
    macd_line = ema12 - ema26
    signal_line = macd_line.ewm(span=9, adjust=False).mean()
    macd_hist = macd_line - signal_line
    df["macd_line"] = macd_line
    df["macd_signal"] = signal_line
    df["macd_hist"] = macd_hist

    # MACD derived features
    df["macd_hist_slope"] = macd_hist.diff(2)
    df["macd_cross_up"] = np.where((macd_line > signal_line) & (macd_line.shift(1) <= signal_line.shift(1)), 1, 0)
    df["macd_cross_dn"] = np.where((macd_line < signal_line) & (macd_line.shift(1) >= signal_line.shift(1)), 1, 0)
    df["macd_hist_positive"] = np.where(macd_hist > 0, 1, 0)
    df["macd_hist_expanding"] = np.where(macd_hist.abs() > macd_hist.abs().shift(1), 1, 0)
    df["macd_normalized"] = macd_line / (close + 1e-12)

    # --- ATR 14 ---
    tr1 = high - low
    tr2 = (high - close.shift(1)).abs()
    tr3 = (low - close.shift(1)).abs()
    tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
    atr14 = tr.ewm(com=13, min_periods=14).mean()
    df["atr_14"] = atr14
    df["natr_14"] = atr14 / (close + 1e-12)

    # ATR regime: high vs low volatility
    atr_ma = atr14.rolling(50).mean()
    df["atr_high_vol"] = np.where(atr14 > atr_ma * 1.2, 1, 0)
    df["atr_low_vol"] = np.where(atr14 < atr_ma * 0.8, 1, 0)

    # --- Bollinger Bands (20, 2) ---
    bb_mid = close.rolling(20).mean()
    bb_std = close.rolling(20).std()
    bb_upper = bb_mid + 2 * bb_std
    bb_lower = bb_mid - 2 * bb_std
    df["bb_pct_b"] = (close - bb_lower) / (bb_upper - bb_lower + 1e-12)
    df["bb_width"] = (bb_upper - bb_lower) / (bb_mid + 1e-12)
    df["bb_squeeze"] = np.where(df["bb_width"] < df["bb_width"].rolling(50).quantile(0.2), 1, 0)
    df["bb_upper_touch"] = np.where(close >= bb_upper * 0.999, 1, 0)
    df["bb_lower_touch"] = np.where(close <= bb_lower * 1.001, 1, 0)

    # --- Keltner Channel (20, 1.5x ATR) ---
    kc_mid = close.ewm(span=20, adjust=False).mean()
    kc_upper = kc_mid + 1.5 * atr14
    kc_lower = kc_mid - 1.5 * atr14
    df["kc_pct"] = (close - kc_lower) / (kc_upper - kc_lower + 1e-12)
    # Squeeze: BB inside KC
    df["kc_bb_squeeze"] = np.where((bb_upper < kc_upper) & (bb_lower > kc_lower), 1, 0)

    # --- Volume-like proxy: bar range & body ---
    bar_range = high - low
    bar_body = (close - open_).abs()
    df["range_norm"] = bar_range / (atr14 + 1e-12)
    df["body_ratio"] = bar_body / (bar_range + 1e-12)
    df["close_position"] = (close - low) / (bar_range + 1e-12)
    df["bullish_bar"] = np.where(close > open_, 1, 0)

    # --- Momentum & ROC ---
    df["roc_5"] = close.pct_change(5)
    df["roc_10"] = close.pct_change(10)
    df["roc_20"] = close.pct_change(20)
    df["momentum_10"] = close - close.shift(10)
    df["momentum_20"] = close - close.shift(20)

    # --- Moving Average features ---
    ema8 = close.ewm(span=8, adjust=False).mean()
    ema21 = close.ewm(span=21, adjust=False).mean()
    ema50 = close.ewm(span=50, adjust=False).mean()
    sma20 = close.rolling(20).mean()
    sma50 = close.rolling(50).mean()
    sma100 = close.rolling(100).mean()

    df["ema8_21_gap"] = (ema8 - ema21) / (close + 1e-12)
    df["ema21_50_gap"] = (ema21 - ema50) / (close + 1e-12)
    df["price_vs_ema50"] = (close - ema50) / (close + 1e-12)
    df["price_vs_sma20"] = (close - sma20) / (close + 1e-12)
    df["price_vs_sma100"] = (close - sma100) / (close + 1e-12)
    df["ema8_slope"] = ema8.diff(3) / (close + 1e-12)
    df["ema21_slope"] = ema21.diff(3) / (close + 1e-12)
    df["ema8_above_ema21"] = np.where(ema8 > ema21, 1, 0)
    df["ema21_above_ema50"] = np.where(ema21 > ema50, 1, 0)
    df["triple_ma_align_bull"] = np.where((ema8 > ema21) & (ema21 > ema50), 1, 0)
    df["triple_ma_align_bear"] = np.where((ema8 < ema21) & (ema21 < ema50), 1, 0)

    # --- Stochastic %K %D (14, 3) ---
    lowest_low_14 = low.rolling(14).min()
    highest_high_14 = high.rolling(14).max()
    stoch_k = 100 * (close - lowest_low_14) / (highest_high_14 - lowest_low_14 + 1e-12)
    stoch_d = stoch_k.rolling(3).mean()
    df["stoch_k"] = stoch_k
    df["stoch_d"] = stoch_d
    df["stoch_kd_diff"] = stoch_k - stoch_d
    df["stoch_overbought"] = np.where(stoch_k > 80, 1, 0)
    df["stoch_oversold"] = np.where(stoch_k < 20, 1, 0)
    df["stoch_cross_up"] = np.where((stoch_k > stoch_d) & (stoch_k.shift(1) <= stoch_d.shift(1)), 1, 0)
    df["stoch_cross_dn"] = np.where((stoch_k < stoch_d) & (stoch_k.shift(1) >= stoch_d.shift(1)), 1, 0)

    # --- Williams %R (14) ---
    df["willr_14"] = -100 * (highest_high_14 - close) / (highest_high_14 - lowest_low_14 + 1e-12)

    # --- CCI (20) ---
    tp = (high + low + close) / 3
    tp_ma = tp.rolling(20).mean()
    tp_mad = tp.rolling(20).apply(lambda x: np.mean(np.abs(x - np.mean(x))), raw=True)
    df["cci_20"] = (tp - tp_ma) / (0.015 * tp_mad + 1e-12)
    df["cci_above_zero"] = np.where(df["cci_20"] > 0, 1, 0)
    df["cci_extreme_bull"] = np.where(df["cci_20"] > 100, 1, 0)
    df["cci_extreme_bear"] = np.where(df["cci_20"] < -100, 1, 0)

    # --- Donchian Channel (20) ---
    don_high = high.rolling(20).max()
    don_low = low.rolling(20).min()
    df["donchian_pct"] = (close - don_low) / (don_high - don_low + 1e-12)
    df["donchian_breakout_up"] = np.where(close >= high.rolling(20).max().shift(1), 1, 0)
    df["donchian_breakout_dn"] = np.where(close <= low.rolling(20).min().shift(1), 1, 0)

    # --- Price pattern features ---
    df["higher_high"] = np.where((high > high.shift(1)) & (high.shift(1) > high.shift(2)), 1, 0)
    df["lower_low"] = np.where((low < low.shift(1)) & (low.shift(1) < low.shift(2)), 1, 0)
    df["inside_bar"] = np.where((high < high.shift(1)) & (low > low.shift(1)), 1, 0)
    df["outside_bar"] = np.where((high > high.shift(1)) & (low < low.shift(1)), 1, 0)

    # --- Lag features for key indicators ---
    for lag in [1, 2, 3, 4]:
        df[f"rsi_14_lag{lag}"] = df["rsi_14"].shift(lag)
        df[f"macd_hist_lag{lag}"] = df["macd_hist"].shift(lag)
        df[f"bb_pct_b_lag{lag}"] = df["bb_pct_b"].shift(lag)

    # --- Interaction features (avoiding lookahead) ---
    df["rsi_macd_bull"] = np.where((df["rsi_14"] > 50) & (df["macd_hist"] > 0), 1, 0)
    df["rsi_macd_bear"] = np.where((df["rsi_14"] < 50) & (df["macd_hist"] < 0), 1, 0)
    df["rsi_bb_oversold_bounce"] = np.where((df["rsi_14"] < 35) & (df["bb_pct_b"] < 0.2), 1, 0)
    df["rsi_bb_overbought_fade"] = np.where((df["rsi_14"] > 65) & (df["bb_pct_b"] > 0.8), 1, 0)
    df["triple_bull"] = np.where(
        (df["rsi_14"] > 50) & (df["macd_hist"] > 0) & (df["stoch_k"] > 50), 1, 0
    )
    df["triple_bear"] = np.where(
        (df["rsi_14"] < 50) & (df["macd_hist"] < 0) & (df["stoch_k"] < 50), 1, 0
    )

    # --- Volatility regime ---
    realized_vol = close.pct_change().rolling(20).std() * np.sqrt(96)
    df["realized_vol_20"] = realized_vol
    df["vol_regime_high"] = np.where(realized_vol > realized_vol.rolling(100).median(), 1, 0)

    # --- Session-aware time features ---
    if hasattr(df.index, 'hour'):
        df["hour_sin"] = np.sin(2 * np.pi * df.index.hour / 24)
        df["hour_cos"] = np.cos(2 * np.pi * df.index.hour / 24)
        df["london_session"] = np.where((df.index.hour >= 7) & (df.index.hour < 16), 1, 0)
        df["ny_session"] = np.where((df.index.hour >= 13) & (df.index.hour < 21), 1, 0)
        df["overlap_session"] = np.where((df.index.hour >= 13) & (df.index.hour < 16), 1, 0)
        df["asian_session"] = np.where((df.index.hour >= 0) & (df.index.hour < 7), 1, 0)
        df["day_of_week"] = df.index.dayofweek
        df["dow_sin"] = np.sin(2 * np.pi * df["day_of_week"] / 5)
        df["dow_cos"] = np.cos(2 * np.pi * df["day_of_week"] / 5)

    df = df.bfill().ffill()
    return df

# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "GBP/USD RSI-MACD Momentum + Volatility Regime XGBoost",
        "model_type":       "XGBClassifier",
        "model_params":     {
            "n_estimators":     500,
            "max_depth":        4,
            "learning_rate":    0.03,
            "subsample":        0.75,
            "colsample_bytree": 0.65,
            "min_child_weight": 5,
            "gamma":            0.15,
            "reg_alpha":        0.3,
            "reg_lambda":       1.5,
            "scale_pos_weight": 1,
            "objective":        "binary:logistic",
            "tree_method":      "hist",
            "random_state":     42,
        },
        "signal_threshold": 0.56,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [7, 21],
        "min_atr":          0.0002,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective":        (
            "Maximize risk-adjusted return (Sharpe/Calmar) by combining RSI momentum "
            "divergence, MACD histogram dynamics, Bollinger squeeze, Stochastic crossovers, "
            "volatility regime, and session-aware time features. XGBoost with moderate depth "
            "and strong regularization prevents overfitting on 15-min GBP/USD data. "
            "Signal threshold 0.56 filters weak signals, SL/TP at 0.5%/1.0% gives 1:2 RR."
        ),
        "notes":            (
            "Differentiating from prior attempts (PF=1.08) by: (1) adding Keltner Channel "
            "squeeze interaction with Bollinger, (2) CCI and Williams %R as confirmation, "
            "Donchian breakout detection, (3) session-aware features (London/NY/overlap), "
            "(4) richer MACD/RSI interaction flags, (5) realized volatility regime, "
            "(6) stronger XGBoost regularization (alpha=0.3, lambda=1.5, min_child=5) "
            "to reduce false signals in choppy GBP/USD conditions."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 02:54:13
# Model            : Gradient Boosting
# Feature Eng.     : EMA (9,21), RSI 14 + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/NZDUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # ── EMA 9 and EMA 21 (required) ──────────────────────────────────────────
    ema_9  = close.ewm(span=9,  adjust=False).mean()
    ema_21 = close.ewm(span=21, adjust=False).mean()

    df["ema_9"]    = ema_9
    df["ema_21"]   = ema_21
    df["dm_ema_9"]  = (close - ema_9)  / ema_9
    df["dm_ema_21"] = (close - ema_21) / ema_21

    # EMA crossover signal: positive when fast > slow
    df["ema_cross"] = ema_9 - ema_21

    # Rate of change of the crossover (momentum of the cross)
    df["ema_cross_roc"] = df["ema_cross"].diff(3)

    # ── RSI 14 (required) ────────────────────────────────────────────────────
    delta  = close.diff()
    gain   = delta.clip(lower=0)
    loss   = (-delta).clip(lower=0)
    avg_gain = gain.ewm(com=13, adjust=False).mean()
    avg_loss = loss.ewm(com=13, adjust=False).mean()
    rs     = avg_gain / avg_loss.replace(0, np.nan)
    df["rsi_14"] = 100 - (100 / (1 + rs))

    # RSI normalised to [-1, 1]
    df["rsi_norm"] = (df["rsi_14"] - 50) / 50

    # RSI momentum (1-bar diff of RSI)
    df["rsi_diff"] = df["rsi_14"].diff(1)

    # RSI overbought / oversold flags (np.where, no pd.cut)
    df["rsi_ob"] = np.where(df["rsi_14"] > 70, 1, 0)
    df["rsi_os"] = np.where(df["rsi_14"] < 30, 1, 0)

    # ── ATR 14 ───────────────────────────────────────────────────────────────
    prev_close = close.shift(1)
    tr = pd.concat([
        high - low,
        (high - prev_close).abs(),
        (low  - prev_close).abs()
    ], axis=1).max(axis=1)
    atr_14 = tr.ewm(com=13, adjust=False).mean()
    df["atr_14"]  = atr_14
    df["natr_14"] = atr_14 / close  # normalised ATR

    # ── MACD-style fast/slow difference (12/26 EMA) ─────────────────────────
    ema_12 = close.ewm(span=12, adjust=False).mean()
    ema_26 = close.ewm(span=26, adjust=False).mean()
    macd_line   = ema_12 - ema_26
    macd_signal = macd_line.ewm(span=9, adjust=False).mean()
    df["macd_line"]   = macd_line / close
    df["macd_signal"] = macd_signal / close
    df["macd_hist"]   = (macd_line - macd_signal) / close

    # ── Bollinger Bands (20, 2) ───────────────────────────────────────────────
    bb_mid  = close.rolling(20).mean()
    bb_std  = close.rolling(20).std()
    bb_up   = bb_mid + 2 * bb_std
    bb_lo   = bb_mid - 2 * bb_std
    bb_bw   = (bb_up - bb_lo) / bb_mid          # bandwidth
    bb_pct  = (close - bb_lo) / (bb_up - bb_lo) # %B position
    df["bb_bandwidth"] = bb_bw
    df["bb_pct"]       = bb_pct

    # ── Stochastic %K / %D (14, 3) ───────────────────────────────────────────
    low14  = low.rolling(14).min()
    high14 = high.rolling(14).max()
    stoch_k = 100 * (close - low14) / (high14 - low14).replace(0, np.nan)
    stoch_d = stoch_k.rolling(3).mean()
    df["stoch_k"] = stoch_k
    df["stoch_d"] = stoch_d
    df["stoch_kd_diff"] = stoch_k - stoch_d

    # ── Price momentum (returns over multiple horizons) ───────────────────────
    df["ret_1"]  = close.pct_change(1)
    df["ret_3"]  = close.pct_change(3)
    df["ret_6"]  = close.pct_change(6)
    df["ret_12"] = close.pct_change(12)

    # ── Candle body & shadow ratios ───────────────────────────────────────────
    body      = (close - open_).abs()
    candle_rng = (high - low).replace(0, np.nan)
    df["body_ratio"]       = body / candle_rng
    df["upper_shadow"]     = (high - pd.concat([close, open_], axis=1).max(axis=1)) / candle_rng
    df["lower_shadow"]     = (pd.concat([close, open_], axis=1).min(axis=1) - low) / candle_rng
    df["body_direction"]   = np.sign(close - open_)

    # ── Volume proxy: volatility-based (OHLC spread) ─────────────────────────
    df["hl_spread"] = (high - low) / close

    # ── Rolling volatility (std of returns) ──────────────────────────────────
    df["vol_6"]  = df["ret_1"].rolling(6).std()
    df["vol_24"] = df["ret_1"].rolling(24).std()

    # ── Z-score of close relative to 20-bar rolling mean ─────────────────────
    roll_mean_20 = close.rolling(20).mean()
    roll_std_20  = close.rolling(20).std()
    df["zscore_20"] = (close - roll_mean_20) / roll_std_20.replace(0, np.nan)

    # ── Trend strength: R² of close over 20 bars ─────────────────────────────
    x = np.arange(20)
    x_demeaned = x - x.mean()
    ss_x = (x_demeaned ** 2).sum()

    def rolling_r2(series, window=20):
        arr = series.values
        n   = len(arr)
        out = np.full(n, np.nan)
        for i in range(window - 1, n):
            y = arr[i - window + 1: i + 1]
            if np.any(np.isnan(y)):
                continue
            y_m = y - y.mean()
            slope = np.dot(x_demeaned, y_m) / ss_x
            y_hat = slope * x_demeaned + y.mean()
            ss_res = ((y - y_hat) ** 2).sum()
            ss_tot = ((y - y.mean()) ** 2).sum()
            out[i] = 1 - ss_res / ss_tot if ss_tot > 0 else 0.0
        return out

    df["trend_r2_20"] = rolling_r2(close, 20)

    # ── SMA 50 (for trend filter reference; also used as feature) ─────────────
    sma_50 = close.rolling(50).mean()
    df["sma_50"]       = sma_50
    df["close_vs_sma50"] = (close - sma_50) / sma_50

    # ── Higher-timeframe EMA proxy (4-bar resample = 1h equivalent) ──────────
    ema_4h = close.ewm(span=4 * 21, adjust=False).mean()
    df["dm_ema_4h"] = (close - ema_4h) / ema_4h

    # ── Cross confirmation: EMA cross direction × RSI regime ─────────────────
    df["cross_x_rsi"] = np.sign(df["ema_cross"]) * df["rsi_norm"]

    # ── Fill NaN from indicator warm-up ──────────────────────────────────────
    df = df.bfill().ffill()

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "NZD/USD EMA Cross (9/21) + RSI Gradient Boost",
        "model_type":       "GradientBoostingClassifier",
        "model_params":     {
            "n_estimators":      400,
            "max_depth":         4,
            "learning_rate":     0.04,
            "subsample":         0.75,
            "min_samples_leaf":  20,
            "max_features":      "sqrt",
            "validation_fraction": 0.1,
            "n_iter_no_change":  25,
            "tol":               1e-4,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [0, 23],
        "min_atr":          None,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective":        (
            "Maximise risk-adjusted return (Sharpe) on NZD/USD 15-min data. "
            "GradientBoostingClassifier chosen for its strong out-of-box performance on "
            "tabular financial data, built-in regularisation via subsample/max_features, "
            "and early-stopping via n_iter_no_change. Depth-4 trees with 400 estimators "
            "and lr=0.04 balance bias-variance. SL=0.5% / TP=1.0% gives 1:2 R:R. "
            "4-bar horizon (~1 hour) aligns with EMA-cross momentum persistence. "
            "Threshold 0.55 filters marginal signals while preserving trade frequency."
        ),
        "notes":            (
            "Features: EMA 9/21 cross + distances, RSI 14 with OB/OS flags, MACD histogram, "
            "Bollinger %B + bandwidth, Stochastic K/D, multi-horizon returns, candle body "
            "ratios, rolling volatility, 20-bar z-score, trend R² and SMA50 distance. "
            "No session filter applied — NZD/USD has meaningful liquidity across Asian + "
            "London sessions. Reverse on opposite signal for continuous market exposure."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 02:19:50
# Model            : XGBoost
# Feature Eng.     : EMA (50,200), ATR 14 + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/EURUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # ── EMA 50 / 200 and distance features ──────────────────────────────
    ema_50  = close.ewm(span=50,  adjust=False).mean()
    ema_200 = close.ewm(span=200, adjust=False).mean()

    df["ema_50"]    = ema_50
    df["ema_200"]   = ema_200
    df["dm_ema_50"]  = (close - ema_50)  / ema_50
    df["dm_ema_200"] = (close - ema_200) / ema_200

    # EMA cross signal: +1 when ema_50 > ema_200, -1 otherwise
    df["ema_cross"] = np.where(ema_50 > ema_200, 1.0, -1.0)

    # Spread between the two EMAs, normalised by price
    df["ema_spread"] = (ema_50 - ema_200) / close

    # Rate of change of ema_spread (momentum of the cross)
    df["ema_spread_roc"] = df["ema_spread"].diff(4)

    # ── ATR 14 & NATR ───────────────────────────────────────────────────
    prev_close = close.shift(1)
    tr = pd.concat([
        high - low,
        (high - prev_close).abs(),
        (low  - prev_close).abs()
    ], axis=1).max(axis=1)

    atr  = tr.ewm(span=14, adjust=False).mean()
    natr = atr / close

    df["atr"]  = atr
    df["natr"] = natr

    # ── RSI 14 ───────────────────────────────────────────────────────────
    delta  = close.diff()
    gain   = delta.clip(lower=0)
    loss   = (-delta).clip(lower=0)
    avg_gain = gain.ewm(span=14, adjust=False).mean()
    avg_loss = loss.ewm(span=14, adjust=False).mean()
    rs  = avg_gain / (avg_loss + 1e-12)
    rsi = 100.0 - (100.0 / (1.0 + rs))
    df["rsi_14"] = rsi
    # Normalised RSI centred around 0
    df["rsi_norm"] = (rsi - 50.0) / 50.0

    # ── MACD (12/26/9) ───────────────────────────────────────────────────
    ema_12   = close.ewm(span=12, adjust=False).mean()
    ema_26   = close.ewm(span=26, adjust=False).mean()
    macd     = ema_12 - ema_26
    signal   = macd.ewm(span=9,  adjust=False).mean()
    df["macd"]        = macd / close
    df["macd_signal"] = signal / close
    df["macd_hist"]   = (macd - signal) / close

    # ── Bollinger Bands (20, 2σ) ─────────────────────────────────────────
    bb_mid  = close.rolling(20).mean()
    bb_std  = close.rolling(20).std(ddof=0)
    bb_up   = bb_mid + 2.0 * bb_std
    bb_lo   = bb_mid - 2.0 * bb_std
    df["bb_width"] = (bb_up - bb_lo) / (bb_mid + 1e-12)
    df["bb_pct"]   = (close - bb_lo)  / (bb_up - bb_lo + 1e-12)

    # ── Price momentum (log-returns at multiple horizons) ────────────────
    for lag in [1, 4, 8, 16]:
        df[f"logret_{lag}"] = np.log(close / close.shift(lag))

    # ── Volume-less volatility proxy: high-low range / ATR ───────────────
    df["hl_range_norm"] = (high - low) / (atr + 1e-12)

    # ── Candle body and shadow ratios ────────────────────────────────────
    body  = (close - open_).abs()
    range_ = (high - low + 1e-12)
    df["body_ratio"]       = body / range_
    df["upper_shadow_ratio"] = (high - pd.concat([close, open_], axis=1).max(axis=1)) / range_
    df["lower_shadow_ratio"] = (pd.concat([close, open_], axis=1).min(axis=1) - low) / range_

    # ── Trend strength: close relative to recent N-bar high/low ──────────
    for window in [20, 50]:
        roll_hi = high.rolling(window).max()
        roll_lo = low.rolling(window).min()
        denom   = (roll_hi - roll_lo + 1e-12)
        df[f"close_rank_{window}"] = (close - roll_lo) / denom

    # ── EMA 50 slope (rate of change) ────────────────────────────────────
    df["ema_50_slope"]  = ema_50.diff(4)  / (close + 1e-12)
    df["ema_200_slope"] = ema_200.diff(8) / (close + 1e-12)

    # ── Hour-of-day and day-of-week as cyclic features ───────────────────
    if hasattr(df.index, "hour"):
        hour = df.index.hour
        dow  = df.index.dayofweek
        df["hour_sin"] = np.sin(2.0 * np.pi * hour / 24.0)
        df["hour_cos"] = np.cos(2.0 * np.pi * hour / 24.0)
        df["dow_sin"]  = np.sin(2.0 * np.pi * dow  / 5.0)
        df["dow_cos"]  = np.cos(2.0 * np.pi * dow  / 5.0)

    # ── Fill NaNs from indicator warm-up ────────────────────────────────
    df = df.bfill().ffill()

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "EUR/USD EMA Cross + ATR Momentum (XGBoost)",
        "model_type":       "XGBClassifier",
        "model_params": {
            "n_estimators":        400,
            "max_depth":           4,
            "learning_rate":       0.04,
            "subsample":           0.75,
            "colsample_bytree":    0.75,
            "min_child_weight":    3,
            "gamma":               0.1,
            "reg_alpha":           0.05,
            "reg_lambda":          1.5,
            "objective":           "binary:logistic",
            "random_state":        42,
            "n_jobs":              -1,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.010,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   [6, 20],
        "min_atr":          0.0002,
        "trend_filter":     "sma_50",
        "target_horizon":   4,
        "objective": (
            "Maximize risk-adjusted return (Sharpe) by combining EMA crossover "
            "trend regime with ATR-normalised volatility, RSI, MACD, and Bollinger "
            "features. XGBoost hyperparameters tuned for bias-variance balance: "
            "moderate depth (4), aggressive shrinkage (lr=0.04), column/row "
            "subsampling, and L1/L2 regularisation. SL=0.5% / TP=1.0% targets a "
            "2:1 reward-risk ratio. Session filter [6,20] UTC focuses on the "
            "liquid London/NY overlap. min_atr filters dead markets."
        ),
        "notes": (
            "EMA 50/200 cross provides the macro trend regime; distance features "
            "capture how far price has stretched from trend. ATR/NATR quantifies "
            "volatility regime. RSI, MACD histogram, and BB %b add mean-reversion "
            "and momentum context. Candle body ratios encode micro-structure. "
            "Cyclic time features allow the model to learn intraday seasonality. "
            "target_horizon=4 bars (1 hour on 15-min data) balances trade frequency "
            "against predictability. on_opposite=reverse reduces idle time and "
            "captures trend continuation efficiently."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 02:57:20
# Model            : Gradient Boosting
# Feature Eng.     : BB (20,2.0), ATR 14 + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# Bollinger Bands Squeeze Breakout Strategy — USD/JPY 15-min
# ============================================================

# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/USDJPY_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # ── Bollinger Bands (20, 2) ──────────────────────────────────────────────
    bb_period = 20
    bb_std    = 2.0

    bb_mid   = close.rolling(bb_period).mean()
    bb_sigma = close.rolling(bb_period).std(ddof=0)
    bb_upper = bb_mid + bb_std * bb_sigma
    bb_lower = bb_mid - bb_std * bb_sigma

    df["bb_mid"]   = bb_mid
    df["bb_upper"] = bb_upper
    df["bb_lower"] = bb_lower

    # Band width and %B — required features
    df["bb_width"] = (bb_upper - bb_lower) / bb_mid
    df["bb_pct"]   = (close - bb_lower) / (bb_upper - bb_lower)

    # ── ATR 14 & NATR ────────────────────────────────────────────────────────
    atr_period = 14
    prev_close = close.shift(1)
    tr = pd.concat([
        high - low,
        (high - prev_close).abs(),
        (low  - prev_close).abs()
    ], axis=1).max(axis=1)

    atr  = tr.ewm(span=atr_period, min_periods=atr_period, adjust=False).mean()
    natr = atr / close

    df["atr"]  = atr
    df["natr"] = natr

    # ── Squeeze detection ────────────────────────────────────────────────────
    # Keltner Channel (EMA20 ± 1.5 × ATR) for squeeze comparison
    kc_mid   = close.ewm(span=20, adjust=False).mean()
    kc_upper = kc_mid + 1.5 * atr
    kc_lower = kc_mid - 1.5 * atr

    df["squeeze"] = np.where(
        (bb_upper < kc_upper) & (bb_lower > kc_lower), 1.0, 0.0
    )

    # Rolling squeeze count (bars in squeeze over last 10 bars)
    df["squeeze_count"] = (
        df["squeeze"].rolling(10).sum()
    )

    # Band-width z-score (how compressed is the width vs recent history)
    bw_mean = df["bb_width"].rolling(50).mean()
    bw_std  = df["bb_width"].rolling(50).std(ddof=0)
    df["bb_width_zscore"] = (df["bb_width"] - bw_mean) / (bw_std + 1e-10)

    # ── Breakout momentum ────────────────────────────────────────────────────
    # Price distance from bands, normalised by ATR
    df["dist_upper"] = (close - bb_upper) / (atr + 1e-10)
    df["dist_lower"] = (close - bb_lower) / (atr + 1e-10)
    df["dist_mid"]   = (close - bb_mid)   / (atr + 1e-10)

    # ── Rate of change ────────────────────────────────────────────────────────
    for n in [1, 4, 8, 16]:
        df[f"roc_{n}"] = close.pct_change(n)

    # ── RSI 14 ───────────────────────────────────────────────────────────────
    delta  = close.diff()
    gain   = delta.clip(lower=0)
    loss   = (-delta).clip(lower=0)
    avg_g  = gain.ewm(span=14, min_periods=14, adjust=False).mean()
    avg_l  = loss.ewm(span=14, min_periods=14, adjust=False).mean()
    rs     = avg_g / (avg_l + 1e-10)
    df["rsi_14"] = 100.0 - 100.0 / (1.0 + rs)

    # RSI normalised to [-1, 1]
    df["rsi_norm"] = (df["rsi_14"] - 50.0) / 50.0

    # ── Momentum / trend context ──────────────────────────────────────────────
    ema_9  = close.ewm(span=9,  adjust=False).mean()
    ema_21 = close.ewm(span=21, adjust=False).mean()
    ema_50 = close.ewm(span=50, adjust=False).mean()

    df["ema_9_21_diff"] = (ema_9  - ema_21) / (atr + 1e-10)
    df["ema_21_50_diff"] = (ema_21 - ema_50) / (atr + 1e-10)

    # Price position relative to EMAs
    df["close_vs_ema9"]  = (close - ema_9)  / (atr + 1e-10)
    df["close_vs_ema50"] = (close - ema_50) / (atr + 1e-10)

    # ── Volume-proxy: ATR velocity ────────────────────────────────────────────
    df["atr_roc"]  = atr.pct_change(4)

    # ── MACD-style oscillator ─────────────────────────────────────────────────
    macd_line   = close.ewm(span=12, adjust=False).mean() - close.ewm(span=26, adjust=False).mean()
    macd_signal = macd_line.ewm(span=9, adjust=False).mean()
    df["macd_hist"] = (macd_line - macd_signal) / (atr + 1e-10)

    # ── Stochastic %K (14) ────────────────────────────────────────────────────
    low_14  = low.rolling(14).min()
    high_14 = high.rolling(14).max()
    df["stoch_k"] = (close - low_14) / (high_14 - low_14 + 1e-10)

    # ── Candle body / wick features ───────────────────────────────────────────
    body     = (close - open_).abs()
    candle_range = (high - low).replace(0, np.nan)
    df["body_ratio"]  = body / candle_range
    df["upper_wick"]  = (high - pd.concat([close, open_], axis=1).max(axis=1)) / (candle_range + 1e-10)
    df["lower_wick"]  = (pd.concat([close, open_], axis=1).min(axis=1) - low) / (candle_range + 1e-10)
    df["bull_candle"]  = np.where(close > open_, 1.0, 0.0)

    # ── Lagged bb_pct and bb_width ────────────────────────────────────────────
    for lag in [1, 2, 4]:
        df[f"bb_pct_lag{lag}"]   = df["bb_pct"].shift(lag)
        df[f"bb_width_lag{lag}"] = df["bb_width"].shift(lag)

    # ── Band width momentum (is it expanding?) ────────────────────────────────
    df["bb_width_chg1"] = df["bb_width"].diff(1)
    df["bb_width_chg4"] = df["bb_width"].diff(4)

    # ── Hour / session features ───────────────────────────────────────────────
    df["hour_sin"] = np.sin(2 * np.pi * df.index.hour / 24)
    df["hour_cos"] = np.cos(2 * np.pi * df.index.hour / 24)
    df["dow_sin"]  = np.sin(2 * np.pi * df.index.dayofweek / 5)
    df["dow_cos"]  = np.cos(2 * np.pi * df.index.dayofweek / 5)

    # ── Fill NaN from warm-up ─────────────────────────────────────────────────
    df = df.bfill().ffill()

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "USD/JPY BB Squeeze Breakout (GBM)",

        "model_type": "GradientBoostingClassifier",
        "model_params": {
            "n_estimators":     400,
            "max_depth":        4,
            "learning_rate":    0.04,
            "subsample":        0.75,
            "min_samples_leaf": 20,
            "max_features":     "sqrt",
            "validation_fraction": 0.1,
            "n_iter_no_change": 30,
            "tol":              1e-4,
            "random_state":     42,
        },

        "signal_threshold": 0.55,

        "direction":     "both",
        "stop_loss":     0.005,
        "take_profit":   0.010,
        "cooldown":      0,
        "max_positions": 1,
        "on_opposite":   "reverse",

        "session_filter": [6, 20],
        "min_atr":        0.0003,
        "trend_filter":   None,

        "target_horizon": 4,

        "objective": (
            "Maximize risk-adjusted return (Sharpe). "
            "GradientBoostingClassifier chosen for strong performance on tabular "
            "financial data with moderate feature counts. Deeper ensemble (400 "
            "estimators, depth 4) with early stopping captures non-linear BB "
            "squeeze patterns. Subsample=0.75 and sqrt features reduce overfitting. "
            "SL 0.5% / TP 1.0% gives 1:2 R:R ratio. Session filter 06-20 UTC covers "
            "London + NY sessions where USD/JPY liquidity is highest."
        ),
        "notes": (
            "Core signal: BB squeeze (narrow band width inside Keltner Channel) "
            "followed by band expansion. Features include band width z-score, "
            "breakout direction (dist_upper/lower), RSI, MACD histogram, "
            "stochastic %K, EMA spreads, candle structure, and lagged BB features. "
            "NATR used as min_atr filter to avoid low-volatility noise trades. "
            "Horizon=4 bars (1 hour on 15-min data) aligns with typical "
            "post-squeeze expansion duration."
        ),
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-05-06 03:16:00
# Model            : Gradient Boosting
# Feature Eng.     : EMA (50,200), ATR 14 + Auto-add features: ON
# Signal / Entry   : Enter when model confidence > threshold; exit on opposite signal or SL/TP
# Optimization     : Maximize risk-adjusted return
# Risk Mgmt        : Stop loss 0.5%, Take profit 1.0%
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

# ============================================================
# SECTION 0 — IMPORTS & CONSTANTS
import numpy as np
import pandas as pd

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/NZDUSD_15min.parquet"
START_DATE = "2025-04-24"
END_DATE   = "2026-04-24"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # ── EMA 50 and EMA 200 ──────────────────────────────────────────────────
    ema_50  = close.ewm(span=50,  adjust=False).mean()
    ema_200 = close.ewm(span=200, adjust=False).mean()

    df["ema_50"]    = ema_50
    df["ema_200"]   = ema_200
    df["dm_ema_50"]  = (close - ema_50)  / ema_50
    df["dm_ema_200"] = (close - ema_200) / ema_200

    # EMA cross signal: ema_50 vs ema_200
    df["ema_cross"] = df["ema_50"] - df["ema_200"]

    # Cross direction: +1 when ema_50 > ema_200, -1 otherwise
    df["ema_cross_sign"] = np.where(df["ema_cross"] > 0, 1.0, -1.0)

    # Cross event: 1 when cross just happened (sign flip)
    prev_cross = df["ema_cross"].shift(1)
    df["ema_cross_event"] = np.where(
        (df["ema_cross"] * prev_cross) < 0, 1.0, 0.0
    )

    # ── ATR 14 ──────────────────────────────────────────────────────────────
    prev_close = close.shift(1)
    tr = pd.concat([
        high - low,
        (high - prev_close).abs(),
        (low  - prev_close).abs()
    ], axis=1).max(axis=1)

    atr = tr.ewm(span=14, adjust=False).mean()
    df["atr"]  = atr
    df["natr"] = atr / close

    # ── RSI 14 ──────────────────────────────────────────────────────────────
    delta  = close.diff()
    gain   = delta.clip(lower=0)
    loss   = (-delta).clip(lower=0)
    avg_gain = gain.ewm(span=14, adjust=False).mean()
    avg_loss = loss.ewm(span=14, adjust=False).mean()
    rs  = avg_gain / (avg_loss + 1e-10)
    rsi = 100 - (100 / (1 + rs))
    df["rsi_14"] = rsi
    df["rsi_norm"] = (rsi - 50) / 50   # centred and scaled

    # ── MACD ────────────────────────────────────────────────────────────────
    ema_12   = close.ewm(span=12, adjust=False).mean()
    ema_26   = close.ewm(span=26, adjust=False).mean()
    macd     = ema_12 - ema_26
    signal   = macd.ewm(span=9, adjust=False).mean()
    df["macd"]         = macd
    df["macd_signal"]  = signal
    df["macd_hist"]    = macd - signal
    df["macd_norm"]    = macd / close
    df["macd_hist_norm"] = (macd - signal) / close

    # ── Bollinger Bands (20, 2) ──────────────────────────────────────────────
    sma_20  = close.rolling(20).mean()
    std_20  = close.rolling(20).std()
    bb_upper = sma_20 + 2 * std_20
    bb_lower = sma_20 - 2 * std_20
    bb_width = (bb_upper - bb_lower) / (sma_20 + 1e-10)
    bb_pos   = (close - bb_lower) / (bb_upper - bb_lower + 1e-10)
    df["bb_width"] = bb_width
    df["bb_pos"]   = bb_pos

    # ── Momentum & Rate-of-Change ────────────────────────────────────────────
    df["mom_4"]  = close.pct_change(4)
    df["mom_8"]  = close.pct_change(8)
    df["mom_16"] = close.pct_change(16)

    # ── Rolling volatility (realised vol over 20 bars) ──────────────────────
    log_ret = np.log(close / close.shift(1))
    df["rvol_20"] = log_ret.rolling(20).std()

    # ── Stochastic Oscillator (14) ───────────────────────────────────────────
    low_14  = low.rolling(14).min()
    high_14 = high.rolling(14).max()
    stoch_k = 100 * (close - low_14) / (high_14 - low_14 + 1e-10)
    stoch_d = stoch_k.rolling(3).mean()
    df["stoch_k"] = stoch_k
    df["stoch_d"] = stoch_d
    df["stoch_diff"] = stoch_k - stoch_d

    # ── Candle body / range features ────────────────────────────────────────
    df["body"]       = (close - open_).abs() / (high - low + 1e-10)
    df["upper_wick"] = (high - close.clip(lower=open_)) / (high - low + 1e-10)
    df["lower_wick"] = (close.clip(upper=open_) - low)  / (high - low + 1e-10)
    df["bar_dir"]    = np.where(close > open_, 1.0, -1.0)

    # ── Price position relative to EMAs ─────────────────────────────────────
    df["close_vs_ema50_sign"]  = np.where(close > ema_50,  1.0, -1.0)
    df["close_vs_ema200_sign"] = np.where(close > ema_200, 1.0, -1.0)

    # ── Lagged features (1-bar and 2-bar lags on key signals) ───────────────
    for col in ["rsi_norm", "macd_hist_norm", "mom_4", "ema_cross", "natr", "bb_pos"]:
        df[f"{col}_lag1"] = df[col].shift(1)
        df[f"{col}_lag2"] = df[col].shift(2)

    # ── Fill NaN from warm-up ────────────────────────────────────────────────
    df = df.bfill().ffill()

    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title":            "NZD/USD EMA Cross + ATR Gradient Boosting",
        "model_type":       "GradientBoostingClassifier",
        "model_params":     {
            "n_estimators":       400,
            "max_depth":          4,
            "learning_rate":      0.03,
            "subsample":          0.8,
            "min_samples_leaf":   20,
            "max_features":       "sqrt",
            "validation_fraction": 0.1,
            "n_iter_no_change":   30,
            "tol":                1e-4,
        },
        "signal_threshold": 0.55,
        "direction":        "both",
        "stop_loss":        0.005,
        "take_profit":      0.01,
        "cooldown":         0,
        "max_positions":    1,
        "on_opposite":      "reverse",
        "session_filter":   None,
        "min_atr":          None,
        "trend_filter":     None,
        "target_horizon":   4,
        "objective": (
            "Maximize risk-adjusted return (Sharpe / Calmar). "
            "GradientBoostingClassifier with moderate depth (4) and low learning rate (0.03) "
            "to reduce overfitting on 15-min NZD/USD. SL=0.5%, TP=1.0% gives 1:2 RR. "
            "EMA 50/200 cross is the primary trend feature; ATR normalises volatility context. "
            "Supplementary RSI, MACD, Bollinger, Stochastic and candle-body features capture "
            "momentum and mean-reversion signals. Early stopping via n_iter_no_change guards "
            "against overfit on the training partition."
        ),
        "notes": (
            "target_horizon=4 (1 hour) matches typical intraday swing on NZD/USD. "
            "reverse on opposite signal keeps the model responsive during trending regimes. "
            "No session filter applied — NZD/USD has reasonable liquidity around the clock. "
            "min_samples_leaf=20 and subsample=0.8 add regularisation without grid search."
        ),
    }