Community Scripts

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-06 15:14:19
# Model            : Random Forest
# Feature Eng.     : EMA 20/50 cross, SMA 200, RSI 7, ATR 14, Keltner (20,2.0), EMA ribbon 8-55, Session/time features
# Signal / Entry   : Buy dips / sell rallies inside an established trend when the fast RSI resets
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 15 pips, Take profit 30 pips
# Risk Filter      : session [7, 20] UTC, trend ema_50
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/USDCAD_5min.parquet"
START_DATE = "2026-07-28"
END_DATE   = "2026-09-06"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 15.0
TAKE_PROFIT = 30.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- EMA 20/50 crossover ---
    _ea = close.ewm(span=20, adjust=False).mean()
    _eb = close.ewm(span=50, adjust=False).mean()
    df["ema_20_50_diff"] = (_ea - _eb) / close * 1e4
    df["ema_20_50_diff_chg"] = df["ema_20_50_diff"].diff(1)
    df["ema_20_50_cross_up"] = ((_ea > _eb) & (_ea.shift(1) <= _eb.shift(1))).astype(float)
    df["ema_20_50_cross_dn"] = ((_ea < _eb) & (_ea.shift(1) >= _eb.shift(1))).astype(float)
    df["close_vs_ema_20"] = close / _ea - 1.0
    # --- SMA(200) distance & slope ---
    _s = close.rolling(200).mean()
    df["sma_200_dist"] = close / _s - 1.0
    df["sma_200_slope"] = _s.pct_change(3)
    # --- RSI(7) with zone flags and slope ---
    _d = close.diff()
    _g = _d.clip(lower=0).ewm(com=6, min_periods=7, adjust=False).mean()
    _l = (-_d.clip(upper=0)).ewm(com=6, min_periods=7, adjust=False).mean()
    _rsi = 100.0 - 100.0 / (1.0 + _g / (_l + 1e-10))
    df["rsi_7"] = _rsi
    df["rsi_7_os"] = (_rsi < 30).astype(float)
    df["rsi_7_ob"] = (_rsi > 70).astype(float)
    df["rsi_7_slope"] = _rsi.diff(2)
    # --- ATR(14) normalised ---
    _tr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr = _tr.ewm(alpha=1.0/14, adjust=False).mean()
    df["atr_14_pct"] = _atr / close
    df["atr_14_ratio"] = _atr / (_atr.rolling(56).mean() + 1e-12)
    # --- Keltner channel(20,2.0) position ---
    _kmid = close.ewm(span=20, adjust=False).mean()
    _ktr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _katr = _ktr.ewm(alpha=1.0/20, adjust=False).mean()
    df["kelt_20_pos"] = (close - _kmid) / (2.0 * _katr + 1e-12)
    # --- EMA ribbon alignment (8/13/21/34/55) ---
    _es = [close.ewm(span=_n, adjust=False).mean() for _n in (8, 13, 21, 34, 55)]
    df["ribbon_align"] = sum(((_es[_i] > _es[_i + 1]).astype(float) * 2 - 1) for _i in range(4))
    df["ribbon_spread"] = (_es[0] - _es[-1]) / close * 1e4
    # --- Time-of-day / day-of-week (UTC) ---
    _h = df.index.hour + df.index.minute / 60.0
    df["hour_sin"] = np.sin(2 * np.pi * _h / 24.0)
    df["hour_cos"] = np.cos(2 * np.pi * _h / 24.0)
    df["dow"] = df.index.dayofweek.astype(float)
    df["london_open"] = ((df.index.hour >= 7) & (df.index.hour < 10)).astype(float)
    df["ny_open"] = ((df.index.hour >= 13) & (df.index.hour < 16)).astype(float)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "USD/CAD Trend Pullback Random Forest 5min",
        "model_type": "RandomForestClassifier",
        "model_params": {
                "n_estimators": 400,
                "max_depth": 5,
                "min_samples_leaf": 5,
                "max_features": "sqrt",
                "random_state": 42,
                "n_jobs": 1
        },
        "signal_threshold": 0.55,
        "direction": "both",
        "stop_loss": 15.0,
        "take_profit": 30.0,
        "risk_unit": "pips",
        "cooldown": 0,
        "max_positions": 1,
        "on_opposite": "reverse",
        "session_filter": [
                7,
                20
        ],
        "min_atr": None,
        "trend_filter": "ema_50",
        "target_horizon": 5,
        "objective": "Trend Pullback strategy on USD/CAD 5min: Buy dips / sell rallies inside an established trend when the fast RSI resets. Features: EMA 20/50 cross, SMA 200, RSI 7, ATR 14, Keltner (20,2.0), EMA ribbon 8-55, Session/time features. Model: Random Forest. Label horizon 5 bars, confidence threshold 0.55, direction both. Risk: 15 pip stop / 30 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-06 15:33:05
# Model            : Random Forest
# Feature Eng.     : Stochastic (21,5), EMA 12/26 cross, ATR 10, ADX 14
# Signal / Entry   : API-default style: randomly composed indicator set, model learns the rule
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# 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 = "2026-07-28"
END_DATE   = "2026-09-06"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- Stochastic(21,5) ---
    _ll = low.rolling(21).min()
    _hh = high.rolling(21).max()
    _k = 100.0 * (close - _ll) / (_hh - _ll + 1e-10)
    df["stoch_k_21"] = _k
    df["stoch_d_21"] = _k.rolling(5).mean()
    df["stoch_21_diff"] = df["stoch_k_21"] - df["stoch_d_21"]
    # --- EMA 12/26 crossover ---
    _ea = close.ewm(span=12, adjust=False).mean()
    _eb = close.ewm(span=26, adjust=False).mean()
    df["ema_12_26_diff"] = (_ea - _eb) / close * 1e4
    df["ema_12_26_diff_chg"] = df["ema_12_26_diff"].diff(1)
    df["ema_12_26_cross_up"] = ((_ea > _eb) & (_ea.shift(1) <= _eb.shift(1))).astype(float)
    df["ema_12_26_cross_dn"] = ((_ea < _eb) & (_ea.shift(1) >= _eb.shift(1))).astype(float)
    df["close_vs_ema_12"] = close / _ea - 1.0
    # --- ATR(10) normalised ---
    _tr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr = _tr.ewm(alpha=1.0/10, adjust=False).mean()
    df["atr_10_pct"] = _atr / close
    df["atr_10_ratio"] = _atr / (_atr.rolling(40).mean() + 1e-12)
    # --- ADX(14) with +DI/-DI ---
    _up = high.diff()
    _dn = -low.diff()
    _pdm = pd.Series(np.where((_up > _dn) & (_up > 0), _up, 0.0), index=df.index)
    _ndm = pd.Series(np.where((_dn > _up) & (_dn > 0), _dn, 0.0), index=df.index)
    _tr2 = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr2 = _tr2.ewm(alpha=1.0/14, adjust=False).mean()
    _pdi = 100.0 * _pdm.ewm(alpha=1.0/14, adjust=False).mean() / (_atr2 + 1e-12)
    _ndi = 100.0 * _ndm.ewm(alpha=1.0/14, adjust=False).mean() / (_atr2 + 1e-12)
    _dx = 100.0 * (_pdi - _ndi).abs() / (_pdi + _ndi + 1e-12)
    df["adx_14"] = _dx.ewm(alpha=1.0/14, adjust=False).mean()
    df["di_diff_14"] = _pdi - _ndi

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "NZD/USD Random Mix Random Forest 15min",
        "model_type": "RandomForestClassifier",
        "model_params": {
                "n_estimators": 400,
                "max_depth": 5,
                "min_samples_leaf": 10,
                "max_features": "sqrt",
                "random_state": 42,
                "n_jobs": 1
        },
        "signal_threshold": 0.55,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 0,
        "max_positions": 1,
        "on_opposite": "close_only",
        "session_filter": None,
        "min_atr": None,
        "trend_filter": None,
        "target_horizon": 2,
        "objective": "Random Mix strategy on NZD/USD 15min: API-default style: randomly composed indicator set, model learns the rule. Features: Stochastic (21,5), EMA 12/26 cross, ATR 10, ADX 14. Model: Random Forest. Label horizon 2 bars, confidence threshold 0.55, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-09 01:34:17
# Model            : LightGBM
# Feature Eng.     : RSI 14, MACD (12,26,9), BB (20,2.0), Stochastic (14,3), ATR 14, ADX 14, EMA 9/21 cross, Candle structure, Return lags 1-3, Session/time features
# Signal / Entry   : Broad indicator set; gradient-boosted model learns the entry rule
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# Risk Filter      : session [7, 20] UTC
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/EURUSD_1h.parquet"
START_DATE = "2026-07-31"
END_DATE   = "2026-09-09"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- RSI(14) with zone flags and slope ---
    _d = close.diff()
    _g = _d.clip(lower=0).ewm(com=13, min_periods=14, adjust=False).mean()
    _l = (-_d.clip(upper=0)).ewm(com=13, min_periods=14, adjust=False).mean()
    _rsi = 100.0 - 100.0 / (1.0 + _g / (_l + 1e-10))
    df["rsi_14"] = _rsi
    df["rsi_14_os"] = (_rsi < 30).astype(float)
    df["rsi_14_ob"] = (_rsi > 70).astype(float)
    df["rsi_14_slope"] = _rsi.diff(2)
    # --- MACD(12,26,9) ---
    _m = close.ewm(span=12, adjust=False).mean() - close.ewm(span=26, adjust=False).mean()
    _sig = _m.ewm(span=9, adjust=False).mean()
    df["macd_12_26"] = _m / close * 1e4
    df["macd_12_26_sig"] = _sig / close * 1e4
    df["macd_12_26_hist"] = (_m - _sig) / close * 1e4
    df["macd_12_26_hist_chg"] = df["macd_12_26_hist"].diff(1)
    # --- Bollinger Bands(20,2.0) ---
    _mid = close.rolling(20).mean()
    _sd = close.rolling(20).std()
    df["bb_20_2p0_pctb"] = (close - (_mid - 2.0 * _sd)) / (2 * 2.0 * _sd + 1e-10)
    df["bb_20_2p0_width"] = (2 * 2.0 * _sd) / (_mid + 1e-10)
    df["bb_20_2p0_width_chg"] = df["bb_20_2p0_width"].pct_change(3)
    # --- Stochastic(14,3) ---
    _ll = low.rolling(14).min()
    _hh = high.rolling(14).max()
    _k = 100.0 * (close - _ll) / (_hh - _ll + 1e-10)
    df["stoch_k_14"] = _k
    df["stoch_d_14"] = _k.rolling(3).mean()
    df["stoch_14_diff"] = df["stoch_k_14"] - df["stoch_d_14"]
    # --- ATR(14) normalised ---
    _tr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr = _tr.ewm(alpha=1.0/14, adjust=False).mean()
    df["atr_14_pct"] = _atr / close
    df["atr_14_ratio"] = _atr / (_atr.rolling(56).mean() + 1e-12)
    # --- ADX(14) with +DI/-DI ---
    _up = high.diff()
    _dn = -low.diff()
    _pdm = pd.Series(np.where((_up > _dn) & (_up > 0), _up, 0.0), index=df.index)
    _ndm = pd.Series(np.where((_dn > _up) & (_dn > 0), _dn, 0.0), index=df.index)
    _tr2 = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr2 = _tr2.ewm(alpha=1.0/14, adjust=False).mean()
    _pdi = 100.0 * _pdm.ewm(alpha=1.0/14, adjust=False).mean() / (_atr2 + 1e-12)
    _ndi = 100.0 * _ndm.ewm(alpha=1.0/14, adjust=False).mean() / (_atr2 + 1e-12)
    _dx = 100.0 * (_pdi - _ndi).abs() / (_pdi + _ndi + 1e-12)
    df["adx_14"] = _dx.ewm(alpha=1.0/14, adjust=False).mean()
    df["di_diff_14"] = _pdi - _ndi
    # --- EMA 9/21 crossover ---
    _ea = close.ewm(span=9, adjust=False).mean()
    _eb = close.ewm(span=21, adjust=False).mean()
    df["ema_9_21_diff"] = (_ea - _eb) / close * 1e4
    df["ema_9_21_diff_chg"] = df["ema_9_21_diff"].diff(1)
    df["ema_9_21_cross_up"] = ((_ea > _eb) & (_ea.shift(1) <= _eb.shift(1))).astype(float)
    df["ema_9_21_cross_dn"] = ((_ea < _eb) & (_ea.shift(1) >= _eb.shift(1))).astype(float)
    df["close_vs_ema_9"] = close / _ea - 1.0
    # --- Candle structure ---
    _rng = (high - low) + 1e-12
    df["body"] = (close - open_) / _rng
    df["upper_wick"] = (high - np.maximum(close, open_)) / _rng
    df["lower_wick"] = (np.minimum(close, open_) - low) / _rng
    df["range_pct"] = _rng / close
    df["range_rel"] = _rng / (_rng.rolling(20).mean() + 1e-12)
    # --- Return lags 1..3 ---
    _r = close.pct_change() * 1e4
    for _i in range(1, 4):
        df[f"ret_lag_{_i}"] = _r.shift(_i - 1)
    df["ret_sum_3"] = _r.rolling(3).sum()
    # --- Time-of-day / day-of-week (UTC) ---
    _h = df.index.hour + df.index.minute / 60.0
    df["hour_sin"] = np.sin(2 * np.pi * _h / 24.0)
    df["hour_cos"] = np.cos(2 * np.pi * _h / 24.0)
    df["dow"] = df.index.dayofweek.astype(float)
    df["london_open"] = ((df.index.hour >= 7) & (df.index.hour < 10)).astype(float)
    df["ny_open"] = ((df.index.hour >= 13) & (df.index.hour < 16)).astype(float)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "EUR/USD Multi-Indicator LightGBM 1h",
        "model_type": "LGBMClassifier",
        "model_params": {
                "n_estimators": 200,
                "num_leaves": 31,
                "learning_rate": 0.02,
                "subsample": 0.8,
                "subsample_freq": 1,
                "colsample_bytree": 0.8,
                "min_child_samples": 20,
                "reg_lambda": 1.0,
                "random_state": 42,
                "n_jobs": 1,
                "verbose": -1
        },
        "signal_threshold": 0.55,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 1,
        "max_positions": 1,
        "on_opposite": "reverse",
        "session_filter": [
                7,
                20
        ],
        "min_atr": None,
        "trend_filter": None,
        "target_horizon": 3,
        "objective": "Multi-Indicator strategy on EUR/USD 1h: Broad indicator set; gradient-boosted model learns the entry rule. Features: RSI 14, MACD (12,26,9), BB (20,2.0), Stochastic (14,3), ATR 14, ADX 14, EMA 9/21 cross, Candle structure, Return lags 1-3, Session/time features. Model: LightGBM. Label horizon 3 bars, confidence threshold 0.55, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-09 01:03:05
# Model            : Random Forest
# Feature Eng.     : Keltner (20,2.0), Session/time features, ADX 14, Return lags 1-3, MACD (12,26,9)
# Signal / Entry   : API-default style: randomly composed indicator set, model learns the rule
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# 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 = "2026-07-31"
END_DATE   = "2026-09-09"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- Keltner channel(20,2.0) position ---
    _kmid = close.ewm(span=20, adjust=False).mean()
    _ktr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _katr = _ktr.ewm(alpha=1.0/20, adjust=False).mean()
    df["kelt_20_pos"] = (close - _kmid) / (2.0 * _katr + 1e-12)
    # --- Time-of-day / day-of-week (UTC) ---
    _h = df.index.hour + df.index.minute / 60.0
    df["hour_sin"] = np.sin(2 * np.pi * _h / 24.0)
    df["hour_cos"] = np.cos(2 * np.pi * _h / 24.0)
    df["dow"] = df.index.dayofweek.astype(float)
    df["london_open"] = ((df.index.hour >= 7) & (df.index.hour < 10)).astype(float)
    df["ny_open"] = ((df.index.hour >= 13) & (df.index.hour < 16)).astype(float)
    # --- ADX(14) with +DI/-DI ---
    _up = high.diff()
    _dn = -low.diff()
    _pdm = pd.Series(np.where((_up > _dn) & (_up > 0), _up, 0.0), index=df.index)
    _ndm = pd.Series(np.where((_dn > _up) & (_dn > 0), _dn, 0.0), index=df.index)
    _tr2 = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr2 = _tr2.ewm(alpha=1.0/14, adjust=False).mean()
    _pdi = 100.0 * _pdm.ewm(alpha=1.0/14, adjust=False).mean() / (_atr2 + 1e-12)
    _ndi = 100.0 * _ndm.ewm(alpha=1.0/14, adjust=False).mean() / (_atr2 + 1e-12)
    _dx = 100.0 * (_pdi - _ndi).abs() / (_pdi + _ndi + 1e-12)
    df["adx_14"] = _dx.ewm(alpha=1.0/14, adjust=False).mean()
    df["di_diff_14"] = _pdi - _ndi
    # --- Return lags 1..3 ---
    _r = close.pct_change() * 1e4
    for _i in range(1, 4):
        df[f"ret_lag_{_i}"] = _r.shift(_i - 1)
    df["ret_sum_3"] = _r.rolling(3).sum()
    # --- MACD(12,26,9) ---
    _m = close.ewm(span=12, adjust=False).mean() - close.ewm(span=26, adjust=False).mean()
    _sig = _m.ewm(span=9, adjust=False).mean()
    df["macd_12_26"] = _m / close * 1e4
    df["macd_12_26_sig"] = _sig / close * 1e4
    df["macd_12_26_hist"] = (_m - _sig) / close * 1e4
    df["macd_12_26_hist_chg"] = df["macd_12_26_hist"].diff(1)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "USD/CHF Random Mix Random Forest 15min",
        "model_type": "RandomForestClassifier",
        "model_params": {
                "n_estimators": 200,
                "max_depth": 8,
                "min_samples_leaf": 5,
                "max_features": "sqrt",
                "random_state": 42,
                "n_jobs": 1
        },
        "signal_threshold": 0.6,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 1,
        "max_positions": 1,
        "on_opposite": "reverse",
        "session_filter": None,
        "min_atr": None,
        "trend_filter": None,
        "target_horizon": 6,
        "objective": "Random Mix strategy on USD/CHF 15min: API-default style: randomly composed indicator set, model learns the rule. Features: Keltner (20,2.0), Session/time features, ADX 14, Return lags 1-3, MACD (12,26,9). Model: Random Forest. Label horizon 6 bars, confidence threshold 0.60, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-06 15:33:05
# Model            : XGBoost
# Feature Eng.     : EMA 20/50 cross, SMA 200, RSI 7, ATR 14, Keltner (20,2.0), EMA ribbon 8-55, Session/time features
# Signal / Entry   : Buy dips / sell rallies inside an established trend when the fast RSI resets
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# Risk Filter      : session [7, 20] UTC, trend sma_200
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/USDJPY_15min.parquet"
START_DATE = "2026-07-28"
END_DATE   = "2026-09-06"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- EMA 20/50 crossover ---
    _ea = close.ewm(span=20, adjust=False).mean()
    _eb = close.ewm(span=50, adjust=False).mean()
    df["ema_20_50_diff"] = (_ea - _eb) / close * 1e4
    df["ema_20_50_diff_chg"] = df["ema_20_50_diff"].diff(1)
    df["ema_20_50_cross_up"] = ((_ea > _eb) & (_ea.shift(1) <= _eb.shift(1))).astype(float)
    df["ema_20_50_cross_dn"] = ((_ea < _eb) & (_ea.shift(1) >= _eb.shift(1))).astype(float)
    df["close_vs_ema_20"] = close / _ea - 1.0
    # --- SMA(200) distance & slope ---
    _s = close.rolling(200).mean()
    df["sma_200_dist"] = close / _s - 1.0
    df["sma_200_slope"] = _s.pct_change(3)
    # --- RSI(7) with zone flags and slope ---
    _d = close.diff()
    _g = _d.clip(lower=0).ewm(com=6, min_periods=7, adjust=False).mean()
    _l = (-_d.clip(upper=0)).ewm(com=6, min_periods=7, adjust=False).mean()
    _rsi = 100.0 - 100.0 / (1.0 + _g / (_l + 1e-10))
    df["rsi_7"] = _rsi
    df["rsi_7_os"] = (_rsi < 30).astype(float)
    df["rsi_7_ob"] = (_rsi > 70).astype(float)
    df["rsi_7_slope"] = _rsi.diff(2)
    # --- ATR(14) normalised ---
    _tr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr = _tr.ewm(alpha=1.0/14, adjust=False).mean()
    df["atr_14_pct"] = _atr / close
    df["atr_14_ratio"] = _atr / (_atr.rolling(56).mean() + 1e-12)
    # --- Keltner channel(20,2.0) position ---
    _kmid = close.ewm(span=20, adjust=False).mean()
    _ktr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _katr = _ktr.ewm(alpha=1.0/20, adjust=False).mean()
    df["kelt_20_pos"] = (close - _kmid) / (2.0 * _katr + 1e-12)
    # --- EMA ribbon alignment (8/13/21/34/55) ---
    _es = [close.ewm(span=_n, adjust=False).mean() for _n in (8, 13, 21, 34, 55)]
    df["ribbon_align"] = sum(((_es[_i] > _es[_i + 1]).astype(float) * 2 - 1) for _i in range(4))
    df["ribbon_spread"] = (_es[0] - _es[-1]) / close * 1e4
    # --- Time-of-day / day-of-week (UTC) ---
    _h = df.index.hour + df.index.minute / 60.0
    df["hour_sin"] = np.sin(2 * np.pi * _h / 24.0)
    df["hour_cos"] = np.cos(2 * np.pi * _h / 24.0)
    df["dow"] = df.index.dayofweek.astype(float)
    df["london_open"] = ((df.index.hour >= 7) & (df.index.hour < 10)).astype(float)
    df["ny_open"] = ((df.index.hour >= 13) & (df.index.hour < 16)).astype(float)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "USD/JPY Trend Pullback XGBoost 15min",
        "model_type": "XGBClassifier",
        "model_params": {
                "n_estimators": 400,
                "max_depth": 3,
                "learning_rate": 0.03,
                "subsample": 0.7,
                "colsample_bytree": 0.8,
                "min_child_weight": 3,
                "reg_lambda": 3.0,
                "gamma": 0.0,
                "objective": "binary:logistic",
                "tree_method": "hist",
                "random_state": 42,
                "n_jobs": 1
        },
        "signal_threshold": 0.55,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 0,
        "max_positions": 1,
        "on_opposite": "reverse",
        "session_filter": [
                7,
                20
        ],
        "min_atr": None,
        "trend_filter": "sma_200",
        "target_horizon": 8,
        "objective": "Trend Pullback strategy on USD/JPY 15min: Buy dips / sell rallies inside an established trend when the fast RSI resets. Features: EMA 20/50 cross, SMA 200, RSI 7, ATR 14, Keltner (20,2.0), EMA ribbon 8-55, Session/time features. Model: XGBoost. Label horizon 8 bars, confidence threshold 0.55, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-06 15:33:05
# Model            : XGBoost
# Feature Eng.     : RSI 7, BB (14,2.0), Z-score 50, Stochastic (14,3), Candle structure, Session/time features
# Signal / Entry   : Fade RSI/Bollinger extremes back toward the mean; classifier decides direction
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# Risk Filter      : session [12, 21] UTC
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/USDCHF_1h.parquet"
START_DATE = "2026-07-28"
END_DATE   = "2026-09-06"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- RSI(7) with zone flags and slope ---
    _d = close.diff()
    _g = _d.clip(lower=0).ewm(com=6, min_periods=7, adjust=False).mean()
    _l = (-_d.clip(upper=0)).ewm(com=6, min_periods=7, adjust=False).mean()
    _rsi = 100.0 - 100.0 / (1.0 + _g / (_l + 1e-10))
    df["rsi_7"] = _rsi
    df["rsi_7_os"] = (_rsi < 30).astype(float)
    df["rsi_7_ob"] = (_rsi > 70).astype(float)
    df["rsi_7_slope"] = _rsi.diff(2)
    # --- Bollinger Bands(14,2.0) ---
    _mid = close.rolling(14).mean()
    _sd = close.rolling(14).std()
    df["bb_14_2p0_pctb"] = (close - (_mid - 2.0 * _sd)) / (2 * 2.0 * _sd + 1e-10)
    df["bb_14_2p0_width"] = (2 * 2.0 * _sd) / (_mid + 1e-10)
    df["bb_14_2p0_width_chg"] = df["bb_14_2p0_width"].pct_change(3)
    # --- Z-score(50) of close ---
    df["zscore_50"] = (close - close.rolling(50).mean()) / (close.rolling(50).std() + 1e-12)
    df["zscore_50_chg"] = df["zscore_50"].diff(1)
    # --- Stochastic(14,3) ---
    _ll = low.rolling(14).min()
    _hh = high.rolling(14).max()
    _k = 100.0 * (close - _ll) / (_hh - _ll + 1e-10)
    df["stoch_k_14"] = _k
    df["stoch_d_14"] = _k.rolling(3).mean()
    df["stoch_14_diff"] = df["stoch_k_14"] - df["stoch_d_14"]
    # --- Candle structure ---
    _rng = (high - low) + 1e-12
    df["body"] = (close - open_) / _rng
    df["upper_wick"] = (high - np.maximum(close, open_)) / _rng
    df["lower_wick"] = (np.minimum(close, open_) - low) / _rng
    df["range_pct"] = _rng / close
    df["range_rel"] = _rng / (_rng.rolling(20).mean() + 1e-12)
    # --- Time-of-day / day-of-week (UTC) ---
    _h = df.index.hour + df.index.minute / 60.0
    df["hour_sin"] = np.sin(2 * np.pi * _h / 24.0)
    df["hour_cos"] = np.cos(2 * np.pi * _h / 24.0)
    df["dow"] = df.index.dayofweek.astype(float)
    df["london_open"] = ((df.index.hour >= 7) & (df.index.hour < 10)).astype(float)
    df["ny_open"] = ((df.index.hour >= 13) & (df.index.hour < 16)).astype(float)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "USD/CHF Mean-Reversion XGBoost 1h",
        "model_type": "XGBClassifier",
        "model_params": {
                "n_estimators": 150,
                "max_depth": 4,
                "learning_rate": 0.05,
                "subsample": 0.8,
                "colsample_bytree": 0.8,
                "min_child_weight": 5,
                "reg_lambda": 2.0,
                "gamma": 0.0,
                "objective": "binary:logistic",
                "tree_method": "hist",
                "random_state": 42,
                "n_jobs": 1
        },
        "signal_threshold": 0.55,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 1,
        "max_positions": 1,
        "on_opposite": "reverse",
        "session_filter": [
                12,
                21
        ],
        "min_atr": None,
        "trend_filter": None,
        "target_horizon": 2,
        "objective": "Mean-Reversion strategy on USD/CHF 1h: Fade RSI/Bollinger extremes back toward the mean; classifier decides direction. Features: RSI 7, BB (14,2.0), Z-score 50, Stochastic (14,3), Candle structure, Session/time features. Model: XGBoost. Label horizon 2 bars, confidence threshold 0.55, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-09 01:03:13
# Model            : XGBoost
# Feature Eng.     : MACD (5,13,3), Williams %R 14, Keltner (20,2.0), EMA 5/13 cross, BB (20,2.0)
# Signal / Entry   : API-default style: randomly composed indicator set, model learns the rule
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# Risk Filter      : —
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/EURUSD_1h.parquet"
START_DATE = "2026-07-31"
END_DATE   = "2026-09-09"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- MACD(5,13,3) ---
    _m = close.ewm(span=5, adjust=False).mean() - close.ewm(span=13, adjust=False).mean()
    _sig = _m.ewm(span=3, adjust=False).mean()
    df["macd_5_13"] = _m / close * 1e4
    df["macd_5_13_sig"] = _sig / close * 1e4
    df["macd_5_13_hist"] = (_m - _sig) / close * 1e4
    df["macd_5_13_hist_chg"] = df["macd_5_13_hist"].diff(1)
    # --- Williams %R(14) ---
    _hh2 = high.rolling(14).max()
    _ll2 = low.rolling(14).min()
    df["willr_14"] = -100.0 * (_hh2 - close) / (_hh2 - _ll2 + 1e-10)
    # --- Keltner channel(20,2.0) position ---
    _kmid = close.ewm(span=20, adjust=False).mean()
    _ktr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _katr = _ktr.ewm(alpha=1.0/20, adjust=False).mean()
    df["kelt_20_pos"] = (close - _kmid) / (2.0 * _katr + 1e-12)
    # --- EMA 5/13 crossover ---
    _ea = close.ewm(span=5, adjust=False).mean()
    _eb = close.ewm(span=13, adjust=False).mean()
    df["ema_5_13_diff"] = (_ea - _eb) / close * 1e4
    df["ema_5_13_diff_chg"] = df["ema_5_13_diff"].diff(1)
    df["ema_5_13_cross_up"] = ((_ea > _eb) & (_ea.shift(1) <= _eb.shift(1))).astype(float)
    df["ema_5_13_cross_dn"] = ((_ea < _eb) & (_ea.shift(1) >= _eb.shift(1))).astype(float)
    df["close_vs_ema_5"] = close / _ea - 1.0
    # --- Bollinger Bands(20,2.0) ---
    _mid = close.rolling(20).mean()
    _sd = close.rolling(20).std()
    df["bb_20_2p0_pctb"] = (close - (_mid - 2.0 * _sd)) / (2 * 2.0 * _sd + 1e-10)
    df["bb_20_2p0_width"] = (2 * 2.0 * _sd) / (_mid + 1e-10)
    df["bb_20_2p0_width_chg"] = df["bb_20_2p0_width"].pct_change(3)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "EUR/USD Random Mix XGBoost 1h",
        "model_type": "XGBClassifier",
        "model_params": {
                "n_estimators": 150,
                "max_depth": 5,
                "learning_rate": 0.08,
                "subsample": 0.8,
                "colsample_bytree": 0.8,
                "min_child_weight": 3,
                "reg_lambda": 2.0,
                "gamma": 0.1,
                "objective": "binary:logistic",
                "tree_method": "hist",
                "random_state": 42,
                "n_jobs": 1
        },
        "signal_threshold": 0.55,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 0,
        "max_positions": 1,
        "on_opposite": "close_only",
        "session_filter": None,
        "min_atr": None,
        "trend_filter": None,
        "target_horizon": 2,
        "objective": "Random Mix strategy on EUR/USD 1h: API-default style: randomly composed indicator set, model learns the rule. Features: MACD (5,13,3), Williams %R 14, Keltner (20,2.0), EMA 5/13 cross, BB (20,2.0). Model: XGBoost. Label horizon 2 bars, confidence threshold 0.55, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-09 01:03:13
# Model            : LightGBM
# Feature Eng.     : RSI 21, BB (20,1.5), ATR 10
# Signal / Entry   : API-default style: randomly composed indicator set, model learns the rule
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# Risk Filter      : session [7, 17] UTC, trend sma_100
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/USDCAD_15min.parquet"
START_DATE = "2026-07-31"
END_DATE   = "2026-09-09"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- RSI(21) with zone flags and slope ---
    _d = close.diff()
    _g = _d.clip(lower=0).ewm(com=20, min_periods=21, adjust=False).mean()
    _l = (-_d.clip(upper=0)).ewm(com=20, min_periods=21, adjust=False).mean()
    _rsi = 100.0 - 100.0 / (1.0 + _g / (_l + 1e-10))
    df["rsi_21"] = _rsi
    df["rsi_21_os"] = (_rsi < 30).astype(float)
    df["rsi_21_ob"] = (_rsi > 70).astype(float)
    df["rsi_21_slope"] = _rsi.diff(2)
    # --- Bollinger Bands(20,1.5) ---
    _mid = close.rolling(20).mean()
    _sd = close.rolling(20).std()
    df["bb_20_1p5_pctb"] = (close - (_mid - 1.5 * _sd)) / (2 * 1.5 * _sd + 1e-10)
    df["bb_20_1p5_width"] = (2 * 1.5 * _sd) / (_mid + 1e-10)
    df["bb_20_1p5_width_chg"] = df["bb_20_1p5_width"].pct_change(3)
    # --- ATR(10) normalised ---
    _tr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr = _tr.ewm(alpha=1.0/10, adjust=False).mean()
    df["atr_10_pct"] = _atr / close
    df["atr_10_ratio"] = _atr / (_atr.rolling(40).mean() + 1e-12)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "USD/CAD Random Mix LightGBM 15min",
        "model_type": "LGBMClassifier",
        "model_params": {
                "n_estimators": 400,
                "num_leaves": 31,
                "learning_rate": 0.05,
                "subsample": 0.8,
                "subsample_freq": 1,
                "colsample_bytree": 0.6,
                "min_child_samples": 20,
                "reg_lambda": 1.0,
                "random_state": 42,
                "n_jobs": 1,
                "verbose": -1
        },
        "signal_threshold": 0.58,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 0,
        "max_positions": 1,
        "on_opposite": "reverse",
        "session_filter": [
                7,
                17
        ],
        "min_atr": None,
        "trend_filter": "sma_100",
        "target_horizon": 8,
        "objective": "Random Mix strategy on USD/CAD 15min: API-default style: randomly composed indicator set, model learns the rule. Features: RSI 21, BB (20,1.5), ATR 10. Model: LightGBM. Label horizon 8 bars, confidence threshold 0.58, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-06 15:33:05
# Model            : Logistic Regression
# Feature Eng.     : EMA 12/26 cross, ADX 20, ATR 14, ROC 20, EMA ribbon 8-55, Session/time features
# Signal / Entry   : Enter in the direction of the EMA crossover when ADX confirms trend; model gates each entry
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 15 pips, Take profit 30 pips
# Risk Filter      : —, trend ema_50
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/USDCAD_5min.parquet"
START_DATE = "2026-07-28"
END_DATE   = "2026-09-06"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 15.0
TAKE_PROFIT = 30.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- EMA 12/26 crossover ---
    _ea = close.ewm(span=12, adjust=False).mean()
    _eb = close.ewm(span=26, adjust=False).mean()
    df["ema_12_26_diff"] = (_ea - _eb) / close * 1e4
    df["ema_12_26_diff_chg"] = df["ema_12_26_diff"].diff(1)
    df["ema_12_26_cross_up"] = ((_ea > _eb) & (_ea.shift(1) <= _eb.shift(1))).astype(float)
    df["ema_12_26_cross_dn"] = ((_ea < _eb) & (_ea.shift(1) >= _eb.shift(1))).astype(float)
    df["close_vs_ema_12"] = close / _ea - 1.0
    # --- ADX(20) with +DI/-DI ---
    _up = high.diff()
    _dn = -low.diff()
    _pdm = pd.Series(np.where((_up > _dn) & (_up > 0), _up, 0.0), index=df.index)
    _ndm = pd.Series(np.where((_dn > _up) & (_dn > 0), _dn, 0.0), index=df.index)
    _tr2 = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr2 = _tr2.ewm(alpha=1.0/20, adjust=False).mean()
    _pdi = 100.0 * _pdm.ewm(alpha=1.0/20, adjust=False).mean() / (_atr2 + 1e-12)
    _ndi = 100.0 * _ndm.ewm(alpha=1.0/20, adjust=False).mean() / (_atr2 + 1e-12)
    _dx = 100.0 * (_pdi - _ndi).abs() / (_pdi + _ndi + 1e-12)
    df["adx_20"] = _dx.ewm(alpha=1.0/20, adjust=False).mean()
    df["di_diff_20"] = _pdi - _ndi
    # --- ATR(14) normalised ---
    _tr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr = _tr.ewm(alpha=1.0/14, adjust=False).mean()
    df["atr_14_pct"] = _atr / close
    df["atr_14_ratio"] = _atr / (_atr.rolling(56).mean() + 1e-12)
    # --- Rate of change(20) ---
    df["roc_20"] = close.pct_change(20) * 1e4
    # --- EMA ribbon alignment (8/13/21/34/55) ---
    _es = [close.ewm(span=_n, adjust=False).mean() for _n in (8, 13, 21, 34, 55)]
    df["ribbon_align"] = sum(((_es[_i] > _es[_i + 1]).astype(float) * 2 - 1) for _i in range(4))
    df["ribbon_spread"] = (_es[0] - _es[-1]) / close * 1e4
    # --- Time-of-day / day-of-week (UTC) ---
    _h = df.index.hour + df.index.minute / 60.0
    df["hour_sin"] = np.sin(2 * np.pi * _h / 24.0)
    df["hour_cos"] = np.cos(2 * np.pi * _h / 24.0)
    df["dow"] = df.index.dayofweek.astype(float)
    df["london_open"] = ((df.index.hour >= 7) & (df.index.hour < 10)).astype(float)
    df["ny_open"] = ((df.index.hour >= 13) & (df.index.hour < 16)).astype(float)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "USD/CAD Trend Logistic Regression 5min",
        "model_type": "LogisticRegression",
        "model_params": {
                "C": 1.0,
                "max_iter": 2000,
                "random_state": 42
        },
        "signal_threshold": 0.55,
        "direction": "short",
        "stop_loss": 15.0,
        "take_profit": 30.0,
        "risk_unit": "pips",
        "cooldown": 1,
        "max_positions": 1,
        "on_opposite": "reverse",
        "session_filter": None,
        "min_atr": None,
        "trend_filter": "ema_50",
        "target_horizon": 4,
        "objective": "Trend strategy on USD/CAD 5min: Enter in the direction of the EMA crossover when ADX confirms trend; model gates each entry. Features: EMA 12/26 cross, ADX 20, ATR 14, ROC 20, EMA ribbon 8-55, Session/time features. Model: Logistic Regression. Label horizon 4 bars, confidence threshold 0.55, direction short. Risk: 15 pip stop / 30 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-09 01:34:17
# Model            : Random Forest
# Feature Eng.     : RSI 14, Stochastic (14,3), Williams %R 14, CCI 20, MACD (12,26,9), Candle structure
# Signal / Entry   : Confluence of RSI, Stochastic, Williams %R and CCI extremes
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# Risk Filter      : —, trend sma_50
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/GBPUSD_15min.parquet"
START_DATE = "2026-07-31"
END_DATE   = "2026-09-09"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- RSI(14) with zone flags and slope ---
    _d = close.diff()
    _g = _d.clip(lower=0).ewm(com=13, min_periods=14, adjust=False).mean()
    _l = (-_d.clip(upper=0)).ewm(com=13, min_periods=14, adjust=False).mean()
    _rsi = 100.0 - 100.0 / (1.0 + _g / (_l + 1e-10))
    df["rsi_14"] = _rsi
    df["rsi_14_os"] = (_rsi < 30).astype(float)
    df["rsi_14_ob"] = (_rsi > 70).astype(float)
    df["rsi_14_slope"] = _rsi.diff(2)
    # --- Stochastic(14,3) ---
    _ll = low.rolling(14).min()
    _hh = high.rolling(14).max()
    _k = 100.0 * (close - _ll) / (_hh - _ll + 1e-10)
    df["stoch_k_14"] = _k
    df["stoch_d_14"] = _k.rolling(3).mean()
    df["stoch_14_diff"] = df["stoch_k_14"] - df["stoch_d_14"]
    # --- Williams %R(14) ---
    _hh2 = high.rolling(14).max()
    _ll2 = low.rolling(14).min()
    df["willr_14"] = -100.0 * (_hh2 - close) / (_hh2 - _ll2 + 1e-10)
    # --- CCI(20) ---
    _tp = (high + low + close) / 3.0
    _tpm = _tp.rolling(20).mean()
    _md = (_tp - _tpm).abs().rolling(20).mean()
    df["cci_20"] = (_tp - _tpm) / (0.015 * _md + 1e-12)
    # --- MACD(12,26,9) ---
    _m = close.ewm(span=12, adjust=False).mean() - close.ewm(span=26, adjust=False).mean()
    _sig = _m.ewm(span=9, adjust=False).mean()
    df["macd_12_26"] = _m / close * 1e4
    df["macd_12_26_sig"] = _sig / close * 1e4
    df["macd_12_26_hist"] = (_m - _sig) / close * 1e4
    df["macd_12_26_hist_chg"] = df["macd_12_26_hist"].diff(1)
    # --- Candle structure ---
    _rng = (high - low) + 1e-12
    df["body"] = (close - open_) / _rng
    df["upper_wick"] = (high - np.maximum(close, open_)) / _rng
    df["lower_wick"] = (np.minimum(close, open_) - low) / _rng
    df["range_pct"] = _rng / close
    df["range_rel"] = _rng / (_rng.rolling(20).mean() + 1e-12)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "GBP/USD Oscillator Stack Random Forest 15min",
        "model_type": "RandomForestClassifier",
        "model_params": {
                "n_estimators": 400,
                "max_depth": 5,
                "min_samples_leaf": 20,
                "max_features": "sqrt",
                "random_state": 42,
                "n_jobs": 1
        },
        "signal_threshold": 0.55,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 0,
        "max_positions": 1,
        "on_opposite": "close_only",
        "session_filter": None,
        "min_atr": None,
        "trend_filter": "sma_50",
        "target_horizon": 6,
        "objective": "Oscillator Stack strategy on GBP/USD 15min: Confluence of RSI, Stochastic, Williams %R and CCI extremes. Features: RSI 14, Stochastic (14,3), Williams %R 14, CCI 20, MACD (12,26,9), Candle structure. Model: Random Forest. Label horizon 6 bars, confidence threshold 0.55, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-09 01:03:13
# Model            : XGBoost
# Feature Eng.     : RSI 21, BB (14,2.0), Z-score 30, Stochastic (14,3), Candle structure, Session/time features
# Signal / Entry   : Fade RSI/Bollinger extremes back toward the mean; classifier decides direction
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# Risk Filter      : session [8, 16] UTC
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/GBPUSD_15min.parquet"
START_DATE = "2026-07-31"
END_DATE   = "2026-09-09"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- RSI(21) with zone flags and slope ---
    _d = close.diff()
    _g = _d.clip(lower=0).ewm(com=20, min_periods=21, adjust=False).mean()
    _l = (-_d.clip(upper=0)).ewm(com=20, min_periods=21, adjust=False).mean()
    _rsi = 100.0 - 100.0 / (1.0 + _g / (_l + 1e-10))
    df["rsi_21"] = _rsi
    df["rsi_21_os"] = (_rsi < 30).astype(float)
    df["rsi_21_ob"] = (_rsi > 70).astype(float)
    df["rsi_21_slope"] = _rsi.diff(2)
    # --- Bollinger Bands(14,2.0) ---
    _mid = close.rolling(14).mean()
    _sd = close.rolling(14).std()
    df["bb_14_2p0_pctb"] = (close - (_mid - 2.0 * _sd)) / (2 * 2.0 * _sd + 1e-10)
    df["bb_14_2p0_width"] = (2 * 2.0 * _sd) / (_mid + 1e-10)
    df["bb_14_2p0_width_chg"] = df["bb_14_2p0_width"].pct_change(3)
    # --- Z-score(30) of close ---
    df["zscore_30"] = (close - close.rolling(30).mean()) / (close.rolling(30).std() + 1e-12)
    df["zscore_30_chg"] = df["zscore_30"].diff(1)
    # --- Stochastic(14,3) ---
    _ll = low.rolling(14).min()
    _hh = high.rolling(14).max()
    _k = 100.0 * (close - _ll) / (_hh - _ll + 1e-10)
    df["stoch_k_14"] = _k
    df["stoch_d_14"] = _k.rolling(3).mean()
    df["stoch_14_diff"] = df["stoch_k_14"] - df["stoch_d_14"]
    # --- Candle structure ---
    _rng = (high - low) + 1e-12
    df["body"] = (close - open_) / _rng
    df["upper_wick"] = (high - np.maximum(close, open_)) / _rng
    df["lower_wick"] = (np.minimum(close, open_) - low) / _rng
    df["range_pct"] = _rng / close
    df["range_rel"] = _rng / (_rng.rolling(20).mean() + 1e-12)
    # --- Time-of-day / day-of-week (UTC) ---
    _h = df.index.hour + df.index.minute / 60.0
    df["hour_sin"] = np.sin(2 * np.pi * _h / 24.0)
    df["hour_cos"] = np.cos(2 * np.pi * _h / 24.0)
    df["dow"] = df.index.dayofweek.astype(float)
    df["london_open"] = ((df.index.hour >= 7) & (df.index.hour < 10)).astype(float)
    df["ny_open"] = ((df.index.hour >= 13) & (df.index.hour < 16)).astype(float)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "GBP/USD Mean-Reversion XGBoost 15min",
        "model_type": "XGBClassifier",
        "model_params": {
                "n_estimators": 150,
                "max_depth": 4,
                "learning_rate": 0.03,
                "subsample": 0.7,
                "colsample_bytree": 0.6,
                "min_child_weight": 1,
                "reg_lambda": 3.0,
                "gamma": 0.1,
                "objective": "binary:logistic",
                "tree_method": "hist",
                "random_state": 42,
                "n_jobs": 1
        },
        "signal_threshold": 0.58,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 0,
        "max_positions": 1,
        "on_opposite": "reverse",
        "session_filter": [
                8,
                16
        ],
        "min_atr": None,
        "trend_filter": None,
        "target_horizon": 2,
        "objective": "Mean-Reversion strategy on GBP/USD 15min: Fade RSI/Bollinger extremes back toward the mean; classifier decides direction. Features: RSI 21, BB (14,2.0), Z-score 30, Stochastic (14,3), Candle structure, Session/time features. Model: XGBoost. Label horizon 2 bars, confidence threshold 0.58, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-09 01:34:17
# Model            : Random Forest
# Feature Eng.     : RSI 14, BB (14,2.0), Z-score 30, Stochastic (14,3), Candle structure, Session/time features
# Signal / Entry   : Fade RSI/Bollinger extremes back toward the mean; classifier decides direction
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# Risk Filter      : session [12, 21] UTC
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/USDCHF_15min.parquet"
START_DATE = "2026-07-31"
END_DATE   = "2026-09-09"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- RSI(14) with zone flags and slope ---
    _d = close.diff()
    _g = _d.clip(lower=0).ewm(com=13, min_periods=14, adjust=False).mean()
    _l = (-_d.clip(upper=0)).ewm(com=13, min_periods=14, adjust=False).mean()
    _rsi = 100.0 - 100.0 / (1.0 + _g / (_l + 1e-10))
    df["rsi_14"] = _rsi
    df["rsi_14_os"] = (_rsi < 30).astype(float)
    df["rsi_14_ob"] = (_rsi > 70).astype(float)
    df["rsi_14_slope"] = _rsi.diff(2)
    # --- Bollinger Bands(14,2.0) ---
    _mid = close.rolling(14).mean()
    _sd = close.rolling(14).std()
    df["bb_14_2p0_pctb"] = (close - (_mid - 2.0 * _sd)) / (2 * 2.0 * _sd + 1e-10)
    df["bb_14_2p0_width"] = (2 * 2.0 * _sd) / (_mid + 1e-10)
    df["bb_14_2p0_width_chg"] = df["bb_14_2p0_width"].pct_change(3)
    # --- Z-score(30) of close ---
    df["zscore_30"] = (close - close.rolling(30).mean()) / (close.rolling(30).std() + 1e-12)
    df["zscore_30_chg"] = df["zscore_30"].diff(1)
    # --- Stochastic(14,3) ---
    _ll = low.rolling(14).min()
    _hh = high.rolling(14).max()
    _k = 100.0 * (close - _ll) / (_hh - _ll + 1e-10)
    df["stoch_k_14"] = _k
    df["stoch_d_14"] = _k.rolling(3).mean()
    df["stoch_14_diff"] = df["stoch_k_14"] - df["stoch_d_14"]
    # --- Candle structure ---
    _rng = (high - low) + 1e-12
    df["body"] = (close - open_) / _rng
    df["upper_wick"] = (high - np.maximum(close, open_)) / _rng
    df["lower_wick"] = (np.minimum(close, open_) - low) / _rng
    df["range_pct"] = _rng / close
    df["range_rel"] = _rng / (_rng.rolling(20).mean() + 1e-12)
    # --- Time-of-day / day-of-week (UTC) ---
    _h = df.index.hour + df.index.minute / 60.0
    df["hour_sin"] = np.sin(2 * np.pi * _h / 24.0)
    df["hour_cos"] = np.cos(2 * np.pi * _h / 24.0)
    df["dow"] = df.index.dayofweek.astype(float)
    df["london_open"] = ((df.index.hour >= 7) & (df.index.hour < 10)).astype(float)
    df["ny_open"] = ((df.index.hour >= 13) & (df.index.hour < 16)).astype(float)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "USD/CHF Mean-Reversion Random Forest 15min",
        "model_type": "RandomForestClassifier",
        "model_params": {
                "n_estimators": 200,
                "max_depth": 8,
                "min_samples_leaf": 10,
                "max_features": "sqrt",
                "random_state": 42,
                "n_jobs": 1
        },
        "signal_threshold": 0.58,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 1,
        "max_positions": 1,
        "on_opposite": "close_only",
        "session_filter": [
                12,
                21
        ],
        "min_atr": None,
        "trend_filter": None,
        "target_horizon": 6,
        "objective": "Mean-Reversion strategy on USD/CHF 15min: Fade RSI/Bollinger extremes back toward the mean; classifier decides direction. Features: RSI 14, BB (14,2.0), Z-score 30, Stochastic (14,3), Candle structure, Session/time features. Model: Random Forest. Label horizon 6 bars, confidence threshold 0.58, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-06 15:33:05
# Model            : Random Forest
# Feature Eng.     : EMA 20/50 cross, SMA 200, RSI 7, ATR 14, Keltner (20,2.0), EMA ribbon 8-55, Session/time features
# Signal / Entry   : Buy dips / sell rallies inside an established trend when the fast RSI resets
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# Risk Filter      : —, trend ema_50
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/USDCHF_15min.parquet"
START_DATE = "2026-07-28"
END_DATE   = "2026-09-06"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- EMA 20/50 crossover ---
    _ea = close.ewm(span=20, adjust=False).mean()
    _eb = close.ewm(span=50, adjust=False).mean()
    df["ema_20_50_diff"] = (_ea - _eb) / close * 1e4
    df["ema_20_50_diff_chg"] = df["ema_20_50_diff"].diff(1)
    df["ema_20_50_cross_up"] = ((_ea > _eb) & (_ea.shift(1) <= _eb.shift(1))).astype(float)
    df["ema_20_50_cross_dn"] = ((_ea < _eb) & (_ea.shift(1) >= _eb.shift(1))).astype(float)
    df["close_vs_ema_20"] = close / _ea - 1.0
    # --- SMA(200) distance & slope ---
    _s = close.rolling(200).mean()
    df["sma_200_dist"] = close / _s - 1.0
    df["sma_200_slope"] = _s.pct_change(3)
    # --- RSI(7) with zone flags and slope ---
    _d = close.diff()
    _g = _d.clip(lower=0).ewm(com=6, min_periods=7, adjust=False).mean()
    _l = (-_d.clip(upper=0)).ewm(com=6, min_periods=7, adjust=False).mean()
    _rsi = 100.0 - 100.0 / (1.0 + _g / (_l + 1e-10))
    df["rsi_7"] = _rsi
    df["rsi_7_os"] = (_rsi < 30).astype(float)
    df["rsi_7_ob"] = (_rsi > 70).astype(float)
    df["rsi_7_slope"] = _rsi.diff(2)
    # --- ATR(14) normalised ---
    _tr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr = _tr.ewm(alpha=1.0/14, adjust=False).mean()
    df["atr_14_pct"] = _atr / close
    df["atr_14_ratio"] = _atr / (_atr.rolling(56).mean() + 1e-12)
    # --- Keltner channel(20,2.0) position ---
    _kmid = close.ewm(span=20, adjust=False).mean()
    _ktr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _katr = _ktr.ewm(alpha=1.0/20, adjust=False).mean()
    df["kelt_20_pos"] = (close - _kmid) / (2.0 * _katr + 1e-12)
    # --- EMA ribbon alignment (8/13/21/34/55) ---
    _es = [close.ewm(span=_n, adjust=False).mean() for _n in (8, 13, 21, 34, 55)]
    df["ribbon_align"] = sum(((_es[_i] > _es[_i + 1]).astype(float) * 2 - 1) for _i in range(4))
    df["ribbon_spread"] = (_es[0] - _es[-1]) / close * 1e4
    # --- Time-of-day / day-of-week (UTC) ---
    _h = df.index.hour + df.index.minute / 60.0
    df["hour_sin"] = np.sin(2 * np.pi * _h / 24.0)
    df["hour_cos"] = np.cos(2 * np.pi * _h / 24.0)
    df["dow"] = df.index.dayofweek.astype(float)
    df["london_open"] = ((df.index.hour >= 7) & (df.index.hour < 10)).astype(float)
    df["ny_open"] = ((df.index.hour >= 13) & (df.index.hour < 16)).astype(float)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "USD/CHF Trend Pullback Random Forest 15min",
        "model_type": "RandomForestClassifier",
        "model_params": {
                "n_estimators": 300,
                "max_depth": 5,
                "min_samples_leaf": 5,
                "max_features": "sqrt",
                "random_state": 42,
                "n_jobs": 1
        },
        "signal_threshold": 0.58,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 0,
        "max_positions": 1,
        "on_opposite": "reverse",
        "session_filter": None,
        "min_atr": None,
        "trend_filter": "ema_50",
        "target_horizon": 8,
        "objective": "Trend Pullback strategy on USD/CHF 15min: Buy dips / sell rallies inside an established trend when the fast RSI resets. Features: EMA 20/50 cross, SMA 200, RSI 7, ATR 14, Keltner (20,2.0), EMA ribbon 8-55, Session/time features. Model: Random Forest. Label horizon 8 bars, confidence threshold 0.58, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-09 01:03:13
# Model            : XGBoost
# Feature Eng.     : BB (20,2.0), ATR 10, ADX 14, Volatility 10, Return lags 1-5, Keltner (20,1.5), Session/time features
# Signal / Entry   : Squeeze (BB inside Keltner) then expansion; classifier picks the direction of the release
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# Risk Filter      : session [12, 21] UTC
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/EURUSD_1h.parquet"
START_DATE = "2026-07-31"
END_DATE   = "2026-09-09"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- Bollinger Bands(20,2.0) ---
    _mid = close.rolling(20).mean()
    _sd = close.rolling(20).std()
    df["bb_20_2p0_pctb"] = (close - (_mid - 2.0 * _sd)) / (2 * 2.0 * _sd + 1e-10)
    df["bb_20_2p0_width"] = (2 * 2.0 * _sd) / (_mid + 1e-10)
    df["bb_20_2p0_width_chg"] = df["bb_20_2p0_width"].pct_change(3)
    # --- ATR(10) normalised ---
    _tr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr = _tr.ewm(alpha=1.0/10, adjust=False).mean()
    df["atr_10_pct"] = _atr / close
    df["atr_10_ratio"] = _atr / (_atr.rolling(40).mean() + 1e-12)
    # --- ADX(14) with +DI/-DI ---
    _up = high.diff()
    _dn = -low.diff()
    _pdm = pd.Series(np.where((_up > _dn) & (_up > 0), _up, 0.0), index=df.index)
    _ndm = pd.Series(np.where((_dn > _up) & (_dn > 0), _dn, 0.0), index=df.index)
    _tr2 = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _atr2 = _tr2.ewm(alpha=1.0/14, adjust=False).mean()
    _pdi = 100.0 * _pdm.ewm(alpha=1.0/14, adjust=False).mean() / (_atr2 + 1e-12)
    _ndi = 100.0 * _ndm.ewm(alpha=1.0/14, adjust=False).mean() / (_atr2 + 1e-12)
    _dx = 100.0 * (_pdi - _ndi).abs() / (_pdi + _ndi + 1e-12)
    df["adx_14"] = _dx.ewm(alpha=1.0/14, adjust=False).mean()
    df["di_diff_14"] = _pdi - _ndi
    # --- Realised volatility(10) ---
    _r2 = close.pct_change()
    df["vol_10"] = _r2.rolling(10).std() * 1e4
    df["vol_10_ratio"] = df["vol_10"] / (_r2.rolling(40).std() * 1e4 + 1e-9)
    # --- Return lags 1..5 ---
    _r = close.pct_change() * 1e4
    for _i in range(1, 6):
        df[f"ret_lag_{_i}"] = _r.shift(_i - 1)
    df["ret_sum_5"] = _r.rolling(5).sum()
    # --- Keltner channel(20,1.5) position ---
    _kmid = close.ewm(span=20, adjust=False).mean()
    _ktr = pd.concat([high - low, (high - close.shift(1)).abs(), (low - close.shift(1)).abs()], axis=1).max(axis=1)
    _katr = _ktr.ewm(alpha=1.0/20, adjust=False).mean()
    df["kelt_20_pos"] = (close - _kmid) / (1.5 * _katr + 1e-12)
    # --- Time-of-day / day-of-week (UTC) ---
    _h = df.index.hour + df.index.minute / 60.0
    df["hour_sin"] = np.sin(2 * np.pi * _h / 24.0)
    df["hour_cos"] = np.cos(2 * np.pi * _h / 24.0)
    df["dow"] = df.index.dayofweek.astype(float)
    df["london_open"] = ((df.index.hour >= 7) & (df.index.hour < 10)).astype(float)
    df["ny_open"] = ((df.index.hour >= 13) & (df.index.hour < 16)).astype(float)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "EUR/USD Vol-Regime XGBoost 1h",
        "model_type": "XGBClassifier",
        "model_params": {
                "n_estimators": 250,
                "max_depth": 3,
                "learning_rate": 0.02,
                "subsample": 0.7,
                "colsample_bytree": 0.7,
                "min_child_weight": 5,
                "reg_lambda": 1.0,
                "gamma": 0.0,
                "objective": "binary:logistic",
                "tree_method": "hist",
                "random_state": 42,
                "n_jobs": 1
        },
        "signal_threshold": 0.58,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 0,
        "max_positions": 1,
        "on_opposite": "reverse",
        "session_filter": [
                12,
                21
        ],
        "min_atr": None,
        "trend_filter": None,
        "target_horizon": 6,
        "objective": "Vol-Regime strategy on EUR/USD 1h: Squeeze (BB inside Keltner) then expansion; classifier picks the direction of the release. Features: BB (20,2.0), ATR 10, ADX 14, Volatility 10, Return lags 1-5, Keltner (20,1.5), Session/time features. Model: XGBoost. Label horizon 6 bars, confidence threshold 0.58, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }

# ╔══════════════════════════════════════════════════════════════╗
# ║                  STRATEGY REQUEST LOG                       ║
# ╚══════════════════════════════════════════════════════════════╝
# Generated        : 2026-09-09 01:03:13
# Model            : XGBoost
# Feature Eng.     : Z-score 50, EMA ribbon 8-55, Volatility 10, Donchian 55
# Signal / Entry   : API-default style: randomly composed indicator set, model learns the rule
# Optimization     : Maximize out-of-sample return with a 70/30 holdout
# Risk Mgmt        : Stop loss 25 pips, Take profit 50 pips
# Risk Filter      : session [7, 20] UTC
# ══════════════════════════════════════════════════════════════

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

DATA_PATH = "/root/Desktop/QuantifyMe/data/ohlc/EURUSD_1h.parquet"
START_DATE = "2026-07-31"
END_DATE   = "2026-09-09"
VALIDATION_DATE = ""
TRAIN_SPLIT = 0.7
LEVERAGE = 30.0
LOTS = 1.0
BALANCE = 10000.0
RISK_UNIT = 'pips'
STOP_LOSS = 25.0
TAKE_PROFIT = 50.0
AUX_FEEDS = []

# SECTION 1 — FEATURE ENGINEERING
def feature_engineering(df, close, open_, high, low):
    # --- Z-score(50) of close ---
    df["zscore_50"] = (close - close.rolling(50).mean()) / (close.rolling(50).std() + 1e-12)
    df["zscore_50_chg"] = df["zscore_50"].diff(1)
    # --- EMA ribbon alignment (8/13/21/34/55) ---
    _es = [close.ewm(span=_n, adjust=False).mean() for _n in (8, 13, 21, 34, 55)]
    df["ribbon_align"] = sum(((_es[_i] > _es[_i + 1]).astype(float) * 2 - 1) for _i in range(4))
    df["ribbon_spread"] = (_es[0] - _es[-1]) / close * 1e4
    # --- Realised volatility(10) ---
    _r2 = close.pct_change()
    df["vol_10"] = _r2.rolling(10).std() * 1e4
    df["vol_10_ratio"] = df["vol_10"] / (_r2.rolling(40).std() * 1e4 + 1e-9)
    # --- Donchian channel(55) position & breakout ---
    _dh = high.rolling(55).max().shift(1)
    _dl = low.rolling(55).min().shift(1)
    df["donch_55_pos"] = (close - _dl) / (_dh - _dl + 1e-10)
    df["donch_55_break_up"] = (close > _dh).astype(float)
    df["donch_55_break_dn"] = (close < _dl).astype(float)

    # Fill indicator warm-up gaps without looking ahead
    df = df.ffill().fillna(0.0)
    return df


# SECTION 2 — STRATEGY CONFIG
def strategy_config():
    return {
        "title": "EUR/USD Random Mix XGBoost 1h",
        "model_type": "XGBClassifier",
        "model_params": {
                "n_estimators": 250,
                "max_depth": 3,
                "learning_rate": 0.02,
                "subsample": 0.8,
                "colsample_bytree": 0.7,
                "min_child_weight": 1,
                "reg_lambda": 1.0,
                "gamma": 0.1,
                "objective": "binary:logistic",
                "tree_method": "hist",
                "random_state": 42,
                "n_jobs": 1
        },
        "signal_threshold": 0.55,
        "direction": "both",
        "stop_loss": 25.0,
        "take_profit": 50.0,
        "risk_unit": "pips",
        "cooldown": 0,
        "max_positions": 1,
        "on_opposite": "close_only",
        "session_filter": [
                7,
                20
        ],
        "min_atr": None,
        "trend_filter": None,
        "target_horizon": 1,
        "objective": "Random Mix strategy on EUR/USD 1h: API-default style: randomly composed indicator set, model learns the rule. Features: Z-score 50, EMA ribbon 8-55, Volatility 10, Donchian 55. Model: XGBoost. Label horizon 1 bars, confidence threshold 0.55, direction both. Risk: 25 pip stop / 50 pip target (1:2 R/R), 1.0 lot on $10k, $6 round-trip commission.",
        "notes": "Generated by the QuantifyMe strategy forge. SL/TP are in pips and match the dashboard defaults, so pasting this code into the Code tab reproduces the published backtest on the same window."
    }