#!/usr/bin/env python3 """ MT5 Multi-Timeframe Candlestick Pattern Scanner & Backtester v8 =============================================================== Expanded from v5: supports M5, M15, H1, H4, and D1 timeframes for both live scanning and backtesting. All parameters are consolidated near the top. Must run on Windows with MT5 installed. Credentials are loaded exclusively from the .env file in the same directory. Install: pip install MetaTrader5 pandas numpy colorama python-dotenv Sound Alerts (Windows only): - High-Hz triple beep for STRONG BUY signals (score >= 65) - Low-Hz triple beep for STRONG SELL signals (score >= 65) - Type 'm' + Enter at any time to mute/unmute sound alerts Usage: # Live scanner — all 5 timeframes (default) python mt5_multitf_pattern_scanner_v8.py # Live scanner — specific timeframes only python mt5_multitf_pattern_scanner_v8.py --timeframes M5 H1 H4 # One-shot scan of latest closed candle on all timeframes python mt5_multitf_pattern_scanner_v8.py --mode scan # Quick backtest (last 500 bars on H4) python mt5_multitf_pattern_scanner_v8.py --mode backtest --bars 500 # Full backtest on one timeframe python mt5_multitf_pattern_scanner_v8.py --mode fullbacktest --timeframes H4 # Full backtest on ALL timeframes, date-ranged python mt5_multitf_pattern_scanner_v8.py --mode fullbacktest --from 2024-01-01 --to 2024-12-31 # Full backtest with filters python mt5_multitf_pattern_scanner_v8.py --mode fullbacktest \\ --d1-trend-filter --volume-filter --forward 15 --sl 1.5 --tp 1.5 # Full backtest with structure-based SL (pattern invalidation levels) python mt5_multitf_pattern_scanner_v8.py --mode fullbacktest --sl-mode structure # Full backtest with breakeven trade management python mt5_multitf_pattern_scanner_v8.py --mode fullbacktest --trade-management breakeven # Full backtest with trailing stop management python mt5_multitf_pattern_scanner_v8.py --mode fullbacktest --trade-management trail # Full backtest with partial close + trailing management python mt5_multitf_pattern_scanner_v8.py --mode fullbacktest --trade-management partial # Full backtest with expired timeout (0R flat) instead of marginal win/loss python mt5_multitf_pattern_scanner_v8.py --mode fullbacktest --timeout-mode expired # Multi-symbol watchlist scan python mt5_multitf_pattern_scanner_v8.py --mode scan --symbols EURUSD GBPUSD USDJPY # Multi-symbol full backtest python mt5_multitf_pattern_scanner_v8.py --mode fullbacktest --symbols EURUSD GBPUSD # Live scanner with custom account sizing python mt5_multitf_pattern_scanner_v8.py --mode live --account-balance 25000 --risk-percent 0.5 # Test sound alerts (plays both BUY and SELL test beeps) python mt5_multitf_pattern_scanner_v8.py --test-sound """ import MetaTrader5 as mt5 import pandas as pd import numpy as np from datetime import datetime, timedelta import argparse import time import os import sys import json import glob import re import warnings warnings.filterwarnings('ignore', category=FutureWarning) warnings.filterwarnings('ignore', category=DeprecationWarning) warnings.filterwarnings('ignore', category=UserWarning) # ── Windows sound & keyboard support ──────────────────────────────── try: import winsound _WINSOUND = True except ImportError: _WINSOUND = False import threading # Global mute state for sound alerts (toggled by 'm' key) # Starts MUTED — type 'm' + Enter to unmute and hear alerts _sound_muted = True _sound_listener_thread = None # ── Load credentials from .env file (REQUIRED) ───────────────────── try: from dotenv import load_dotenv _dotenv_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '.env') if os.path.exists(_dotenv_path): load_dotenv(_dotenv_path) _ENV_LOADED = True else: _ENV_LOADED = False except ImportError: _ENV_LOADED = False # ── Color output for Windows terminal ────────────────────────────── try: from colorama import init, Fore, Style init(autoreset=True) _COLORAMA = True except ImportError: _COLORAMA = False def C(color, text): """Return colour-wrapped text if colorama available, else plain text.""" if not _COLORAMA: return str(text) _MAP = { 'green': Fore.LIGHTGREEN_EX, 'red': Fore.LIGHTRED_EX, 'yellow': Fore.YELLOW, 'cyan': Fore.CYAN, 'blue': Fore.LIGHTBLUE_EX, 'magenta': Fore.MAGENTA, 'white': Fore.WHITE, 'dim': Fore.BLACK, 'bold': Style.BRIGHT, 'reset': Style.RESET_ALL, } c = _MAP.get(color, '') return f"{c}{text}{Style.RESET_ALL}" # ============================================================ # CONFIGURATION — ALL PARAMETERS IN ONE PLACE # ============================================================ # ── MT5 Credentials (from .env — never hardcode) ─────────────────── _MT5_PATH = os.getenv('MT5_PATH', r"C:\Program Files\Capital Point Trading MT5 Terminal\terminal64.exe") _MT5_ACCOUNT = int(os.getenv('MT5_ACCOUNT', '0')) # Must be set in .env — 0 will fail login _MT5_PASSWORD = os.getenv('MT5_PASSWORD', '') _MT5_SERVER = os.getenv('MT5_SERVER', 'CapitalPointTrading-Demo') # ── Timeframe Map: label → MT5 constant + candle duration (minutes) ─ TIMEFRAME_MAP = { 'M5': {'mt5_tf': mt5.TIMEFRAME_M5, 'minutes': 5, 'label': 'M5'}, 'M15': {'mt5_tf': mt5.TIMEFRAME_M15, 'minutes': 15, 'label': 'M15'}, 'H1': {'mt5_tf': mt5.TIMEFRAME_H1, 'minutes': 60, 'label': 'H1'}, 'H4': {'mt5_tf': mt5.TIMEFRAME_H4, 'minutes': 240, 'label': 'H4'}, 'D1': {'mt5_tf': mt5.TIMEFRAME_D1, 'minutes': 1440, 'label': 'D1'}, } CFG = { # ── MT5 Connection ───────────────────────────────────────────── 'mt5_path': _MT5_PATH, 'account': _MT5_ACCOUNT, 'password': _MT5_PASSWORD, 'server': _MT5_SERVER, # ── Symbol & Timeframes ──────────────────────────────────────── 'symbol': "EURUSD", # Active timeframes for live scan & backtest. All 5 available: # 'M5', 'M15', 'H1', 'H4', 'D1' 'active_timeframes': ['M5', 'M15', 'H1', 'H4', 'D1'], # Timeframe used as the D1 trend-filter source (should be >= 'H4') 'trend_filter_tf': 'D1', # ── ATR / SL / TP ───────────────────────────────────────────── 'atr_period': 14, 'sl_multiplier': 1.5, 'tp_multiplier': 1.5, # R:R = tp_multiplier / sl_multiplier # Variable R:R overrides per pattern (tp_multiplier override). # If a pattern is listed here, its TP multiplier is overridden. # Example: Engulfing at 1.5:1, Morning Star at 2.5:1 'rr_by_pattern': {}, # Higher-timeframe ATR source per trading TF. # M5/M15 ATR is tiny → use H1 ATR for SL/TP sizing on fast TFs. # Set to None or same as trading TF to use native ATR. 'atr_tf_by_tf': { 'M5': 'H1', # Use H1 ATR for M5 signals (much wider, more realistic SL/TP) 'M15': 'H1', # Use H1 ATR for M15 signals 'H1': 'H1', # Native 'H4': 'H4', # Native (H4 ATR is already meaningful) 'D1': 'D1', # Native }, # ── Pattern Detection Thresholds ────────────────────────────── 'doji_body_ratio': 0.1, 'spinning_top_body_ratio': 0.3, 'marubozu_wick_ratio': 0.05, 'hammer_lower_wick_ratio': 2.0, 'hammer_upper_wick_ratio': 0.3, 'long_candle_ratio': 0.7, 'small_candle_ratio': 0.35, 'tweezer_tolerance_pips': 3, 'engulf_tolerance_pips': 2.0, # ── Trend Detection ──────────────────────────────────────────── 'trend_lookback': 20, # SMA-based lookback bars # ── Forward Evaluation (per-timeframe multiples of candle duration) # Default forward candles. For fast TFs this is auto-scaled in # run_full_backtest() so the evaluation window is always ~60 hours. 'default_forward_candles': 15, # used as-is for H4 (60 h) # Per-timeframe forward candle overrides (set 0 to use auto-scaling) 'forward_candles_by_tf': { 'M5': 720, # 720 × 5 min = 60 h 'M15': 240, # 240 × 15 min = 60 h 'H1': 60, # 60 × 1 h = 60 h 'H4': 15, # 15 × 4 h = 60 h 'D1': 20, # 20 × 1 day = 20 days (~4 trading weeks) }, # ── Full Backtest ────────────────────────────────────────────── 'max_r_levels': 5, 'pip_divisor': 0.0001, 'warmup_bars': 30, # ── Live Scanner ─────────────────────────────────────────────── 'bars_to_fetch': 50, # bars fetched per TF for pattern context # Seconds between poll cycles per timeframe # M5/M15 poll more frequently; D1 can poll once per minute 'poll_interval_by_tf': { 'M5': 15, 'M15': 30, 'H1': 30, 'H4': 30, 'D1': 60, }, # ── Session Classifier ───────────────────────────────────────── 'broker_utc_offset': 2, # UTC+2 broker server time # ── Signal Deduplication & Entry Verification ───────────────── 'deduplicate_signals': True, 'verify_entry': True, # ── Volume Confirmation ──────────────────────────────────────── 'volume_filter': False, 'volume_ma_period': 20, 'volume_threshold': 1.0, # signal candle vol >= threshold × avg # ── D1 Trend Filter ──────────────────────────────────────────── 'd1_trend_filter': True, 'd1_sma_period': 20, # ── Auto-Reconnect ───────────────────────────────────────────── 'max_reconnect_attempts': 5, 'reconnect_backoff_base': 10, # seconds, doubles each retry # ── Live Stats Integration ───────────────────────────────────── 'stats_cache_hours': 4, 'min_signals_for_stats': 5, 'min_historical_win_rate': 50.0, # ── Live Signal Filtering ────────────────────────────────────── 'min_signal_score': 55.0, # 0 = disabled 'alert_only_strong': True, 'show_dashboard_on_start': True, # ── Position Sizing ──────────────────────────────────────────── 'account_balance': 100000, 'risk_percent': 1.0, # % of account per trade # ── Sound Alerts (Windows only) ───────────────────────────────── 'sound_enabled': True, # master switch for sound alerts 'sound_buy_hz': 1200, # Hz for strong buy triple beep 'sound_sell_hz': 400, # Hz for strong sell triple beep 'sound_beep_duration': 150, # ms per individual beep 'sound_beep_pause': 100, # ms pause between beeps 'sound_strong_threshold': 65.0, # signal score >= this = STRONG # ── Trade Management (Backtest) ──────────────────────────────── 'trade_management_mode': 'fixed', # 'fixed', 'breakeven', 'trail', 'partial' 'breakeven_at_r': 1.0, # Move SL to breakeven when price hits this R level 'trail_at_r': 1.5, # Start trailing stop when price hits this R level 'trail_atr_mult': 1.0, # Trail SL by this multiple of ATR behind price 'partial_close_r': 1.0, # Close partial position at this R level 'partial_close_pct': 0.5, # Fraction of position to close at partial_close_r (0.5 = 50%) 'time_stop_pct': 0.7, # If this fraction of forward_candles elapsed without TP, tighten SL # 0 = disabled. E.g. 0.7 with 15 forward = tighten after 10 bars # ── SL Placement Mode ────────────────────────────────────────── 'sl_mode': 'atr', # 'atr' (current) or 'structure' (pattern-based) 'sl_structure_buffer_pips': 2, # Buffer in pips below pattern extreme for structure SL # ── Timeout Classification ────────────────────────────────────── 'timeout_mode': 'marginal', # 'marginal' (current: Marginal_Win/Loss) or 'expired' (flat 0R) # ── Multi-Symbol Watchlist ────────────────────────────────────── 'watchlist': ['EURUSD'], # Symbols to scan/backtest (default: EURUSD only) # ── Equity Curve ──────────────────────────────────────────────── 'equity_curve_enabled': True, # Generate equity curve in full backtest } # ── Derived Paths ─────────────────────────────────────────────────── _LOG_DIR = os.path.dirname(os.path.abspath(__file__)) LOG_FILE = os.path.join(_LOG_DIR, "mt5_pattern_scan_log.txt") DEFAULT_OUTPUT_DIR = os.path.join(_LOG_DIR, "backtest_results") # ── Pattern Priority for Deduplication ───────────────────────────── PATTERN_PRIORITY = { 'Doji': 1, 'Spinning Top': 1, 'Hammer': 2, 'Inverted Hammer': 2, 'Shooting Star': 2, 'Hanging Man': 2, 'Marubozu (Bullish)': 3, 'Marubozu (Bearish)': 3, 'Tweezer Tops': 4, 'Tweezer Bottoms': 4, 'Near Bullish Engulfing': 4, 'Near Bearish Engulfing': 4, 'Bullish Engulfing': 5, 'Bearish Engulfing': 5, 'Bullish Harami': 6, 'Bearish Harami': 6, 'Morning Star': 7, 'Evening Star': 7, 'Three White Soldiers': 8, 'Three Black Crows': 8, 'Rising Three Methods': 9, 'Falling Three Methods': 9, } # ============================================================ # UTILITY FUNCTIONS # ============================================================ # ============================================================ # SOUND ALERT FUNCTIONS # ============================================================ def play_signal_beep(direction, score, cfg=None): """Play a triple beep sound alert for strong signals. High-Hz triple beep for STRONG BUY, Low-Hz triple beep for STRONG SELL. Respects the global mute state and configuration thresholds. Args: direction: 'Bullish' or 'Bearish' score: signal quality score (0-100) cfg: configuration dict """ global _sound_muted if cfg is None: cfg = CFG # Check master switch and mute state if not cfg.get('sound_enabled', True) or _sound_muted: return if not _WINSOUND: return # Only beep for STRONG signals (score >= threshold) threshold = cfg.get('sound_strong_threshold', 65.0) if score is None or score < threshold: return # Determine frequency based on direction if direction == 'Bullish': freq = cfg.get('sound_buy_hz', 1200) elif direction == 'Bearish': freq = cfg.get('sound_sell_hz', 400) else: return # Neutral signals don't beep duration = cfg.get('sound_beep_duration', 150) pause = cfg.get('sound_beep_pause', 100) # Play triple beep try: for i in range(3): winsound.Beep(int(freq), int(duration)) if i < 2: # No pause after last beep time.sleep(pause / 1000.0) except Exception: pass # Silently ignore sound errors def _sound_key_listener(): """Background daemon thread that listens for 'm' + Enter to toggle mute. Uses input() which works in ALL terminals including PyCharm. Runs as a daemon thread so it dies automatically when the main program exits. """ global _sound_muted while True: try: cmd = input().strip().lower() if cmd == 'm': _sound_muted = not _sound_muted status = C('red', 'MUTED') if _sound_muted else C('green', 'UNMUTED') print(f"\n Sound {status} | Type 'm' + Enter to toggle") except (EOFError, KeyboardInterrupt): break except Exception: pass def start_sound_key_listener(): """Start the background keyboard listener thread (if not already running).""" global _sound_listener_thread if _sound_listener_thread is not None and _sound_listener_thread.is_alive(): return _sound_listener_thread = threading.Thread(target=_sound_key_listener, daemon=True) _sound_listener_thread.start() # check_mute_key() removed — keyboard handled by background thread (start_sound_key_listener) def test_sound(cfg=None): """Play test beeps for STRONG BUY and STRONG SELL so the user can verify audio. Temporarily forces sound enabled and unmuted for the test, then restores the original state. Exits after playing both test beeps. """ global _sound_muted if cfg is None: cfg = CFG if not _WINSOUND: print(C('red', "ERROR: winsound not available — sound requires Windows")) return # Save original mute state, force unmute for the test was_muted = _sound_muted _sound_muted = False buy_hz = cfg.get('sound_buy_hz', 1200) sell_hz = cfg.get('sound_sell_hz', 400) duration = cfg.get('sound_beep_duration', 150) pause = cfg.get('sound_beep_pause', 100) print("") print(C('cyan', "=" * 50)) print(C('bold', " SOUND TEST")) print(C('cyan', "=" * 50)) print(f" STRONG BUY beep: {buy_hz} Hz x 3") print(f" STRONG SELL beep: {sell_hz} Hz x 3") print(f" Beep duration: {duration} ms") print(f" Pause between: {pause} ms") print("") # Test STRONG BUY print(C('green', " >>> Playing STRONG BUY test beep...")) try: for i in range(3): winsound.Beep(int(buy_hz), int(duration)) if i < 2: time.sleep(pause / 1000.0) except Exception as e: print(C('red', f" ERROR: {e}")) time.sleep(0.5) # Test STRONG SELL print(C('red', " >>> Playing STRONG SELL test beep...")) try: for i in range(3): winsound.Beep(int(sell_hz), int(duration)) if i < 2: time.sleep(pause / 1000.0) except Exception as e: print(C('red', f" ERROR: {e}")) # Restore original mute state _sound_muted = was_muted print("") print(C('cyan', "=" * 50)) if was_muted: print(f" Sound is {C('red', 'MUTED')} (restored to original state)") print(f" Type {C('yellow', '\"m\" + Enter')} to unmute during live scanner") else: print(f" Sound is {C('green', 'UNMUTED')} (restored to original state)") print(C('cyan', "=" * 50)) print("") def broker_now(): """Return current broker server time. MT5 timestamps interpreted as UTC = broker time.""" return datetime.utcnow() def broker_time(ts): """Convert a Unix timestamp (from MT5) to broker server time. MT5 brokers encode their server time directly in the timestamps, so fromtimestamp with UTC returns the broker's clock time. """ return datetime.fromtimestamp(int(ts), tz=None) _log_lock = threading.Lock() def log_message(msg, cfg=None): """Print and log a message. Strips ANSI colour codes for log file. Thread-safe: uses a lock to prevent interleaved writes from the sound listener thread and the main scanner thread. """ timestamp = broker_now().strftime("%Y-%m-%d %H:%M:%S") line = f"[{timestamp}] {msg}" print(line) clean_line = re.sub(r'\x1b\[[0-9;]*m', '', line) with _log_lock: try: with open(LOG_FILE, "a", encoding='utf-8') as f: f.write(clean_line + "\n") except Exception: pass def classify_session(hour, cfg=None): """Classify broker-time hour into a trading session.""" if cfg is None: cfg = CFG offset = cfg.get('broker_utc_offset', 2) utc_hour = (hour - offset) % 24 if 0 <= utc_hour < 7: return 'Asia' elif 7 <= utc_hour < 9: return 'London Open' elif 9 <= utc_hour < 12: return 'London Morning' elif 12 <= utc_hour < 16: return 'London/NY Overlap' elif 16 <= utc_hour < 20: return 'NY Afternoon' elif 20 <= utc_hour < 24: return 'Pacific' else: return 'Unknown' def deduplicate_patterns(patterns, cfg=None): """Keep only the highest-priority directional pattern per candle.""" if cfg is None: cfg = CFG if not cfg.get('deduplicate_signals', True): return patterns directional = [p for p in patterns if p.get('direction') != 'Neutral'] neutral = [p for p in patterns if p.get('direction') == 'Neutral'] if directional: directional.sort(key=lambda p: PATTERN_PRIORITY.get(p.get('name', ''), 0), reverse=True) return [directional[0]] else: neutral.sort(key=lambda p: PATTERN_PRIORITY.get(p.get('name', ''), 0), reverse=True) return [neutral[0]] if neutral else [] def get_forward_candles(tf_label, cfg=None): """Return the forward evaluation candle count for the given timeframe label.""" if cfg is None: cfg = CFG overrides = cfg.get('forward_candles_by_tf', {}) return overrides.get(tf_label, cfg.get('default_forward_candles', 15)) def get_atr_tf(tf_label, cfg=None): """Return the timeframe label used for ATR calculation for the given trading TF. If 'atr_tf_by_tf' maps a TF to a higher TF, that higher TF is returned. If the mapping is None or the same as tf_label, returns tf_label (native ATR). """ if cfg is None: cfg = CFG atr_tf_map = cfg.get('atr_tf_by_tf', {}) atr_tf = atr_tf_map.get(tf_label, tf_label) if atr_tf is None: return tf_label return atr_tf def get_pip_value(symbol=None, cfg=None): """Compute pip value for position sizing based on MT5 symbol info. Falls back to a static lookup table if MT5 is not connected. Returns the value of 1 pip movement per standard lot in account currency. For most forex pairs: pip_value = contract_size * pip_size / (current_rate for cross pairs) For EURUSD standard: 100000 * 0.0001 = 10 USD per pip per lot """ if cfg is None: cfg = CFG if symbol is None: symbol = cfg.get('symbol', 'EURUSD') # Try MT5 symbol_info (only works when connected) try: info = mt5.symbol_info(symbol) if info is not None: contract_size = info.trade_contract_size or 100000 tick_size = info.trade_tick_size or 0.00001 tick_value = info.trade_tick_value or 0 if tick_size > 0 and tick_value > 0: # pip_value = value of 1 pip (0.0001 for 5-digit, 0.01 for 3-digit) pip_size = 0.0001 if 'JPY' not in symbol else 0.01 return round(tick_value * (pip_size / tick_size), 4) except Exception: pass # Fallback static lookup for common symbols _STATIC_PIP_VALUES = { 'EURUSD': 10, 'GBPUSD': 10, 'AUDUSD': 10, 'NZDUSD': 10, 'USDCAD': 7.5, 'USDCHF': 11, 'USDJPY': 6.5, 'EURJPY': 6.5, 'GBPJPY': 6.5, 'XAUUSD': 1, 'XAGUSD': 5, 'US30': 1, 'NAS100': 1, 'SPX500': 1, } return _STATIC_PIP_VALUES.get(symbol, 10) def compute_structure_sl(pattern_name, direction, rates_or_df, idx, cfg=None): """Compute structure-based SL using the pattern's natural invalidation level. Structure SL places the stop at the pattern's extreme (e.g. below the Hammer's low, below the engulfing candle's low) plus a small buffer, rather than using a fixed ATR multiple. This gives tighter, more logical stops. Returns (sl_price, sl_reason) or None if not applicable. Args: pattern_name: e.g. 'Hammer', 'Bullish Engulfing', 'Morning Star' direction: 'Bullish' or 'Bearish' rates_or_df: structured array (scanner) or DataFrame (backtest) idx: index of the signal candle cfg: configuration dict """ if cfg is None: cfg = CFG buffer_pips = cfg.get('sl_structure_buffer_pips', 2) pip_divisor = cfg.get('pip_divisor', 0.0001) buffer = buffer_pips * pip_divisor # For DataFrame, use uppercase column names; for structured arrays, use lowercase is_df = isinstance(rates_or_df, pd.DataFrame) low_key = 'LOW' if is_df else 'low' high_key = 'HIGH' if is_df else 'high' close_key = 'CLOSE' if is_df else 'close' open_key = 'OPEN' if is_df else 'open' try: if is_df: curr = rates_or_df.iloc[idx] else: curr = rates_or_df[idx] except (IndexError, KeyError): return None curr_low = curr[low_key] curr_high = curr[high_key] if direction == 'Bullish': # For bullish patterns, SL goes below the pattern's lowest point if pattern_name in ('Hammer', 'Inverted Hammer'): # Below the signal candle's low (the wick IS the pattern) sl = curr_low - buffer reason = f'Below Hammer low ({curr_low:.5f}) - buffer {buffer_pips}p' elif pattern_name in ('Morning Star',): # Below the lowest point of the 3-candle pattern if idx >= 2: if is_df: prev2 = rates_or_df.iloc[idx-2] prev1 = rates_or_df.iloc[idx-1] else: prev2 = rates_or_df[idx-2] prev1 = rates_or_df[idx-1] pattern_low = min(prev2[low_key], prev1[low_key], curr_low) sl = pattern_low - buffer reason = f'Below Morning Star low ({pattern_low:.5f}) - buffer {buffer_pips}p' else: sl = curr_low - buffer reason = f'Below candle low ({curr_low:.5f}) - buffer {buffer_pips}p' elif pattern_name in ('Three White Soldiers', 'Rising Three Methods'): # Below the first candle's low of the multi-candle pattern lookback = 4 if 'Three Methods' in pattern_name else 2 if idx >= lookback: if is_df: first = rates_or_df.iloc[idx-lookback] else: first = rates_or_df[idx-lookback] sl = first[low_key] - buffer reason = f'Below pattern first candle low ({first[low_key]:.5f}) - buffer {buffer_pips}p' else: sl = curr_low - buffer reason = f'Below candle low ({curr_low:.5f}) - buffer {buffer_pips}p' elif 'Bullish Engulfing' in pattern_name: # Below the engulfing candle's low (current candle = engulfing) sl = curr_low - buffer reason = f'Below Engulfing candle low ({curr_low:.5f}) - buffer {buffer_pips}p' elif 'Bullish Harami' in pattern_name: # Below the mother candle's low (previous candle) if idx >= 1: if is_df: prev = rates_or_df.iloc[idx-1] else: prev = rates_or_df[idx-1] sl = min(prev[low_key], curr_low) - buffer reason = f'Below Harami pattern low ({min(prev[low_key], curr_low):.5f}) - buffer {buffer_pips}p' else: sl = curr_low - buffer reason = f'Below candle low - buffer {buffer_pips}p' elif pattern_name == 'Tweezer Bottoms': # Below the tweezer lows sl = curr_low - buffer reason = f'Below Tweezer Bottoms low ({curr_low:.5f}) - buffer {buffer_pips}p' else: # Default: below current candle low sl = curr_low - buffer reason = f'Below candle low ({curr_low:.5f}) - buffer {buffer_pips}p' return (round(sl, 5), reason) elif direction == 'Bearish': # For bearish patterns, SL goes above the pattern's highest point if pattern_name in ('Shooting Star', 'Hanging Man'): sl = curr_high + buffer reason = f'Above Shooting Star high ({curr_high:.5f}) + buffer {buffer_pips}p' elif pattern_name in ('Evening Star',): if idx >= 2: if is_df: prev2 = rates_or_df.iloc[idx-2] prev1 = rates_or_df.iloc[idx-1] else: prev2 = rates_or_df[idx-2] prev1 = rates_or_df[idx-1] pattern_high = max(prev2[high_key], prev1[high_key], curr_high) sl = pattern_high + buffer reason = f'Above Evening Star high ({pattern_high:.5f}) + buffer {buffer_pips}p' else: sl = curr_high + buffer reason = f'Above candle high + buffer {buffer_pips}p' elif pattern_name in ('Three Black Crows', 'Falling Three Methods'): lookback = 4 if 'Three Methods' in pattern_name else 2 if idx >= lookback: if is_df: first = rates_or_df.iloc[idx-lookback] else: first = rates_or_df[idx-lookback] sl = first[high_key] + buffer reason = f'Above pattern first candle high ({first[high_key]:.5f}) + buffer {buffer_pips}p' else: sl = curr_high + buffer reason = f'Above candle high + buffer {buffer_pips}p' elif 'Bearish Engulfing' in pattern_name: sl = curr_high + buffer reason = f'Above Engulfing candle high ({curr_high:.5f}) + buffer {buffer_pips}p' elif 'Bearish Harami' in pattern_name: if idx >= 1: if is_df: prev = rates_or_df.iloc[idx-1] else: prev = rates_or_df[idx-1] sl = max(prev[high_key], curr_high) + buffer reason = f'Above Harami pattern high ({max(prev[high_key], curr_high):.5f}) + buffer {buffer_pips}p' else: sl = curr_high + buffer reason = f'Above candle high + buffer {buffer_pips}p' elif pattern_name == 'Tweezer Tops': sl = curr_high + buffer reason = f'Above Tweezer Tops high ({curr_high:.5f}) + buffer {buffer_pips}p' else: sl = curr_high + buffer reason = f'Above candle high ({curr_high:.5f}) + buffer {buffer_pips}p' return (round(sl, 5), reason) return None # ============================================================ # PATTERN DETECTION — Unified (scanner uses fb_detect_* via DataFrame adapter) # ============================================================ def detect_trend(rates, cfg=None): """Detect trend using SMA over configurable lookback.""" if cfg is None: cfg = CFG lookback = cfg.get('trend_lookback', 20) if isinstance(rates, pd.DataFrame): if len(rates) < lookback + 1: return 'ranging' closes = rates['CLOSE'].values if 'CLOSE' in rates.columns else rates['close'].values recent = closes[-(lookback+1):] sma = np.mean(recent[:-1]) current_close = recent[-1] else: if len(rates) < lookback + 1: return 'ranging' recent = rates[-(lookback+1):] closes = np.array([r['close'] for r in recent]) sma = np.mean(closes[:-1]) current_close = closes[-1] if current_close > sma: return 'uptrend' elif current_close < sma: return 'downtrend' else: return 'ranging' def compute_atr(rates, cfg=None): """Compute ATR using Wilder's exponential smoothing (standard ATR method). Uses alpha = 1/period for EMA smoothing, matching MT5's built-in ATR. This is the industry-standard method and differs from simple moving average by 5-15% on typical data. """ if cfg is None: cfg = CFG period = cfg.get('atr_period', 14) if len(rates) < period + 1: ranges = [r['high'] - r['low'] for r in rates] return np.mean(ranges) if ranges else 0.001 tr_values = [] for i in range(1, len(rates)): hl = rates[i]['high'] - rates[i]['low'] hc = abs(rates[i]['high'] - rates[i-1]['close']) lc = abs(rates[i]['low'] - rates[i-1]['close']) tr_values.append(max(hl, hc, lc)) if len(tr_values) < period: return np.mean(tr_values) # Wilder's smoothing: seed with SMA of first 'period' values, then EMA atr_val = np.mean(tr_values[:period]) alpha = 1.0 / period for i in range(period, len(tr_values)): atr_val = alpha * tr_values[i] + (1.0 - alpha) * atr_val return atr_val def mt5_rates_to_df(rates, cfg=None): """Convert MT5 structured array to a minimal DataFrame for unified pattern detection. This adapter allows the scanner to use the same fb_detect_* functions as the backtest, eliminating ~400 lines of code duplication. The DataFrame has the same column names (UPPERCASE) as the backtest DataFrame. Also pre-computes BODY, BODY_SIGN, RANGE, UPPER_WICK, LOWER_WICK, BODY_RATIO columns so the fb_detect_* functions work without modification. Args: rates: MT5 structured array (from mt5.copy_rates_from_pos) cfg: configuration dict Returns: pd.DataFrame with UPPER-CASE column names matching backtest format """ if rates is None or len(rates) == 0: return pd.DataFrame() # Build DataFrame from structured array rows = [] for r in rates: rows.append({ 'time': r['time'], 'OPEN': r['open'], 'HIGH': r['high'], 'LOW': r['low'], 'CLOSE': r['close'], 'TICKVOL': r['tick_volume'], 'VOL': r.get('real_volume', 0), 'SPREAD': r.get('spread', 0), }) df = pd.DataFrame(rows) df['DATETIME'] = pd.to_datetime(df['time'], unit='s') df['DATE'] = df['DATETIME'].dt.strftime('%Y.%m.%d') df['TIME'] = df['DATETIME'].dt.strftime('%H:%M:%S') df['IN_RANGE'] = True # All scanner bars are "in range" df['BODY'] = abs(df['CLOSE'] - df['OPEN']) df['BODY_SIGN'] = np.where(df['CLOSE'] >= df['OPEN'], 1, -1) df['RANGE'] = df['HIGH'] - df['LOW'] df['UPPER_WICK'] = df['HIGH'] - df[['OPEN', 'CLOSE']].max(axis=1) df['LOWER_WICK'] = df[['OPEN', 'CLOSE']].min(axis=1) - df['LOW'] df['BODY_RATIO'] = np.where(df['RANGE'] > 0, df['BODY'] / df['RANGE'], 0) return df # ── Scanner-specific detect_* functions removed (v8) ──────────── # Pattern detection is now unified: scan_patterns() converts MT5 # structured arrays to DataFrames and uses the fb_detect_* functions # that are also used by the backtest. This eliminates ~400 lines of # code duplication and ensures scanner/backtest always use identical # detection logic. # # Removed functions: # get_candle_metrics, detect_doji, detect_spinning_top, detect_marubozu, # detect_hammer, detect_inverted_hammer, detect_shooting_star, # detect_hanging_man, detect_near_engulfing_full, detect_engulfing_full, # detect_harami_full, detect_morning_star, detect_evening_star, # detect_three_white_soldiers, detect_three_black_crows, detect_tweezer, # detect_rising_three_methods, detect_falling_three_methods, # check_volume_confirmed # ============================================================ # ENTRY PRICE LOGIC # ============================================================ def compute_entry_details(candle, pattern_name, direction, trend, idx, rates, cfg=None): """Compute trade entry price based on pattern and candle structure.""" if cfg is None: cfg = CFG body_top = max(candle['open'], candle['close']) body_bottom = min(candle['open'], candle['close']) body_mid = (body_top + body_bottom) / 2.0 is_bullish_candle = candle['close'] >= candle['open'] entry_type = entry_price = entry_reason = None if direction == 'Bullish': if pattern_name in ('Hammer', 'Inverted Hammer', 'Morning Star', 'Three White Soldiers', 'Tweezer Bottoms', 'Rising Three Methods') \ or 'Bullish Engulfing' in pattern_name \ or 'Bullish Harami' in pattern_name: entry_type, entry_price = 'Buy Stop', round(body_top, 5) entry_reason = f'Break above body top ({body_top:.5f}) confirms bullish signal' elif 'Marubozu' in pattern_name and 'Bullish' in pattern_name: entry_type, entry_price = 'Market Buy', round(candle['close'], 5) entry_reason = f'Bullish Marubozu close ({candle["close"]:.5f}) — strong momentum' else: entry_type, entry_price = 'Buy Stop', round(body_top, 5) entry_reason = f'Break above body top ({body_top:.5f})' elif direction == 'Bearish': if pattern_name in ('Evening Star', 'Shooting Star', 'Hanging Man', 'Three Black Crows', 'Falling Three Methods', 'Tweezer Tops') \ or 'Bearish Engulfing' in pattern_name \ or 'Bearish Harami' in pattern_name: entry_type, entry_price = 'Sell Stop', round(body_bottom, 5) entry_reason = f'Break below body bottom ({body_bottom:.5f}) confirms bearish signal' elif 'Marubozu' in pattern_name and 'Bearish' in pattern_name: entry_type, entry_price = 'Market Sell', round(candle['close'], 5) entry_reason = f'Bearish Marubozu close ({candle["close"]:.5f}) — strong momentum' else: entry_type, entry_price = 'Sell Stop', round(body_bottom, 5) entry_reason = f'Break below body bottom ({body_bottom:.5f})' else: entry_type = 'Breakout' entry_price = None entry_reason = 'Wait for breakout: Buy Stop above body top OR Sell Stop below body bottom' return { 'body_top': round(body_top, 5), 'body_bottom': round(body_bottom, 5), 'body_mid': round(body_mid, 5), 'is_bullish_candle': is_bullish_candle, 'entry_type': entry_type, 'entry_price': entry_price, 'aggressive_entry': round(candle['close'], 5), 'entry_reason': entry_reason, } def verify_entry_fill(entry_type, entry_price, next_candle, cfg=None): """Verify whether a stop/market entry would be filled on the next candle.""" if cfg is None: cfg = CFG if not cfg.get('verify_entry', True): return True, entry_price if entry_type == 'Market Buy': return True, next_candle['open'] elif entry_type == 'Market Sell': return True, next_candle['open'] elif entry_type == 'Buy Stop': if next_candle['high'] >= entry_price: return True, max(next_candle['open'], entry_price) return False, None elif entry_type == 'Sell Stop': if next_candle['low'] <= entry_price: return True, min(next_candle['open'], entry_price) return False, None return True, entry_price # ============================================================ # BACKTEST STATS LOADER (for live scanner integration) # ============================================================ def load_latest_backtest_stats(output_dir=None, symbol=None, cfg=None): """Load pattern & session performance from latest backtest CSVs or JSON cache. Tries multiple sources in order: 1. v5 JSON cache (latest_stats.json) — flat structure with patterns/sessions/cross 2. v6 JSON cache (latest_stats_multitf.json) — multi-TF nested structure 3. Fall back to parsing CSV files (supports both v5 and v6 naming) Returns dict with keys: patterns, sessions, overall, cross, generated_at """ if cfg is None: cfg = CFG if output_dir is None: output_dir = DEFAULT_OUTPUT_DIR if symbol is None: symbol = cfg.get('symbol', 'EURUSD') cache_hours = cfg.get('stats_cache_hours', 4) # ── Try v5 JSON cache first (flat structure with pattern/session/cross stats) ── v5_cache_path = os.path.join(output_dir, 'latest_stats.json') if os.path.exists(v5_cache_path): try: with open(v5_cache_path, 'r', encoding='utf-8') as f: stats = json.load(f) # v5 cache has 'patterns', 'sessions', 'overall', 'cross' at top level if stats.get('patterns') or stats.get('overall'): generated = stats.get('generated_at', '') if generated: gen_dt = datetime.strptime(generated, '%Y-%m-%d %H:%M:%S') age_hours = (datetime.now() - gen_dt).total_seconds() / 3600 if age_hours < cache_hours * 24: # v5 cache: allow 24h staleness return stats except Exception: pass # ── Try v6 multi-TF JSON cache ── v6_cache_path = os.path.join(output_dir, 'latest_stats_multitf.json') if os.path.exists(v6_cache_path): try: with open(v6_cache_path, 'r', encoding='utf-8') as f: v6_stats = json.load(f) generated = v6_stats.get('generated_at', '') if generated: gen_dt = datetime.strptime(generated, '%Y-%m-%d %H:%M:%S') age_hours = (datetime.now() - gen_dt).total_seconds() / 3600 if age_hours < cache_hours * 24: # Convert v6 multi-TF structure to v5 flat structure # Aggregate across all timeframes into unified stats stats = _merge_multitf_stats(v6_stats, output_dir, symbol) if stats.get('patterns') or stats.get('overall'): return stats except Exception: pass # ── Fall back to parsing CSVs (both v5 and v6 naming) ── stats = {'patterns': {}, 'sessions': {}, 'overall': {}, 'cross': {}} # Find latest CSVs — try v5 naming first, then v6 naming pattern_csvs = sorted( glob.glob(os.path.join(output_dir, f"{symbol}_*_pattern_summary.csv")) + glob.glob(os.path.join(output_dir, f"{symbol}_*_*_to_*_pattern_summary.csv")), reverse=True ) session_csvs = sorted( glob.glob(os.path.join(output_dir, f"{symbol}_*_session_summary.csv")) + glob.glob(os.path.join(output_dir, f"{symbol}_*_*_to_*_session_summary.csv")), reverse=True ) det_csvs = sorted( glob.glob(os.path.join(output_dir, f"{symbol}_*_detections.csv")) + glob.glob(os.path.join(output_dir, f"{symbol}_*_*_to_*_detections.csv")), reverse=True ) if pattern_csvs: try: df_p = pd.read_csv(pattern_csvs[0]) for _, row in df_p.iterrows(): pat = row['Pattern'] stats['patterns'][pat] = { 'win_rate': round(float(row.get('Win_Rate_%', 0)), 1), 'total': int(row.get('Total', 0)), 'avg_max_r': round(float(row.get('Avg_Max_R', 0)), 2), 'sl_hit_pct': round(float(row.get('SL_Hit_%', 0)), 1), 'tp_hit_pct': round(float(row.get('TP_Hit_%', 0)), 1), } except Exception: pass if session_csvs: try: df_s = pd.read_csv(session_csvs[0]) for _, row in df_s.iterrows(): sess = row['Session'] stats['sessions'][sess] = { 'win_rate': round(float(row.get('Win_Rate_%', 0)), 1), 'signals': int(row.get('Signals', 0)), 'avg_max_r': round(float(row.get('Avg_Max_R', 0)), 2), 'sl_hit_pct': round(float(row.get('SL_Hit_%', 0)), 1), 'tp_hit_pct': round(float(row.get('TP_Hit_%', 0)), 1), } except Exception: pass # Overall + cross stats from detections CSV if det_csvs: try: df_d = pd.read_csv(det_csvs[0]) directional = df_d[df_d['Direction'] != 'Neutral'] if len(directional) > 0: s = int((directional['Prediction_Success'] == True).sum()) f_ = int((directional['Prediction_Success'] == False).sum()) stats['overall'] = { 'win_rate': round(s / (s + f_) * 100, 1) if (s + f_) > 0 else 0, 'total_signals': len(directional), 'avg_max_r': round(float(directional['Max_R'].dropna().mean()), 2), 'sl_hit_pct': round(float((directional['SL_Hit'] == True).sum() / len(directional) * 100), 1), 'tp_hit_pct': round(float((directional['TP_Hit'] == True).sum() / len(directional) * 100), 1), } cross = {} for pat_name in directional['Pattern'].unique(): pat_dir = directional[directional['Pattern'] == pat_name] for sess in pat_dir['Session'].unique(): ps = pat_dir[pat_dir['Session'] == sess] if len(ps) >= 3: s_ps = int((ps['Prediction_Success'] == True).sum()) f_ps = int((ps['Prediction_Success'] == False).sum()) cross[f"{pat_name}|{sess}"] = { 'win_rate': round(s_ps / (s_ps + f_ps) * 100, 1) if (s_ps + f_ps) > 0 else 0, 'signals': len(ps), 'avg_max_r': round(float(ps['Max_R'].dropna().mean()), 2), } stats['cross'] = cross except Exception: pass stats['generated_at'] = datetime.now().strftime('%Y-%m-%d %H:%M:%S') return stats def _merge_multitf_stats(v6_stats, output_dir, symbol): """Merge v6 multi-TF stats into v5 flat structure for display compatibility. Reads ALL per-TF CSVs (pattern_summary, session_summary, detections) and: - Builds per-TF pattern stats in stats['patterns_tf'] - Properly merges across all TFs for overall pattern/session/cross stats - Carries per-TF overall stats from the v6 JSON """ tf_order = ['M5', 'M15', 'H1', 'H4', 'D1'] stats = {'patterns': {}, 'sessions': {}, 'overall': {}, 'cross': {}, 'generated_at': v6_stats.get('generated_at', ''), 'patterns_tf': {tf: {} for tf in tf_order}, 'timeframes': {}} # Carry over per-TF overall stats from the v6 JSON for tf_label, tf_data in v6_stats.get('timeframes', {}).items(): if 'overall' in tf_data: stats['timeframes'][tf_label] = tf_data['overall'] # Carry over per-TF pattern stats from enriched JSON (v7+) if 'patterns' in tf_data: for pat, pat_data in tf_data['patterns'].items(): stats['patterns_tf'][tf_label][pat] = pat_data # ── Build merged stats from enriched JSON if available (v7+), else fall back to CSVs ── # Check if the JSON has per-TF pattern/session/cross data (v7 enrichment) has_enriched_data = any('patterns' in tf_data for tf_data in v6_stats.get('timeframes', {}).values()) if has_enriched_data: # Build merged stats directly from JSON — no CSV parsing needed # Merged patterns (weighted average across TFs) all_pat_data = {} # pat -> list of (n, wr, amr, sl_pct, tp_pct) for tf_label, tf_data in v6_stats.get('timeframes', {}).items(): for pat, pat_data in tf_data.get('patterns', {}).items(): if pat not in all_pat_data: all_pat_data[pat] = [] all_pat_data[pat].append(pat_data) for pat, entries in all_pat_data.items(): total_sig = sum(e.get('total', 0) for e in entries) if total_sig > 0: total_wins = sum(round(e.get('win_rate', 0) * e.get('total', 0) / 100) for e in entries) total_maxr_w = sum(e.get('avg_max_r', 0) * e.get('total', 0) for e in entries) total_sl_w = sum(e.get('sl_hit_pct', 0) * e.get('total', 0) for e in entries) total_tp_w = sum(e.get('tp_hit_pct', 0) * e.get('total', 0) for e in entries) stats['patterns'][pat] = { 'win_rate': round(total_wins / total_sig * 100, 1), 'total': total_sig, 'avg_max_r': round(total_maxr_w / total_sig, 2), 'sl_hit_pct': round(total_sl_w / total_sig, 1), 'tp_hit_pct': round(total_tp_w / total_sig, 1), } # Merged sessions (weighted average across TFs) all_sess_data = {} for tf_label, tf_data in v6_stats.get('timeframes', {}).items(): for sess, sess_data in tf_data.get('sessions', {}).items(): if sess not in all_sess_data: all_sess_data[sess] = [] all_sess_data[sess].append(sess_data) for sess, entries in all_sess_data.items(): total_sig = sum(e.get('signals', 0) for e in entries) if total_sig > 0: total_wins = sum(round(e.get('win_rate', 0) * e.get('signals', 0) / 100) for e in entries) total_maxr_w = sum(e.get('avg_max_r', 0) * e.get('signals', 0) for e in entries) stats['sessions'][sess] = { 'win_rate': round(total_wins / total_sig * 100, 1), 'signals': total_sig, 'avg_max_r': round(total_maxr_w / total_sig, 2), } # Merged cross stats (weighted average across TFs) all_cross_data = {} for tf_label, tf_data in v6_stats.get('timeframes', {}).items(): for cross_key, cross_data in tf_data.get('cross', {}).items(): if cross_key not in all_cross_data: all_cross_data[cross_key] = [] all_cross_data[cross_key].append(cross_data) for cross_key, entries in all_cross_data.items(): total_sig = sum(e.get('signals', 0) for e in entries) if total_sig >= 3: total_wins = sum(round(e.get('win_rate', 0) * e.get('signals', 0) / 100) for e in entries) total_maxr_w = sum(e.get('avg_max_r', 0) * e.get('signals', 0) for e in entries) stats['cross'][cross_key] = { 'win_rate': round(total_wins / total_sig * 100, 1), 'signals': total_sig, 'avg_max_r': round(total_maxr_w / total_sig, 2), } # Overall (aggregate across all TFs) total_all = sum(stats['timeframes'].get(tf, {}).get('total_signals', 0) for tf in tf_order) if total_all > 0: total_wins = sum(round(stats['timeframes'].get(tf, {}).get('win_rate', 0) * stats['timeframes'].get(tf, {}).get('total_signals', 0) / 100) for tf in tf_order) total_maxr = sum(stats['timeframes'].get(tf, {}).get('avg_max_r', 0) * stats['timeframes'].get(tf, {}).get('total_signals', 0) for tf in tf_order) stats['overall'] = { 'win_rate': round(total_wins / total_all * 100, 1), 'total_signals': total_all, 'avg_max_r': round(total_maxr / total_all, 2), } else: # Fall back to CSV parsing for older JSON formats (v6 without enrichment) pattern_csvs = sorted( glob.glob(os.path.join(output_dir, f"{symbol}_*_*_to_*_pattern_summary.csv")), reverse=True ) if pattern_csvs: try: all_dfs = [pd.read_csv(p) for p in pattern_csvs] df_all = pd.concat(all_dfs, ignore_index=True) # Per-TF pattern stats for tf in tf_order: tf_rows = df_all[df_all.get('Timeframe', pd.Series(dtype=str)) == tf] if len(tf_rows) > 0: for _, row in tf_rows.iterrows(): pat = row['Pattern'] stats['patterns_tf'][tf][pat] = { 'win_rate': round(float(row.get('Win_Rate_%', 0)), 1), 'total': int(row.get('Total', 0)), 'avg_max_r': round(float(row.get('Avg_Max_R', 0)), 2), } # Merged across all TFs (weighted by signal count) for pat in df_all['Pattern'].unique(): rows = df_all[df_all['Pattern'] == pat] total_sig = int(rows['Total'].sum()) if total_sig > 0: total_wins = 0 total_maxr_w = 0.0 total_sl_w = 0.0 total_tp_w = 0.0 for _, r in rows.iterrows(): n = int(r.get('Total', 0)) if n > 0: total_wins += round(float(r.get('Win_Rate_%', 0)) * n / 100) total_maxr_w += float(r.get('Avg_Max_R', 0)) * n total_sl_w += float(r.get('SL_Hit_%', 0)) * n total_tp_w += float(r.get('TP_Hit_%', 0)) * n stats['patterns'][pat] = { 'win_rate': round(total_wins / total_sig * 100, 1), 'total': total_sig, 'avg_max_r': round(total_maxr_w / total_sig, 2), 'sl_hit_pct': round(total_sl_w / total_sig, 1), 'tp_hit_pct': round(total_tp_w / total_sig, 1), } except Exception: pass # ── Parse ALL session_summary CSVs ── session_csvs = sorted( glob.glob(os.path.join(output_dir, f"{symbol}_*_*_to_*_session_summary.csv")), reverse=True ) if session_csvs: try: all_dfs = [pd.read_csv(s) for s in session_csvs] df_all = pd.concat(all_dfs, ignore_index=True) for sess in df_all['Session'].unique(): rows = df_all[df_all['Session'] == sess] total_sig = int(rows['Signals'].sum()) if total_sig > 0: total_wins = 0 total_maxr_w = 0.0 total_sl_w = 0.0 total_tp_w = 0.0 for _, r in rows.iterrows(): n = int(r.get('Signals', 0)) if n > 0: total_wins += round(float(r.get('Win_Rate_%', 0)) * n / 100) total_maxr_w += float(r.get('Avg_Max_R', 0)) * n total_sl_w += float(r.get('SL_Hit_%', 0)) * n total_tp_w += float(r.get('TP_Hit_%', 0)) * n stats['sessions'][sess] = { 'win_rate': round(total_wins / total_sig * 100, 1), 'signals': total_sig, 'avg_max_r': round(total_maxr_w / total_sig, 2), 'sl_hit_pct': round(total_sl_w / total_sig, 1), 'tp_hit_pct': round(total_tp_w / total_sig, 1), } except Exception: pass # ── Parse ALL detections CSVs for overall + cross stats ── det_csvs = sorted( glob.glob(os.path.join(output_dir, f"{symbol}_*_*_to_*_detections.csv")), reverse=True ) if det_csvs: try: all_dfs = [pd.read_csv(d) for d in det_csvs] df_d = pd.concat(all_dfs, ignore_index=True) directional = df_d[df_d['Direction'] != 'Neutral'] if len(directional) > 0: s = int((directional['Prediction_Success'] == True).sum()) f_ = int((directional['Prediction_Success'] == False).sum()) stats['overall'] = { 'win_rate': round(s / (s + f_) * 100, 1) if (s + f_) > 0 else 0, 'total_signals': len(directional), 'avg_max_r': round(float(directional['Max_R'].dropna().mean()), 2), 'sl_hit_pct': round(float((directional['SL_Hit'] == True).sum() / len(directional) * 100), 1), 'tp_hit_pct': round(float((directional['TP_Hit'] == True).sum() / len(directional) * 100), 1), } cross = {} for pat_name in directional['Pattern'].unique(): pat_dir = directional[directional['Pattern'] == pat_name] for sess in pat_dir['Session'].unique(): ps = pat_dir[pat_dir['Session'] == sess] if len(ps) >= 3: s_ps = int((ps['Prediction_Success'] == True).sum()) f_ps = int((ps['Prediction_Success'] == False).sum()) cross[f"{pat_name}|{sess}"] = { 'win_rate': round(s_ps / (s_ps + f_ps) * 100, 1) if (s_ps + f_ps) > 0 else 0, 'signals': len(ps), 'avg_max_r': round(float(ps['Max_R'].dropna().mean()), 2), } stats['cross'] = cross except Exception: pass return stats def compute_pattern_tier(pattern_name, stats, cfg=None): """Classify a pattern into a tier (A/B/C/D) based on backtest statistics. Tier A (Elite): WR >= 58% AND sample >= 30 AND avg_max_r >= 0.35R Tier B (Tradeable): WR >= 50% AND sample >= 10 AND avg_max_r >= 0.25R Tier C (Marginal): WR >= 40% AND sample >= 5 Tier D (Avoid): WR < 40% OR insufficient data """ if cfg is None: cfg = CFG min_sig = cfg.get('min_signals_for_stats', 5) pat_stats = stats.get('patterns', {}).get(pattern_name, {}) n = pat_stats.get('total', 0) wr = pat_stats.get('win_rate', 0) amr = pat_stats.get('avg_max_r', 0) if n < min_sig: return ('D', 'AVOID', 'red') if wr >= 58 and n >= 30 and amr >= 0.35: return ('A', 'ELITE', 'green') elif wr >= 50 and n >= 10 and amr >= 0.25: return ('B', 'TRADEABLE', 'yellow') elif wr >= 40: return ('C', 'MARGINAL', 'red') else: return ('D', 'AVOID', 'red') def compute_session_quality(session, stats, cfg=None): """Classify session quality based on directional win rate and R-multiples. Returns: (quality_label, quality_color, sess_wr, sess_n, sess_amr) """ if cfg is None: cfg = CFG min_sig = cfg.get('min_signals_for_stats', 5) sess_stats = stats.get('sessions', {}).get(session, {}) n = sess_stats.get('signals', 0) wr = sess_stats.get('win_rate', 0) amr = sess_stats.get('avg_max_r', 0) if n < min_sig: return ('UNKNOWN', 'dim', 0, n, 0) if wr >= 55 and amr >= 0.35: return ('PRIME', 'green', wr, n, amr) elif wr >= 50: return ('FAVORABLE', 'green', wr, n, amr) elif wr >= 45: return ('NEUTRAL', 'yellow', wr, n, amr) else: return ('UNFAVORABLE', 'red', wr, n, amr) def compute_cross_quality(pattern_name, session, stats, cfg=None): """Get the most specific win rate and quality for a pattern+session combo. Returns: (cross_wr, cross_n, cross_amr, cross_label, cross_color) """ if cfg is None: cfg = CFG min_sig = cfg.get('min_signals_for_stats', 5) cross_key = f"{pattern_name}|{session}" cross_stats = stats.get('cross', {}).get(cross_key, {}) pat_stats = stats.get('patterns', {}).get(pattern_name, {}) if cross_stats and cross_stats.get('signals', 0) >= min_sig: wr = cross_stats.get('win_rate', 0) n = cross_stats.get('signals', 0) amr = cross_stats.get('avg_max_r', 0) elif pat_stats and pat_stats.get('total', 0) >= min_sig: wr = pat_stats.get('win_rate', 0) n = pat_stats.get('total', 0) amr = pat_stats.get('avg_max_r', 0) elif stats.get('overall', {}).get('total_signals', 0) >= min_sig: wr = stats['overall'].get('win_rate', 0) n = stats['overall'].get('total_signals', 0) amr = stats['overall'].get('avg_max_r', 0) else: return (None, 0, 0, 'N/A', 'dim') if wr >= 60: return (wr, n, amr, 'HIGH EDGE', 'green') elif wr >= 50: return (wr, n, amr, 'EDGE', 'yellow') elif wr >= 40: return (wr, n, amr, 'WEAK', 'red') else: return (wr, n, amr, 'NO EDGE', 'red') def compute_signal_score(pattern_name, session, direction, stats, cfg=None, tf_label=None): """Compute a 0-100 signal quality score based on historical backtest stats. Enhanced formula (v7): base = raw win rate (0-100) sample_penalty = penalty if sample size is small (avoids over-scoring rare patterns) session_gradient = proportional session bonus/penalty (not binary) confluence_bonus = +5 if confluence >= 3 (from backtest confluence stats) tier_bonus = +5 for Tier A, +3 for Tier B Prefers TF-specific stats when available (tf_label provided and stats have per-TF breakdown), falling back to merged aggregate stats. """ if cfg is None: cfg = CFG min_signals = cfg.get('min_signals_for_stats', 5) # Try TF-specific stats first if tf_label is provided pat_stats = {} sess_stats = {} cross_key = f"{pattern_name}|{session}" cross_stats = {} if tf_label and tf_label in stats.get('timeframes', {}): tf_data = stats['timeframes'][tf_label] pat_stats = tf_data.get('patterns', {}).get(pattern_name, {}) sess_stats = tf_data.get('sessions', {}).get(session, {}) cross_stats = tf_data.get('cross', {}).get(cross_key, {}) # Fallback to merged stats if TF-specific not available if not pat_stats: pat_stats = stats.get('patterns', {}).get(pattern_name, {}) if not sess_stats: sess_stats = stats.get('sessions', {}).get(session, {}) if not cross_stats: cross_stats = stats.get('cross', {}).get(cross_key, {}) # Select most specific data source with sufficient sample if cross_stats and cross_stats.get('signals', 0) >= min_signals: wr = cross_stats.get('win_rate', 50) n = cross_stats.get('signals', 0) amr = cross_stats.get('avg_max_r', 0) elif pat_stats and pat_stats.get('total', 0) >= min_signals: wr = pat_stats.get('win_rate', 50) n = pat_stats.get('total', 0) amr = pat_stats.get('avg_max_r', 0) elif stats.get('overall', {}).get('total_signals', 0) >= min_signals: overall = stats['overall'] wr = overall.get('win_rate', 50) n = overall.get('total_signals', 0) amr = overall.get('avg_max_r', 0) else: return None # Base score = raw win rate base_score = wr # Sample penalty: penalize low sample sizes instead of multiplying # At 30+ signals, no penalty. Below 30, linear penalty down to -15 at min_signals. if n >= 30: sample_penalty = 0 elif n >= min_signals: sample_penalty = -15.0 * (1.0 - (n - min_signals) / (30.0 - min_signals)) else: sample_penalty = -20.0 # Session gradient: proportional bonus/penalty based on session WR session_gradient = 0 if sess_stats and sess_stats.get('signals', 0) >= min_signals: sess_wr = sess_stats.get('win_rate', 50) # Gradient: +8 at 60% WR, +4 at 55%, 0 at 50%, -4 at 45%, -8 at 40% session_gradient = round((sess_wr - 50) * 0.8, 1) # Confluence bonus: +5 if high-confluence signals (upper half of range) perform well # With d1_trend_filter active, effective range is 0-6, so high = scores 3,4,5 # Without the filter, effective range is 0-7, so high = scores 4,5,6 confluence_bonus = 0 if tf_label and tf_label in stats.get('timeframes', {}): conf_data = stats['timeframes'][tf_label].get('confluence', {}) # Determine threshold based on d1_trend_filter if cfg.get('d1_trend_filter', False): high_keys = ['3', '4', '5'] # upper half of 0-6 range else: high_keys = ['4', '5', '6'] # upper half of 0-7 range high_conf = None for k in high_keys: entry = conf_data.get(k, {}) if entry.get('signals', 0) >= 5: high_conf = entry break if high_conf and high_conf.get('win_rate', 0) >= 55: confluence_bonus = 5 # Tier bonus tier_letter, _, _ = compute_pattern_tier(pattern_name, stats, cfg) tier_bonus = 5 if tier_letter == 'A' else (3 if tier_letter == 'B' else 0) # MFE bonus: patterns with higher MFE have more profit potential mfe_bonus = 0 if amr >= 0.8: mfe_bonus = 3 elif amr >= 0.5: mfe_bonus = 1 score = base_score + sample_penalty + session_gradient + confluence_bonus + tier_bonus + mfe_bonus return round(max(0, min(100, score)), 1) def print_top_setups(stats, cfg=None): """Print best historical setups at scanner start — top patterns, sessions, and cross-stats.""" if cfg is None: cfg = CFG min_sig = cfg.get('min_signals_for_stats', 5) min_wr = cfg.get('min_historical_win_rate', 50.0) lines = [] lines.append("") lines.append(C('cyan', "=" * 70)) lines.append(C('bold', " TOP HISTORICAL SETUPS (from latest backtest)")) lines.append(C('cyan', "=" * 70)) overall = stats.get('overall', {}) if overall: owr = overall.get('win_rate', 0) owr_color = 'green' if owr >= min_wr else 'red' lines.append(f" Overall: {C(owr_color, f'WR {owr:.1f}%')} | {overall.get('total_signals',0)} signals | Avg Max R: {overall.get('avg_max_r',0):.2f}R") # Per-timeframe breakdown tf_stats = stats.get('timeframes', {}) if tf_stats: lines.append(f" {'Timeframe':<12s} | {'WR':>6s} | {'Signals':>8s} | {'Avg Max R':>10s}") lines.append(f" {'-'*12} | {'-'*6} | {'-'*8} | {'-'*10}") for tf_label, tf_overall in tf_stats.items(): twr = tf_overall.get('win_rate', 0) tclr = 'green' if twr >= min_wr else ('yellow' if twr >= 45 else 'red') lines.append(f" {tf_label:<12s} | {C(tclr, f'{twr:>5.1f}%')} | {tf_overall.get('total_signals',0):>8d} | {tf_overall.get('avg_max_r',0):>9.2f}R") pat_list = [] patterns_tf = stats.get('patterns_tf', {}) for pat, data in stats.get('patterns', {}).items(): n = data.get('total', 0) wr = data.get('win_rate', 0) amr = data.get('avg_max_r', 0) if n >= min_sig: confidence = min(1.0, n / 30.0) weighted = wr * confidence + min(amr, 2.0) * 10 tier_letter, tier_label, tier_clr = compute_pattern_tier(pat, stats, cfg) # Find best TF for this pattern best_tf, best_tf_wr = '', 0 tf_wrs = {} for tf in ['M5', 'M15', 'H1', 'H4', 'D1']: if pat in patterns_tf.get(tf, {}): tf_wr = patterns_tf[tf][pat].get('win_rate', 0) tf_n = patterns_tf[tf][pat].get('total', 0) tf_wrs[tf] = (tf_wr, tf_n) if tf_n >= min_sig else (None, tf_n) if tf_n >= min_sig and tf_wr > best_tf_wr: best_tf_wr = tf_wr best_tf = tf else: tf_wrs[tf] = (None, 0) pat_list.append((pat, wr, n, amr, weighted, tier_letter, tier_label, tier_clr, best_tf, tf_wrs)) pat_list.sort(key=lambda x: x[4], reverse=True) tf_cols = ['M5', 'M15', 'H1', 'H4', 'D1'] if pat_list: lines.append("") lines.append(f" {'Pattern':<28s} | {'Tier':>14s} | {'M5':>5s} | {'M15':>5s} | {'H1':>5s} | {'H4':>5s} | {'D1':>5s} | {'Sig':>6s} | {'Edge':>5s}") lines.append(f" {'-'*28} | {'-'*14} | {'-'*5} | {'-'*5} | {'-'*5} | {'-'*5} | {'-'*5} | {'-'*6} | {'-'*5}") for pat, wr, n, amr, weighted, tl, tlab, tc, best_tf, tf_wrs in pat_list[:7]: edge_tag = "HIGH" if wr >= min_wr else "LOW" edge_color = 'green' if wr >= min_wr else 'red' tf_cells = [] for tf in tf_cols: tf_wr, tf_n = tf_wrs.get(tf, (None, 0)) if tf_wr is not None: clr = 'green' if tf_wr >= min_wr else ('yellow' if tf_wr >= 45 else 'red') tf_cells.append(C(clr, f'{tf_wr:>4.1f}%')) else: tf_cells.append(f" {'--' if tf_n < min_sig else '':>4s} ") tf_str = ' | '.join(tf_cells) lines.append(f" {pat:<28s} | {C(tc, f'{tl}:{tlab}'):>14s} | {tf_str} | {n:>6d} | {C(edge_color, f'{edge_tag:>5s}')}") all_sess = [(s, d) for s, d in stats.get('sessions', {}).items() if d.get('signals', 0) >= min_sig] if all_sess: all_sess.sort(key=lambda x: x[1].get('win_rate', 0), reverse=True) lines.append("") lines.append(C('bold', " Session Quality:")) for sess, data in all_sess: swr = data.get('win_rate', 0) sq, sqc, _, sn, samr = compute_session_quality(sess, stats, cfg) lines.append(f" {sess:<22s} | {C(sqc, f'{swr:.1f}% WR [{sq}]')} ({sn} sig) | AvgMaxR: {samr:.2f}R") cross_list = [] for key, data in stats.get('cross', {}).items(): n = data.get('signals', 0) wr = data.get('win_rate', 0) amr = data.get('avg_max_r', 0) if n >= min_sig: confidence = min(1.0, n / 20.0) weighted = wr * confidence + min(amr, 2.0) * 10 cross_list.append((key, wr, n, amr, weighted)) cross_list.sort(key=lambda x: x[4], reverse=True) if cross_list: lines.append("") lines.append(f" {'Pattern x Session':<40s} | {'WR':>6s} | {'Sig':>4s} | {'MaxR':>5s}") lines.append(f" {'-'*40} | {'-'*6} | {'-'*4} | {'-'*5}") for key, wr, n, amr, weighted in cross_list[:5]: cwr_color = 'green' if wr >= min_wr else 'yellow' lines.append(f" {key:<40s} | {C(cwr_color, f'{wr:>5.1f}%')} | {n:>4d} | {amr:>4.2f}R") weak = [(p, d) for p, d in stats.get('patterns', {}).items() if d.get('total', 0) >= min_sig and d.get('win_rate', 0) < 45] if weak: weak.sort(key=lambda x: x[1].get('win_rate', 0)) lines.append("") lines.append(C('red', " Tier D — AVOID (WR < 45%):")) for pat, data in weak: wwr = data.get('win_rate', 0) _, _, wtc = compute_pattern_tier(pat, stats, cfg) lines.append(f" {pat:<30s} | {C(wtc, f'WR: {wwr:.1f}%')} ({data.get('total',0)} sig)") rec_setups = [] for key, data in stats.get('cross', {}).items(): n = data.get('signals', 0) wr = data.get('win_rate', 0) amr = data.get('avg_max_r', 0) if n >= min_sig: confidence = min(1.0, n / 20.0) score = wr * confidence + min(amr, 2.0) * 10 if score > 60: rec_setups.append((key, wr, n, amr, score)) for pat, data in stats.get('patterns', {}).items(): n = data.get('total', 0) wr = data.get('win_rate', 0) amr = data.get('avg_max_r', 0) if n >= min_sig: confidence = min(1.0, n / 30.0) score = wr * confidence + min(amr, 2.0) * 10 if score > 60: rec_key = f"{pat} (any session)" if not any(pat in k for k, _, _, _, _ in rec_setups): rec_setups.append((rec_key, wr, n, amr, score)) if rec_setups: rec_setups.sort(key=lambda x: x[4], reverse=True) lines.append("") lines.append(C('green', C('bold', " RECOMMENDED LIVE SETUPS (score > 60):"))) for key, wr, n, amr, score in rec_setups[:8]: lines.append(f" {key:<40s} | {C('green', f'WR: {wr:.1f}%')} | {n} sig | {C('bold', f'Score: {score:.1f}')}") lines.append(C('cyan', "=" * 70)) lines.append("") for line in lines: print(line) def apply_signal_score_filter(patterns, stats, cfg=None, tf_label=None): """Filter patterns by min_signal_score. Attaches signal_score to each pattern dict.""" if cfg is None: cfg = CFG min_score = cfg.get('min_signal_score', 0) if min_score <= 0 or not stats: for p in patterns: score = compute_signal_score(p['name'], p['session'], p['direction'], stats, cfg, tf_label=tf_label) p['signal_score'] = score return patterns filtered = [] for p in patterns: score = compute_signal_score(p['name'], p['session'], p['direction'], stats, cfg, tf_label=tf_label) p['signal_score'] = score if score is None or score >= min_score: filtered.append(p) return filtered # ============================================================ # SCANNER: scan last closed candle on a given timeframe # ============================================================ def scan_patterns(rates, cfg=None, d1_rates=None, tf_label='H4', htf_atr_rates=None): """Scan the last closed candle for all patterns. Returns list of dicts. Args: htf_atr_rates: Optional higher-timeframe rates (structured array) for ATR calculation. If provided and atr_tf_by_tf maps this TF to a higher TF, ATR is computed from these rates instead of native. """ if cfg is None: cfg = CFG # ── Use DataFrame-based detection (unified with backtest) ──────── scan_df = mt5_rates_to_df(rates, cfg) if len(scan_df) < 6: return [] idx = len(scan_df) - 1 row = scan_df.iloc[idx] cm = { 'body': row['BODY'], 'body_sign': row['BODY_SIGN'], 'range': row['RANGE'], 'upper_wick': row['UPPER_WICK'], 'lower_wick': row['LOWER_WICK'], 'body_ratio': row['BODY_RATIO'] } curr = {'open': row['OPEN'], 'high': row['HIGH'], 'low': row['LOW'], 'close': row['CLOSE'], 'time': row['time']} patterns = [] trend = detect_trend(scan_df[:idx+1], cfg) # Use higher-timeframe ATR if configured and rates provided atr_src = get_atr_tf(tf_label, cfg) if htf_atr_rates is not None and atr_src != tf_label: atr = compute_atr(htf_atr_rates, cfg) else: atr = compute_atr(rates, cfg) _ct = curr['time'] if isinstance(_ct, (int, float, np.integer, np.floating)): hour = broker_time(int(_ct)).hour elif hasattr(_ct, 'hour'): hour = _ct.hour else: hour = int(_ct) % 24 session = classify_session(hour, cfg) # Volume confirmation (DataFrame-based, matching backtest logic) vol_confirmed = True if cfg.get('volume_filter', False) and len(scan_df) > 0: vol_ma_period = cfg.get('volume_ma_period', 20) vol_thresh = cfg.get('volume_threshold', 1.0) start = max(0, idx - vol_ma_period) vols = scan_df.iloc[start:idx+1]['TICKVOL'].values if len(vols) >= 2: avg_vol = np.mean(vols[:-1]) if avg_vol > 0: vol_confirmed = vols[-1] >= vol_thresh * avg_vol # D1 trend filter d1_trend = 'N/A' if cfg.get('d1_trend_filter', False) and d1_rates is not None and len(d1_rates) >= cfg.get('d1_sma_period', 20): d1_closes = [r['close'] for r in d1_rates[-cfg['d1_sma_period']:]] d1_sma = np.mean(d1_closes) d1_close = d1_rates[-1]['close'] d1_trend = 'uptrend' if d1_close > d1_sma else ('downtrend' if d1_close < d1_sma else 'ranging') # Single-candle patterns (using unified fb_detect_* functions) if fb_detect_doji(scan_df, idx, cfg): patterns.append({'name': 'Doji', 'category': 'Neutral', 'direction': 'Neutral'}) if fb_detect_spinning_top(scan_df, idx, cfg): patterns.append({'name': 'Spinning Top', 'category': 'Neutral', 'direction': 'Neutral'}) if fb_detect_marubozu(scan_df, idx, cfg): d = 'Bullish' if cm['body_sign'] == 1 else 'Bearish' patterns.append({'name': f'Marubozu ({d})', 'category': f'{d} Continuation', 'direction': d}) if fb_detect_hammer(scan_df, idx, cfg): patterns.append({'name': 'Hammer', 'category': 'Bullish Reversal', 'direction': 'Bullish'}) if fb_detect_inverted_hammer(scan_df, idx, cfg): patterns.append({'name': 'Inverted Hammer', 'category': 'Bullish Reversal', 'direction': 'Bullish'}) if fb_detect_shooting_star(scan_df, idx, cfg): patterns.append({'name': 'Shooting Star', 'category': 'Bearish Reversal', 'direction': 'Bearish'}) if fb_detect_hanging_man(scan_df, idx, cfg): patterns.append({'name': 'Hanging Man', 'category': 'Bearish Reversal', 'direction': 'Bearish'}) # Two-candle patterns eng = fb_detect_engulfing(scan_df, idx, cfg) if eng: d = 'Bullish' if 'Bullish' in eng else 'Bearish' patterns.append({'name': eng, 'category': f'{d} Reversal', 'direction': d}) ne = fb_detect_near_engulfing(scan_df, idx, cfg) if ne: d = 'Bullish' if 'Bullish' in ne else 'Bearish' patterns.append({'name': ne, 'category': f'{d} Reversal', 'direction': d}) har = fb_detect_harami(scan_df, idx, cfg) if har: d = 'Bullish' if 'Bullish' in har else 'Bearish' patterns.append({'name': har, 'category': f'{d} Reversal', 'direction': d}) tw = fb_detect_tweezer(scan_df, idx, cfg) if tw: d = 'Bearish' if 'Tops' in tw else 'Bullish' patterns.append({'name': tw, 'category': f'{d} Reversal', 'direction': d}) # Three-candle patterns if fb_detect_morning_star(scan_df, idx, cfg): patterns.append({'name': 'Morning Star', 'category': 'Bullish Reversal', 'direction': 'Bullish'}) if fb_detect_evening_star(scan_df, idx, cfg): patterns.append({'name': 'Evening Star', 'category': 'Bearish Reversal', 'direction': 'Bearish'}) if fb_detect_three_white_soldiers(scan_df, idx, cfg): patterns.append({'name': 'Three White Soldiers', 'category': 'Bullish Reversal', 'direction': 'Bullish'}) if fb_detect_three_black_crows(scan_df, idx, cfg): patterns.append({'name': 'Three Black Crows', 'category': 'Bearish Reversal', 'direction': 'Bearish'}) # Five-candle patterns if fb_detect_rising_three_methods(scan_df, idx, cfg): patterns.append({'name': 'Rising Three Methods', 'category': 'Bullish Continuation', 'direction': 'Bullish'}) if fb_detect_falling_three_methods(scan_df, idx, cfg): patterns.append({'name': 'Falling Three Methods', 'category': 'Bearish Continuation', 'direction': 'Bearish'}) patterns = deduplicate_patterns(patterns, cfg) # D1 trend filter if cfg.get('d1_trend_filter', False) and d1_trend != 'N/A': filtered = [] for pat in patterns: if pat['direction'] == 'Bullish' and d1_trend == 'uptrend': filtered.append(pat) elif pat['direction'] == 'Bearish' and d1_trend == 'downtrend': filtered.append(pat) elif pat['direction'] == 'Neutral': filtered.append(pat) patterns = filtered if cfg.get('volume_filter', False): patterns = [p for p in patterns if p['direction'] == 'Neutral' or vol_confirmed] sl_mult = cfg['sl_multiplier'] tp_mult = cfg['tp_multiplier'] sl_mode = cfg.get('sl_mode', 'atr') for pat in patterns: d = pat['direction'] sl_reason = '' # Structure-based SL: use pattern's natural invalidation level struct_sl = None if sl_mode == 'structure' and d in ('Bullish', 'Bearish'): struct_result = compute_structure_sl(pat['name'], d, rates, idx, cfg) if struct_result is not None: struct_sl, sl_reason = struct_result if d == 'Bullish': if struct_sl is not None: pat['sl'] = struct_sl else: pat['sl'] = round(curr['low'] - sl_mult * atr, 5) risk = curr['close'] - pat['sl'] pat['tp'] = round(curr['close'] + risk * (tp_mult / sl_mult), 5) if sl_reason: pat['sl_reason'] = sl_reason elif d == 'Bearish': if struct_sl is not None: pat['sl'] = struct_sl else: pat['sl'] = round(curr['high'] + sl_mult * atr, 5) risk = pat['sl'] - curr['close'] pat['tp'] = round(curr['close'] - risk * (tp_mult / sl_mult), 5) if sl_reason: pat['sl_reason'] = sl_reason else: pat['sl'] = round(curr['low'] - sl_mult * atr, 5) risk_bull = curr['close'] - pat['sl'] pat['tp_long'] = round(curr['close'] + risk_bull * (tp_mult / sl_mult), 5) bearish_sl = round(curr['high'] + sl_mult * atr, 5) risk_bear = bearish_sl - curr['close'] pat['tp_short'] = round(curr['close'] - risk_bear * (tp_mult / sl_mult), 5) pat['atr'] = round(atr, 5) pat['atr_tf'] = atr_src pat['session'] = session pat['trend'] = trend pat['Volume_Confirmed'] = vol_confirmed pat['D1_Trend'] = d1_trend pat['timeframe'] = tf_label entry = compute_entry_details(curr, pat['name'], d, trend, idx, rates, cfg) pat.update(entry) if d == 'Bullish' and entry['entry_price'] is not None: pat['sl_dist_pips'] = round(abs(entry['entry_price'] - pat['sl']) * 10000, 1) pat['tp_dist_pips'] = round(abs(pat['tp'] - entry['entry_price']) * 10000, 1) pat['rr_ratio'] = round(pat['tp_dist_pips'] / pat['sl_dist_pips'], 2) if pat['sl_dist_pips'] > 0 else None elif d == 'Bearish' and entry['entry_price'] is not None: pat['sl_dist_pips'] = round(abs(pat['sl'] - entry['entry_price']) * 10000, 1) pat['tp_dist_pips'] = round(abs(entry['entry_price'] - pat['tp']) * 10000, 1) pat['rr_ratio'] = round(pat['tp_dist_pips'] / pat['sl_dist_pips'], 2) if pat['sl_dist_pips'] > 0 else None else: pat['sl_dist_pips'] = pat['tp_dist_pips'] = pat['rr_ratio'] = None return patterns def format_pattern_output(candle, patterns, cfg=None, stats=None, tf_label='H4'): """Format pattern detection results for display with colour-coded tier, historical backtest edge, and signal quality score.""" if cfg is None: cfg = CFG if stats is None: stats = {} ct = candle['time'] if isinstance(ct, (int, float, np.integer, np.floating)): ct = broker_time(int(ct)) time_str = ct.strftime("%Y-%m-%d %H:%M:%S") if hasattr(ct, 'strftime') else str(ct) bt = max(candle['open'], candle['close']) bb = min(candle['open'], candle['close']) lines = [] tf_color = {'M5': 'magenta', 'M15': 'blue', 'H1': 'cyan', 'H4': 'yellow', 'D1': 'white'}.get(tf_label, 'cyan') lines.append(C(tf_color, "=" * 80)) lines.append(C('bold', f" [{tf_label}] CANDLE CLOSE: {time_str}")) lines.append(f" Symbol: {C('yellow', cfg['symbol'])} | Timeframe: {C(tf_color, tf_label)}") close_str = f"{candle['close']:.5f}" lines.append(f" O: {candle['open']:.5f} H: {candle['high']:.5f} L: {candle['low']:.5f} C: {C('bold', close_str)}") lines.append(f" Body Top: {bt:.5f} | Body Bottom: {bb:.5f} | Size: {abs(candle['close']-candle['open'])*10000:.1f} pips") lines.append(C(tf_color, "=" * 80)) if not patterns: lines.append(C('dim', f" No patterns detected on {tf_label}.")) return "\n".join(lines) lines.append(C('bold', f" PATTERNS DETECTED: {len(patterns)}")) lines.append("-" * 80) min_wr = cfg.get('min_historical_win_rate', 50.0) min_sig = cfg.get('min_signals_for_stats', 5) for i, pat in enumerate(patterns, 1): direction = pat['direction'] dir_color = 'green' if direction == 'Bullish' else ('red' if direction == 'Bearish' else 'yellow') # ── Pre-compute tier, session quality, cross quality ── tier_letter, tier_label, tier_color = compute_pattern_tier(pat['name'], stats, cfg) sess_quality, sess_q_color, sess_wr, sess_n, sess_amr = compute_session_quality(pat['session'], stats, cfg) cross_wr, cross_n, cross_amr, cross_ql, cross_qc = compute_cross_quality(pat['name'], pat['session'], stats, cfg) # ── Pattern header with TIER badge ── tier_badge = C(tier_color, C('bold', f'[Tier {tier_letter}]')) lines.append(f"\n {C('bold', f'Pattern #{i}:')} {C(dir_color, pat['name'])} {tier_badge} {C(tier_color, tier_label)}") lines.append(f" TF: {C(tf_color, tf_label)} | Category: {pat['category']} | Direction: {C(dir_color, direction)}") atr_display_tf = pat.get('atr_tf', tf_label) atr_label = f"ATR({cfg['atr_period']},{atr_display_tf})" if atr_display_tf != tf_label else f"ATR({cfg['atr_period']})" lines.append(f" Session: {C('cyan', pat['session'])} | Trend: {pat['trend']} | {atr_label}: {pat['atr']:.5f}") vol_val = pat.get('Volume_Confirmed', 'N/A') vol_color = 'green' if vol_val is True else ('red' if vol_val is False else 'dim') lines.append(f" Volume Confirmed: {C(vol_color, str(vol_val))}") d1_val = pat.get('D1_Trend', 'N/A') d1_color = 'green' if d1_val == 'uptrend' else ('red' if d1_val == 'downtrend' else 'yellow') lines.append(f" D1 Trend: {C(d1_color, str(d1_val))}") # ── QUALITY SUMMARY LINE (tier + session + cross) ── pat_stats = stats.get('patterns', {}).get(pat['name'], {}) sess_stats = stats.get('sessions', {}).get(pat['session'], {}) cross_key = f"{pat['name']}|{pat['session']}" cross_stats = stats.get('cross', {}).get(cross_key, {}) pat_wr = pat_stats.get('win_rate', 0) pat_n = pat_stats.get('total', 0) pat_amr = pat_stats.get('avg_max_r', 0) quality_parts = [] quality_parts.append(f"Tier {tier_letter}:{C(tier_color, tier_label)}") if pat_n >= min_sig: wr_color = 'green' if pat_wr >= min_wr else ('yellow' if pat_wr >= 45 else 'red') quality_parts.append(f"WR {C(wr_color, f'{pat_wr:.1f}%')} ({pat_n})") quality_parts.append(f"Sess:{C(sess_q_color, f'{sess_quality}')}") if sess_n >= min_sig: quality_parts.append(f"SessWR {C(sess_q_color, f'{sess_wr:.1f}%')}") if cross_wr is not None: quality_parts.append(f"CrossWR {C(cross_qc, f'{cross_wr:.1f}%')} ({cross_n})") quality_parts.append(f"AvgR {pat_amr:.2f}R") lines.append(f" {C('bold', 'QUALITY:')} {' | '.join(quality_parts)}") lines.append(f" ENTRY: {C('bold', pat['entry_type'])} | Price: {C('bold', str(pat['entry_price']))} | Aggressive: {pat['aggressive_entry']:.5f}") lines.append(f" Reason: {pat['entry_reason']}") # ── Gather historical probability data ── best_tp_pct = None best_wr = None best_src = '' if cross_stats and cross_stats.get('signals', 0) >= min_sig: best_tp_pct = cross_stats.get('tp_hit_pct') best_wr = cross_stats.get('win_rate') best_src = 'cross' if best_tp_pct is None and pat_stats and pat_stats.get('total', 0) >= min_sig: best_tp_pct = pat_stats.get('tp_hit_pct') best_wr = pat_stats.get('win_rate') best_src = 'pattern' if best_tp_pct is None: overall = stats.get('overall', {}) if overall.get('total_signals', 0) >= min_sig: best_tp_pct = overall.get('tp_hit_pct') best_wr = overall.get('win_rate') best_src = 'overall' # ── BUY / SELL / BREAKOUT with probability ── if direction == 'Bullish': sl_str = C('red', f"SL: {pat['sl']:.5f}") tp_str = C('green', f"TP: {pat['tp']:.5f}") buy_line = f" >>> {C('green', C('bold', 'BUY'))} | Entry: {pat['entry_price']:.5f} {sl_str} {tp_str}" if best_tp_pct is not None: prob_color = 'green' if best_tp_pct >= 40 else ('yellow' if best_tp_pct >= 30 else 'red') buy_line += f" {C(prob_color, C('bold', f'Prob(TP): {best_tp_pct:.1f}%'))}" lines.append(buy_line) if pat['sl_dist_pips'] is not None: lines.append(f" >>> SL: {pat['sl_dist_pips']:.1f} pips | TP: {pat['tp_dist_pips']:.1f} pips | R:R 1:{pat['rr_ratio']:.2f}") elif direction == 'Bearish': sl_str = C('red', f"SL: {pat['sl']:.5f}") tp_str = C('green', f"TP: {pat['tp']:.5f}") sell_line = f" >>> {C('red', C('bold', 'SELL'))} | Entry: {pat['entry_price']:.5f} {sl_str} {tp_str}" if best_tp_pct is not None: prob_color = 'green' if best_tp_pct >= 40 else ('yellow' if best_tp_pct >= 30 else 'red') sell_line += f" {C(prob_color, C('bold', f'Prob(TP): {best_tp_pct:.1f}%'))}" lines.append(sell_line) if pat['sl_dist_pips'] is not None: lines.append(f" >>> SL: {pat['sl_dist_pips']:.1f} pips | TP: {pat['tp_dist_pips']:.1f} pips | R:R 1:{pat['rr_ratio']:.2f}") else: lines.append(f" >>> {C('yellow', 'BREAKOUT')} | Buy: {pat['body_top']:.5f} | Sell: {pat['body_bottom']:.5f}") # ── Historical edge ── has_edge = False if pat_stats and pat_stats.get('total', 0) >= min_sig: has_edge = True lines.append(f" {C('bold', 'HISTORICAL EDGE:')}") wr = pat_stats.get('win_rate', 0) n = pat_stats.get('total', 0) amr = pat_stats.get('avg_max_r', 0) sl_pct = pat_stats.get('sl_hit_pct', 0) tp_pct = pat_stats.get('tp_hit_pct', 0) wr_tag = "HIGH" if wr >= min_wr else "LOW" wr_tag_color = 'green' if wr >= min_wr else 'red' lines.append(f" {pat['name']}: {C(wr_tag_color, f'WR {wr:.1f}% [{wr_tag}]')} ({n} signals) | Avg Max R: {amr:.2f}R | {C('red', f'SL: {sl_pct:.1f}%')} {C('green', f'TP: {tp_pct:.1f}%')}") if sess_stats and sess_stats.get('signals', 0) >= min_sig: sess_wr_val = sess_stats.get('win_rate', 0) sess_n_val = sess_stats.get('signals', 0) lines.append(f" Session {pat['session']}: {C(sess_q_color, f'{sess_wr_val:.1f}% WR [{sess_quality}]')} ({sess_n_val} signals)") if cross_stats and cross_stats.get('signals', 0) >= min_sig: cross_wr_val = cross_stats.get('win_rate', 0) cross_n_val = cross_stats.get('signals', 0) cross_amr_val = cross_stats.get('avg_max_r', 0) lines.append(f" {pat['name']} in {pat['session']}: {C(cross_qc, f'{cross_wr_val:.1f}% WR [{cross_ql}]')} ({cross_n_val} signals) | Avg Max R: {cross_amr_val:.2f}R") # ── Signal quality score ── score = pat.get('signal_score') if score is None: score = compute_signal_score(pat['name'], pat['session'], pat['direction'], stats, cfg, tf_label=tf_label) if score is not None: if score >= 65: score_label = "STRONG"; score_color = 'green' elif score >= 52: score_label = "MODERATE"; score_color = 'yellow' else: score_label = "WEAK"; score_color = 'red' lines.append(f" Signal Score: {C(score_color, C('bold', f'{score:.1f}/100 [{score_label}]'))}") elif not has_edge: lines.append(C('dim', f" HISTORICAL EDGE: Insufficient data (<{min_sig} signals)")) # Position sizing (standard account — standard lots only) risk_pct = cfg.get('risk_percent', 1.0) balance = cfg.get('account_balance', 100000) if pat.get('sl_dist_pips') and pat['sl_dist_pips'] > 0: risk_amount = balance * risk_pct / 100.0 pip_value = get_pip_value(cfg.get('symbol', 'EURUSD'), cfg) lots = round(risk_amount / (pat['sl_dist_pips'] * pip_value), 2) lines.append(f" Position Size ({risk_pct:.1f}% of ${balance:,.0f}): {C('cyan', f'{lots:.2f} lots')} (pip val: {pip_value})") lines.append(f" {'─' * 40}") lines.append(C(tf_color, "=" * 80)) return "\n".join(lines) # ============================================================ # MT5 CONNECTION HELPERS # ============================================================ def connect_mt5(cfg=None): """Initialize and log in to MT5 using credentials from CFG (loaded from .env).""" if cfg is None: cfg = CFG if not _ENV_LOADED: log_message(C('yellow', "WARNING: .env file not found — using fallback credentials"), cfg) log_message("Initializing MT5 connection...", cfg) if not mt5.initialize(path=cfg['mt5_path']): log_message(f"MT5 initialization failed: {mt5.last_error()}", cfg) return False log_message(f"MT5 initialized. Version: {mt5.version()}", cfg) if not mt5.login(login=cfg['account'], password=cfg['password'], server=cfg['server']): log_message(f"MT5 login failed: {mt5.last_error()}", cfg) mt5.shutdown() return False log_message(f"Connected to {cfg['server']} account {cfg['account']}", cfg) return True def mt5_reconnect(cfg=None): """Attempt MT5 reconnection with exponential backoff.""" if cfg is None: cfg = CFG max_attempts = cfg.get('max_reconnect_attempts', 5) base_backoff = cfg.get('reconnect_backoff_base', 10) for attempt in range(1, max_attempts + 1): log_message(f"Reconnection attempt {attempt}/{max_attempts}...", cfg) try: mt5.shutdown() except Exception: pass time.sleep(base_backoff * (2 ** (attempt - 1))) if connect_mt5(cfg): log_message(f"Reconnection successful on attempt {attempt}.", cfg) return True log_message(f"Reconnection attempt {attempt} failed.", cfg) log_message(f"All {max_attempts} reconnection attempts failed.", cfg) return False def fetch_rates(symbol, tf_label, num_bars, cfg=None): """Fetch the most recent `num_bars` bars for the given symbol and TF label.""" if cfg is None: cfg = CFG tf_info = TIMEFRAME_MAP.get(tf_label) if tf_info is None: log_message(f"Unknown timeframe: {tf_label}", cfg) return None rates = mt5.copy_rates_from_pos(symbol, tf_info['mt5_tf'], 0, num_bars) if rates is None: log_message(f"Failed to fetch {tf_label} rates: {mt5.last_error()}", cfg) return rates def fetch_rates_range(symbol, tf_label, date_from, date_to, cfg=None): """Fetch bars in a date range for full backtest.""" if cfg is None: cfg = CFG tf_info = TIMEFRAME_MAP.get(tf_label) if tf_info is None: return None warmup_bars = cfg.get('warmup_bars', 30) warmup_start = date_from - timedelta(minutes=warmup_bars * tf_info['minutes'] + 24 * 60) rates = mt5.copy_rates_range(symbol, tf_info['mt5_tf'], warmup_start, date_to) if rates is None or len(rates) == 0: print(f"[MT5] No {tf_label} data for {symbol} from {warmup_start} to {date_to}") return None df = pd.DataFrame(rates) df['DATETIME'] = pd.to_datetime(df['time'], unit='s') df.sort_values('DATETIME', inplace=True) df.reset_index(drop=True, inplace=True) df.rename(columns={'open': 'OPEN', 'high': 'HIGH', 'low': 'LOW', 'close': 'CLOSE', 'tick_volume': 'TICKVOL', 'real_volume': 'VOL', 'spread': 'SPREAD'}, inplace=True) df['DATE'] = df['DATETIME'].dt.strftime('%Y.%m.%d') df['TIME'] = df['DATETIME'].dt.strftime('%H:%M:%S') df['IN_RANGE'] = (df['DATETIME'] >= date_from) & (df['DATETIME'] <= date_to) df['BODY'] = abs(df['CLOSE'] - df['OPEN']) df['BODY_SIGN'] = np.where(df['CLOSE'] >= df['OPEN'], 1, -1) df['RANGE'] = df['HIGH'] - df['LOW'] df['UPPER_WICK'] = df['HIGH'] - df[['OPEN', 'CLOSE']].max(axis=1) df['LOWER_WICK'] = df[['OPEN', 'CLOSE']].min(axis=1) - df['LOW'] df['BODY_RATIO'] = np.where(df['RANGE'] > 0, df['BODY'] / df['RANGE'], 0) wc = (~df['IN_RANGE']).sum(); ic = df['IN_RANGE'].sum() print(f" [{tf_label}] Fetched {len(df)} bars ({wc} warmup + {ic} in range)") return df # ============================================================ # BACKTEST — DataFrame-based pattern detectors # ============================================================ def fb_compute_atr(df, period): """Compute ATR using Wilder's exponential smoothing (standard ATR method). Returns a pd.Series aligned with df, using alpha = 1/period for EMA smoothing. This matches MT5's built-in ATR indicator and the industry standard. """ tr = pd.DataFrame({ 'hl': df['HIGH'] - df['LOW'], 'hc': abs(df['HIGH'] - df['CLOSE'].shift(1)), 'lc': abs(df['LOW'] - df['CLOSE'].shift(1)), }).max(axis=1) # Wilder's smoothing: EMA with alpha = 1/period alpha = 1.0 / period return tr.ewm(alpha=alpha, adjust=False).mean() def fb_compute_htf_atr(df, htf_df, atr_period): """Compute ATR on a higher-timeframe DataFrame and map it to the lower-TF df. For each bar in `df`, finds the most recent HTF bar whose DATETIME <= df bar's DATETIME and uses that HTF bar's ATR value. This allows M5/M15 bars to use H1 ATR for SL/TP sizing, giving much more realistic stop distances. Args: df: Lower-timeframe DataFrame (the one being scanned for patterns). htf_df: Higher-timeframe DataFrame with at least HIGH, LOW, CLOSE, DATETIME columns. atr_period: ATR period for the rolling mean. Returns: pd.Series aligned with df's index, containing the HTF ATR values. """ if htf_df is None or len(htf_df) == 0: # Fallback: compute native ATR return fb_compute_atr(df, atr_period) # Compute ATR on the higher-timeframe htf_atr = fb_compute_atr(htf_df, atr_period) htf_with_atr = htf_df[['DATETIME']].copy() htf_with_atr['ATR'] = htf_atr.values # Build an ATR lookup: for each lower-TF bar, find the most recent HTF ATR # Use merge_asof for efficient time-based alignment result = pd.merge_asof( df[['DATETIME']].copy().sort_values('DATETIME'), htf_with_atr.sort_values('DATETIME'), on='DATETIME', direction='backward' # use the HTF bar at or before the current bar ) # Re-align with original df index (merge_asof sorts by DATETIME) result.index = df.index return result['ATR'] def fb_detect_trend(df, idx, cfg=None): if cfg is None: cfg = CFG lookback = cfg.get('trend_lookback', 20) if idx < lookback: return 'ranging' subset = df.iloc[max(0, idx - lookback):idx + 1] return detect_trend(subset, cfg) def fb_detect_doji(df, idx, cfg=None): if cfg is None: cfg = CFG r = df.iloc[idx] return r['RANGE'] > 0 and r['BODY_RATIO'] <= cfg['doji_body_ratio'] def fb_detect_spinning_top(df, idx, cfg=None): if cfg is None: cfg = CFG r = df.iloc[idx] if r['RANGE'] == 0 or r['BODY'] == 0: return False if r['BODY_RATIO'] > cfg['spinning_top_body_ratio']: return False return r['UPPER_WICK'] >= r['BODY'] and r['LOWER_WICK'] >= r['BODY'] def fb_detect_marubozu(df, idx, cfg=None): if cfg is None: cfg = CFG r = df.iloc[idx] if r['BODY'] == 0: return False if r['BODY_RATIO'] < cfg['long_candle_ratio']: return False return (r['UPPER_WICK'] <= r['BODY'] * cfg['marubozu_wick_ratio'] and r['LOWER_WICK'] <= r['BODY'] * cfg['marubozu_wick_ratio']) def fb_detect_hammer(df, idx, cfg=None): if cfg is None: cfg = CFG r = df.iloc[idx] if idx < 3: return False trend = fb_detect_trend(df, idx, cfg) if trend not in ('downtrend', 'ranging'): return False if r['BODY'] == 0: return False return r['LOWER_WICK'] >= r['BODY'] * cfg['hammer_lower_wick_ratio'] and r['UPPER_WICK'] <= r['BODY'] * cfg['hammer_upper_wick_ratio'] def fb_detect_inverted_hammer(df, idx, cfg=None): if cfg is None: cfg = CFG r = df.iloc[idx] if idx < 3: return False trend = fb_detect_trend(df, idx, cfg) if trend not in ('downtrend', 'ranging'): return False if r['BODY'] == 0: return False return r['UPPER_WICK'] >= r['BODY'] * cfg['hammer_lower_wick_ratio'] and r['LOWER_WICK'] <= r['BODY'] * cfg['hammer_upper_wick_ratio'] def fb_detect_shooting_star(df, idx, cfg=None): if cfg is None: cfg = CFG r = df.iloc[idx] if idx < 3: return False trend = fb_detect_trend(df, idx, cfg) if trend not in ('uptrend', 'ranging'): return False if r['BODY'] == 0: return False return r['UPPER_WICK'] >= r['BODY'] * cfg['hammer_lower_wick_ratio'] and r['LOWER_WICK'] <= r['BODY'] * cfg['hammer_upper_wick_ratio'] def fb_detect_hanging_man(df, idx, cfg=None): if cfg is None: cfg = CFG r = df.iloc[idx] if idx < 3: return False trend = fb_detect_trend(df, idx, cfg) if trend not in ('uptrend', 'ranging'): return False if r['BODY'] == 0: return False return r['LOWER_WICK'] >= r['BODY'] * cfg['hammer_lower_wick_ratio'] and r['UPPER_WICK'] <= r['BODY'] * cfg['hammer_upper_wick_ratio'] def fb_detect_near_engulfing(df, idx, cfg=None): if cfg is None: cfg = CFG if idx < 1: return None c = df.iloc[idx]; p = df.iloc[idx-1] if c['BODY'] == 0 or p['BODY'] == 0: return None tol = cfg.get('engulf_tolerance_pips', 2.0) * 0.0001 if c['BODY_SIGN'] == 1 and p['BODY_SIGN'] == -1: if not (c['OPEN'] <= p['CLOSE'] and c['CLOSE'] >= p['OPEN']): if c['OPEN'] <= p['CLOSE'] + tol and c['CLOSE'] >= p['OPEN'] - tol: return 'Near Bullish Engulfing' if c['BODY_SIGN'] == -1 and p['BODY_SIGN'] == 1: if not (c['OPEN'] >= p['CLOSE'] and c['CLOSE'] <= p['OPEN']): if c['OPEN'] >= p['CLOSE'] - tol and c['CLOSE'] <= p['OPEN'] + tol: return 'Near Bearish Engulfing' return None def fb_detect_engulfing(df, idx, cfg=None): if idx < 1: return None c = df.iloc[idx]; p = df.iloc[idx-1] if c['BODY'] == 0 or p['BODY'] == 0: return None if c['BODY_SIGN'] == 1 and p['BODY_SIGN'] == -1 and c['OPEN'] <= p['CLOSE'] and c['CLOSE'] >= p['OPEN']: return 'Bullish Engulfing' if c['BODY_SIGN'] == -1 and p['BODY_SIGN'] == 1 and c['OPEN'] >= p['CLOSE'] and c['CLOSE'] <= p['OPEN']: return 'Bearish Engulfing' return None def fb_detect_harami(df, idx, cfg=None): if cfg is None: cfg = CFG if idx < 1: return None c = df.iloc[idx]; p = df.iloc[idx-1] if c['BODY'] == 0 or p['BODY'] == 0: return None if p['BODY_RATIO'] < cfg['long_candle_ratio'] * 0.8: return None ch = max(c['OPEN'], c['CLOSE']); cl = min(c['OPEN'], c['CLOSE']) ph = max(p['OPEN'], p['CLOSE']); pl = min(p['OPEN'], p['CLOSE']) if ch <= ph and cl >= pl: if p['BODY_SIGN'] == -1 and c['BODY_SIGN'] == 1: return 'Bullish Harami' if p['BODY_SIGN'] == 1 and c['BODY_SIGN'] == -1: return 'Bearish Harami' return None def fb_detect_morning_star(df, idx, cfg=None): if cfg is None: cfg = CFG if idx < 2: return False f, s, t = df.iloc[idx-2], df.iloc[idx-1], df.iloc[idx] if f['BODY_SIGN'] != -1 or f['BODY_RATIO'] < cfg['long_candle_ratio']: return False if s['BODY_RATIO'] > cfg['small_candle_ratio'] + 0.1: return False if t['BODY_SIGN'] != 1 or t['BODY_RATIO'] < cfg['long_candle_ratio'] * 0.7: return False return t['CLOSE'] > (f['OPEN'] + f['CLOSE']) / 2 def fb_detect_evening_star(df, idx, cfg=None): if cfg is None: cfg = CFG if idx < 2: return False f, s, t = df.iloc[idx-2], df.iloc[idx-1], df.iloc[idx] if f['BODY_SIGN'] != 1 or f['BODY_RATIO'] < cfg['long_candle_ratio']: return False if s['BODY_RATIO'] > cfg['small_candle_ratio'] + 0.1: return False if t['BODY_SIGN'] != -1 or t['BODY_RATIO'] < cfg['long_candle_ratio'] * 0.7: return False return t['CLOSE'] < (f['OPEN'] + f['CLOSE']) / 2 def fb_detect_three_white_soldiers(df, idx, cfg=None): if idx < 2: return False c1, c2, c3 = df.iloc[idx-2], df.iloc[idx-1], df.iloc[idx] if c1['BODY_SIGN'] != 1 or c2['BODY_SIGN'] != 1 or c3['BODY_SIGN'] != 1: return False if c1['BODY_RATIO'] < 0.5 or c2['BODY_RATIO'] < 0.5 or c3['BODY_RATIO'] < 0.5: return False return c3['CLOSE'] > c2['CLOSE'] > c1['CLOSE'] def fb_detect_three_black_crows(df, idx, cfg=None): if idx < 2: return False c1, c2, c3 = df.iloc[idx-2], df.iloc[idx-1], df.iloc[idx] if c1['BODY_SIGN'] != -1 or c2['BODY_SIGN'] != -1 or c3['BODY_SIGN'] != -1: return False if c1['BODY_RATIO'] < 0.5 or c2['BODY_RATIO'] < 0.5 or c3['BODY_RATIO'] < 0.5: return False return c3['CLOSE'] < c2['CLOSE'] < c1['CLOSE'] def fb_detect_tweezer(df, idx, cfg=None): if cfg is None: cfg = CFG if idx < 1: return None p = df.iloc[idx-1]; c = df.iloc[idx] tol = cfg['tweezer_tolerance_pips'] * 0.0001 trend = fb_detect_trend(df, idx, cfg) if abs(p['HIGH'] - c['HIGH']) <= tol and trend in ('uptrend', 'ranging'): return 'Tweezer Tops' if abs(p['LOW'] - c['LOW']) <= tol and trend in ('downtrend', 'ranging'): return 'Tweezer Bottoms' return None def fb_detect_rising_three_methods(df, idx, cfg=None): if cfg is None: cfg = CFG if idx < 4: return False first = df.iloc[idx-4]; fifth = df.iloc[idx] if first['BODY_SIGN'] != 1 or first['BODY_RATIO'] < cfg['long_candle_ratio']: return False for i in range(1, 4): c = df.iloc[idx-4+i] if c['BODY_RATIO'] > cfg['small_candle_ratio'] + 0.15: return False if c['HIGH'] > first['HIGH'] or c['LOW'] < first['LOW']: return False if fifth['BODY_SIGN'] != 1 or fifth['BODY_RATIO'] < cfg['long_candle_ratio'] * 0.7: return False return fifth['CLOSE'] > first['CLOSE'] def fb_detect_falling_three_methods(df, idx, cfg=None): if cfg is None: cfg = CFG if idx < 4: return False first = df.iloc[idx-4]; fifth = df.iloc[idx] if first['BODY_SIGN'] != -1 or first['BODY_RATIO'] < cfg['long_candle_ratio']: return False for i in range(1, 4): c = df.iloc[idx-4+i] if c['BODY_RATIO'] > cfg['small_candle_ratio'] + 0.15: return False if c['HIGH'] > first['HIGH'] or c['LOW'] < first['LOW']: return False if fifth['BODY_SIGN'] != -1 or fifth['BODY_RATIO'] < cfg['long_candle_ratio'] * 0.7: return False return fifth['CLOSE'] < first['CLOSE'] # ============================================================ # FORWARD EVALUATION (intra-candle path simulation) # ============================================================ def simulate_forward_evaluation(df, idx, direction, sl_price, tp_price, r_levels, forward_candles, cfg=None, fill_price=None): """Forward evaluation with trade management and intra-candle path simulation. Supports four trade management modes via cfg['trade_management_mode']: 'fixed' — Static SL/TP (original behavior, default) 'breakeven' — Move SL to entry (breakeven) when price hits breakeven_at_r R 'trail' — After trail_at_r R hit, trail SL by trail_atr_mult × ATR behind price 'partial' — Close partial_close_pct at partial_close_r R, trail the rest Also supports time-based stop tightening: if time_stop_pct fraction of forward_candles elapsed without TP, SL is tightened to breakeven. Returns dict with: sl_hit, tp_hit, outcome, max_r, r_hits, fill_price, entry_filled, bars_to_sl, bars_to_tp, mae_r, mfe_r, exit_r (R-multiple at actual exit), sl_moved_to_be, partial_closed, remaining_pct """ if cfg is None: cfg = CFG max_r_levels = cfg.get('max_r_levels', 5) pip_divisor = cfg.get('pip_divisor', 0.0001) r_hits = {f'R{r}_Hit': None for r in range(1, max_r_levels+1)} sl_hit = tp_hit = False highest_r = 0 outcome = 'Timeout' bars_to_sl = None bars_to_tp = None mae_r = 0.0 mfe_r = 0.0 exit_r = 0.0 # R-multiple at actual exit sl_moved_to_be = False partial_closed = False remaining_pct = 1.0 # Fraction of position still open # Trade management config tm_mode = cfg.get('trade_management_mode', 'fixed') be_at_r = cfg.get('breakeven_at_r', 1.0) trail_at_r = cfg.get('trail_at_r', 1.5) trail_atr_mult = cfg.get('trail_atr_mult', 1.0) partial_r = cfg.get('partial_close_r', 1.0) partial_pct = cfg.get('partial_close_pct', 0.5) time_stop_pct = cfg.get('time_stop_pct', 0.7) time_stop_bar = int(forward_candles * time_stop_pct) if time_stop_pct > 0 else 0 if direction not in ('Bullish', 'Bearish'): return {'sl_hit': None, 'tp_hit': None, 'outcome': 'N/A', 'max_r': None, 'r_hits': r_hits, 'fill_price': None, 'entry_filled': True, 'bars_to_sl': None, 'bars_to_tp': None, 'mae_r': None, 'mfe_r': None, 'exit_r': None, 'sl_moved_to_be': False, 'partial_closed': False, 'remaining_pct': 1.0} if idx + 1 >= len(df): return {'sl_hit': None, 'tp_hit': None, 'outcome': 'Timeout', 'max_r': 0, 'r_hits': r_hits, 'fill_price': None, 'entry_filled': False, 'bars_to_sl': None, 'bars_to_tp': None, 'mae_r': 0.0, 'mfe_r': 0.0, 'exit_r': 0.0, 'sl_moved_to_be': False, 'partial_closed': False, 'remaining_pct': 1.0} entry = fill_price if fill_price is not None else df.iloc[idx]['CLOSE'] risk = abs(entry - sl_price) if sl_price is not None else 0.001 if risk == 0: risk = 0.001 end_idx = min(idx + 1 + forward_candles, len(df)) future = df.iloc[idx+1:end_idx] if len(future) == 0: return {'sl_hit': None, 'tp_hit': None, 'outcome': 'Timeout', 'max_r': 0, 'r_hits': r_hits, 'fill_price': None, 'entry_filled': False, 'bars_to_sl': None, 'bars_to_tp': None, 'mae_r': 0.0, 'mfe_r': 0.0, 'exit_r': 0.0, 'sl_moved_to_be': False, 'partial_closed': False, 'remaining_pct': 1.0} # Active SL (may move during trade) active_sl = sl_price # Breakeven price (entry price, used when SL moves to BE) be_price = entry # Track whether trailing has started trailing_active = False # Track whether breakeven has been triggered (for partial mode) be_triggered = False bar_count = 0 stopped = False for _, fc in future.iterrows(): if stopped: break bar_count += 1 fc_high = fc['HIGH']; fc_low = fc['LOW'] fc_open = fc['OPEN']; fc_close = fc['CLOSE'] # Current favorable R (for trade management decisions) if direction == 'Bullish': current_favorable_r = (fc_high - entry) / risk else: current_favorable_r = (entry - fc_low) / risk # ── Trade management: adjust SL before checking hits ────────── if tm_mode == 'breakeven' and not sl_moved_to_be: if current_favorable_r >= be_at_r: active_sl = be_price sl_moved_to_be = True elif tm_mode == 'trail': # First move to breakeven at trail_at_r if not sl_moved_to_be and current_favorable_r >= trail_at_r: active_sl = be_price sl_moved_to_be = True trailing_active = True # Then trail by ATR if trailing_active and 'ATR' in fc.index and not pd.isna(fc.get('ATR', None)): trail_dist = trail_atr_mult * fc['ATR'] if direction == 'Bullish': new_sl = fc_high - trail_dist if new_sl > active_sl: active_sl = new_sl else: new_sl = fc_low + trail_dist if new_sl < active_sl: active_sl = new_sl elif tm_mode == 'partial': # Close partial position at partial_r if not partial_closed and current_favorable_r >= partial_r: partial_closed = True remaining_pct = 1.0 - partial_pct # Move SL to breakeven for the remainder if not sl_moved_to_be: active_sl = be_price sl_moved_to_be = True # After partial close, start trailing if partial_closed and 'ATR' in fc.index and not pd.isna(fc.get('ATR', None)): trail_dist = trail_atr_mult * fc['ATR'] if direction == 'Bullish': new_sl = fc_high - trail_dist if new_sl > active_sl: active_sl = new_sl else: new_sl = fc_low + trail_dist if new_sl < active_sl: active_sl = new_sl # Time-based stop tightening: if X% of forward window elapsed, tighten SL # Only applies when trade management mode is not 'fixed' if tm_mode != 'fixed' and time_stop_pct > 0 and bar_count >= time_stop_bar and not sl_moved_to_be: active_sl = be_price sl_moved_to_be = True # ── Track MAE/MFE before checking stops ────────────────────── if direction == 'Bullish': adverse = entry - fc_low favorable = fc_high - entry else: adverse = fc_high - entry favorable = entry - fc_low mae_r = max(mae_r, adverse / risk) mfe_r = max(mfe_r, favorable / risk) # ── Check SL/TP using the (possibly adjusted) active_sl ────── sl_in_range = (fc_low <= active_sl if direction == 'Bullish' else fc_high >= active_sl) tp_in_range = (fc_high >= tp_price if direction == 'Bullish' else fc_low <= tp_price) if sl_in_range and tp_in_range: sl_dist = abs(fc_open - active_sl) tp_dist = abs(fc_open - tp_price) if tp_dist <= sl_dist: tp_hit = True; outcome = 'TP_Hit' bars_to_tp = bar_count for r in range(1, max_r_levels+1): rv = r_levels.get(f'R{r}') if rv is not None: if (direction == 'Bullish' and fc_high >= rv) or (direction == 'Bearish' and fc_low <= rv): r_hits[f'R{r}_Hit'] = True; highest_r = max(highest_r, r) sl_hit = True bars_to_sl = bar_count # Exit R for TP if direction == 'Bullish': exit_r = (tp_price - entry) / risk else: exit_r = (entry - tp_price) / risk exit_r *= remaining_pct # Scale by remaining position else: sl_hit = True; outcome = 'SL_Hit' bars_to_sl = bar_count tp_hit = True bars_to_tp = bar_count # Exit R for SL (with adjusted SL) if direction == 'Bullish': exit_r = (active_sl - entry) / risk else: exit_r = (entry - active_sl) / risk exit_r *= remaining_pct stopped = True elif sl_in_range: sl_hit = True; outcome = 'SL_Hit'; stopped = True bars_to_sl = bar_count # Calculate exit R with adjusted SL if direction == 'Bullish': exit_r = (active_sl - entry) / risk else: exit_r = (entry - active_sl) / risk exit_r *= remaining_pct elif tp_in_range: tp_hit = True; outcome = 'TP_Hit' bars_to_tp = bar_count for r in range(1, max_r_levels+1): rv = r_levels.get(f'R{r}') if rv is not None: if (direction == 'Bullish' and fc_high >= rv) or (direction == 'Bearish' and fc_low <= rv): r_hits[f'R{r}_Hit'] = True; highest_r = max(highest_r, r) stopped = True if direction == 'Bullish': exit_r = (tp_price - entry) / risk else: exit_r = (entry - tp_price) / risk exit_r *= remaining_pct else: for r in range(1, max_r_levels+1): rv = r_levels.get(f'R{r}') if rv is not None: if (direction == 'Bullish' and fc_high >= rv) or (direction == 'Bearish' and fc_low <= rv): r_hits[f'R{r}_Hit'] = True; highest_r = max(highest_r, r) for r in range(1, max_r_levels+1): if r_hits[f'R{r}_Hit'] is None: r_hits[f'R{r}_Hit'] = False if not stopped and len(future) > 0: if cfg.get('timeout_mode', 'marginal') == 'expired': outcome = 'Expired' else: final_close = future.iloc[-1]['CLOSE'] benchmark = fill_price if fill_price is not None else df.iloc[idx]['CLOSE'] if direction == 'Bullish': outcome = 'Marginal_Win' if final_close > benchmark else 'Marginal_Loss' elif direction == 'Bearish': outcome = 'Marginal_Win' if final_close < benchmark else 'Marginal_Loss' # Calculate exit R for timeout if len(future) > 0: final_close = future.iloc[-1]['CLOSE'] if direction == 'Bullish': exit_r = (final_close - entry) / risk else: exit_r = (entry - final_close) / risk exit_r *= remaining_pct return {'sl_hit': sl_hit, 'tp_hit': tp_hit, 'outcome': outcome, 'max_r': highest_r, 'r_hits': r_hits, 'fill_price': None, 'entry_filled': True, 'bars_to_sl': bars_to_sl, 'bars_to_tp': bars_to_tp, 'mae_r': round(mae_r, 3), 'mfe_r': round(mfe_r, 3), 'exit_r': round(exit_r, 3), 'sl_moved_to_be': sl_moved_to_be, 'partial_closed': partial_closed, 'remaining_pct': remaining_pct} # ============================================================ # BACKTEST: detect all patterns on a DataFrame (one timeframe) # ============================================================ def fb_detect_all_patterns(df, cfg=None, d1_df=None, tf_label='H4', htf_atr_df=None): """Run all pattern detectors on in-range candles. Returns list of detection dicts. Args: htf_atr_df: Optional higher-timeframe DataFrame for ATR calculation. If provided and the atr_tf_by_tf mapping indicates a different ATR source TF, ATR is computed from this DF instead of the native TF. """ if cfg is None: cfg = CFG atr_period = cfg.get('atr_period', 14) sl_mult = cfg.get('sl_multiplier', 1.5) tp_mult = cfg.get('tp_multiplier', 1.5) forward_candles = get_forward_candles(tf_label, cfg) # Determine ATR source: native or higher timeframe atr_tf = get_atr_tf(tf_label, cfg) if htf_atr_df is not None and atr_tf != tf_label: atr = fb_compute_htf_atr(df, htf_atr_df, atr_period) print(f" [{tf_label}] Using {atr_tf} ATR for SL/TP (native {tf_label} ATR too small)") else: atr = fb_compute_atr(df, atr_period) df['ATR'] = atr vol_ma_period = cfg.get('volume_ma_period', 20) df['VOL_MA'] = df['TICKVOL'].rolling(window=vol_ma_period, min_periods=1).mean() detections = [] in_range = df.index[df['IN_RANGE']].tolist() total = len(in_range) for count, idx in enumerate(in_range, 1): if count % 200 == 0 or count == total: print(f" [{tf_label}] Scanning candle {count}/{total} ...", end='\r') row = df.iloc[idx] found = [] if fb_detect_doji(df, idx, cfg): found.append({'Pattern': 'Doji', 'Category': 'Neutral', 'Direction': 'Neutral', 'Candles': 1}) if fb_detect_spinning_top(df, idx, cfg): found.append({'Pattern': 'Spinning Top', 'Category': 'Neutral', 'Direction': 'Neutral', 'Candles': 1}) if fb_detect_marubozu(df, idx, cfg): d = 'Bullish' if row['BODY_SIGN'] == 1 else 'Bearish' found.append({'Pattern': f'Marubozu ({d})', 'Category': f'{d} Continuation', 'Direction': d, 'Candles': 1}) if fb_detect_hammer(df, idx, cfg): found.append({'Pattern': 'Hammer', 'Category': 'Bullish Reversal', 'Direction': 'Bullish', 'Candles': 1}) if fb_detect_inverted_hammer(df, idx, cfg): found.append({'Pattern': 'Inverted Hammer', 'Category': 'Bullish Reversal', 'Direction': 'Bullish', 'Candles': 1}) if fb_detect_shooting_star(df, idx, cfg): found.append({'Pattern': 'Shooting Star', 'Category': 'Bearish Reversal', 'Direction': 'Bearish', 'Candles': 1}) if fb_detect_hanging_man(df, idx, cfg): found.append({'Pattern': 'Hanging Man', 'Category': 'Bearish Reversal', 'Direction': 'Bearish', 'Candles': 1}) eng = fb_detect_engulfing(df, idx, cfg) if eng: d = 'Bullish' if 'Bullish' in eng else 'Bearish' found.append({'Pattern': eng, 'Category': f'{d} Reversal', 'Direction': d, 'Candles': 2}) ne = fb_detect_near_engulfing(df, idx, cfg) if ne: d = 'Bullish' if 'Bullish' in ne else 'Bearish' found.append({'Pattern': ne, 'Category': f'{d} Reversal', 'Direction': d, 'Candles': 2}) har = fb_detect_harami(df, idx, cfg) if har: d = 'Bullish' if 'Bullish' in har else 'Bearish' found.append({'Pattern': har, 'Category': f'{d} Reversal', 'Direction': d, 'Candles': 2}) tw = fb_detect_tweezer(df, idx, cfg) if tw: d = 'Bearish' if 'Tops' in tw else 'Bullish' found.append({'Pattern': tw, 'Category': f'{d} Reversal', 'Direction': d, 'Candles': 2}) if fb_detect_morning_star(df, idx, cfg): found.append({'Pattern': 'Morning Star', 'Category': 'Bullish Reversal', 'Direction': 'Bullish', 'Candles': 3}) if fb_detect_evening_star(df, idx, cfg): found.append({'Pattern': 'Evening Star', 'Category': 'Bearish Reversal', 'Direction': 'Bearish', 'Candles': 3}) if fb_detect_three_white_soldiers(df, idx, cfg): found.append({'Pattern': 'Three White Soldiers', 'Category': 'Bullish Reversal', 'Direction': 'Bullish', 'Candles': 3}) if fb_detect_three_black_crows(df, idx, cfg): found.append({'Pattern': 'Three Black Crows', 'Category': 'Bearish Reversal', 'Direction': 'Bearish', 'Candles': 3}) if fb_detect_rising_three_methods(df, idx, cfg): found.append({'Pattern': 'Rising Three Methods', 'Category': 'Bullish Continuation', 'Direction': 'Bullish', 'Candles': 5}) if fb_detect_falling_three_methods(df, idx, cfg): found.append({'Pattern': 'Falling Three Methods', 'Category': 'Bearish Continuation', 'Direction': 'Bearish', 'Candles': 5}) # Deduplicate if cfg.get('deduplicate_signals', True): found_dicts = [{'name': f['Pattern'], 'category': f['Category'], 'direction': f['Direction']} for f in found] deduped = deduplicate_patterns(found_dicts, cfg) found = [f for f in found if any(f['Pattern'] == d['name'] for d in deduped)] # D1 trend filter d1_trend = 'N/A' if cfg.get('d1_trend_filter', False) and d1_df is not None: d1_trend = fb_get_d1_trend_at_time(d1_df, row['DATETIME'], cfg) filtered_found = [] for pat in found: if pat['Direction'] == 'Bullish' and d1_trend == 'uptrend': filtered_found.append(pat) elif pat['Direction'] == 'Bearish' and d1_trend == 'downtrend': filtered_found.append(pat) elif pat['Direction'] == 'Neutral': filtered_found.append(pat) found = filtered_found # Volume filter if cfg.get('volume_filter', False): vol_confirmed = row['TICKVOL'] >= cfg.get('volume_threshold', 1.0) * row['VOL_MA'] if row['VOL_MA'] > 0 else True found = [p for p in found if p['Direction'] == 'Neutral' or vol_confirmed] else: vol_confirmed = True for pat in found: det = fb_compute_details(df, idx, pat, atr.iloc[idx], sl_mult, tp_mult, forward_candles, cfg, d1_df, vol_confirmed, tf_label, d1_trend, atr_tf) if det is not None: detections.append(det) print(f" [{tf_label}] Scanning complete.{' '*30}") return detections def fb_get_d1_trend_at_time(d1_df, h4_datetime, cfg=None): """Get D1 trend at a given datetime.""" d1_bar = d1_df[d1_df['DATETIME'] <= h4_datetime] if len(d1_bar) == 0: return 'ranging' return d1_bar.iloc[-1].get('D1_TREND', 'ranging') # ============================================================ # SUPPORT/RESISTANCE & RSI HELPERS # ============================================================ def fb_detect_swing_levels(df, idx, lookback=50, cfg=None): """Detect nearby swing highs and lows for support/resistance context. Returns dict with: - near_support: bool — price is within 1 ATR of a recent swing low - near_resistance: bool — price is within 1 ATR of a recent swing high - at_swing_low: bool — candle low is the lowest in the lookback window - at_swing_high: bool — candle high is the highest in the lookback window """ if cfg is None: cfg = CFG lookback = min(lookback, idx) if lookback < 5: return {'near_support': False, 'near_resistance': False, 'at_swing_low': False, 'at_swing_high': False} subset = df.iloc[idx - lookback:idx + 1] row = df.iloc[idx] current_atr = row.get('ATR', 0) if pd.isna(current_atr) or current_atr <= 0: current_atr = subset['HIGH'].sub(subset['LOW']).mean() if current_atr <= 0: current_atr = 0.001 # Find swing highs and lows (local extremes using a 5-bar window) swing_highs = [] swing_lows = [] for i in range(2, len(subset) - 2): s = subset.iloc[i] if s['HIGH'] >= subset.iloc[i-1]['HIGH'] and s['HIGH'] >= subset.iloc[i-2]['HIGH'] \ and s['HIGH'] >= subset.iloc[i+1]['HIGH'] and s['HIGH'] >= subset.iloc[i+2]['HIGH']: swing_highs.append(s['HIGH']) if s['LOW'] <= subset.iloc[i-1]['LOW'] and s['LOW'] <= subset.iloc[i-2]['LOW'] \ and s['LOW'] <= subset.iloc[i+1]['LOW'] and s['LOW'] <= subset.iloc[i+2]['LOW']: swing_lows.append(s['LOW']) near_support = any(abs(row['LOW'] - sl) <= current_atr for sl in swing_lows) if swing_lows else False near_resistance = any(abs(row['HIGH'] - sh) <= current_atr for sh in swing_highs) if swing_highs else False at_swing_low = row['LOW'] <= subset['LOW'].min() + current_atr * 0.1 at_swing_high = row['HIGH'] >= subset['HIGH'].max() - current_atr * 0.1 return { 'near_support': near_support, 'near_resistance': near_resistance, 'at_swing_low': at_swing_low, 'at_swing_high': at_swing_high, } def fb_compute_rsi(df, idx, period=14): """Compute RSI at a given index using Wilder's smoothing method. Returns the RSI value (0-100) or None if insufficient data. """ if idx < period + 1: return None subset = df.iloc[max(0, idx - period * 3):idx + 1] if len(subset) < period + 1: return None deltas = subset['CLOSE'].diff().dropna() if len(deltas) < period: return None gains = deltas.where(deltas > 0, 0.0) losses = (-deltas).where(deltas < 0, 0.0) # Seed with SMA avg_gain = gains.iloc[:period].mean() avg_loss = losses.iloc[:period].mean() if avg_loss == 0: return 100.0 # Wilder's smoothing for i in range(period, len(gains)): avg_gain = (avg_gain * (period - 1) + gains.iloc[i]) / period avg_loss = (avg_loss * (period - 1) + losses.iloc[i]) / period if avg_loss == 0: return 100.0 rs = avg_gain / avg_loss return round(100.0 - (100.0 / (1.0 + rs)), 1) def fb_compute_confluence(direction, trend, d1_trend, vol_confirmed, sr_context, rsi_value, session_quality, cfg=None): """Compute a confluence score (0-6 with D1 filter, 0-7 without) based on multiple confirming factors. Each factor that aligns with the trade direction adds 1 point: 1. Trend alignment — trade with the local trend 2. D1 trend alignment — trade with the daily trend (SKIPPED when d1_trend_filter is active, since it's guaranteed) 3. Volume confirmation — above-average volume on signal candle 4. Support/Resistance context — near key level 5. RSI extreme — oversold for bullish, overbought for bearish 6. At swing extreme — at a swing high/low 7. Session quality — PRIME or FAVORABLE session Returns (confluence_score, confluence_factors_list) """ if cfg is None: cfg = CFG score = 0 factors = [] # 1. Trend alignment if direction == 'Bullish' and trend == 'uptrend': score += 1; factors.append('trend') elif direction == 'Bearish' and trend == 'downtrend': score += 1; factors.append('trend') # 2. D1 trend alignment — skip when d1_trend_filter is active # (the filter already guarantees alignment, so counting it would # inflate every score by +1 and destroy score differentiation) if not cfg.get('d1_trend_filter', False): if direction == 'Bullish' and d1_trend == 'uptrend': score += 1; factors.append('d1_trend') elif direction == 'Bearish' and d1_trend == 'downtrend': score += 1; factors.append('d1_trend') # 3. Volume confirmation if vol_confirmed: score += 1; factors.append('volume') # 4. S/R context — near support for bullish, near resistance for bearish if sr_context.get('near_support') and direction == 'Bullish': score += 1; factors.append('support') elif sr_context.get('near_resistance') and direction == 'Bearish': score += 1; factors.append('resistance') # 5. RSI extreme if rsi_value is not None: if direction == 'Bullish' and rsi_value < 35: score += 1; factors.append(f'rsi_{rsi_value}') elif direction == 'Bearish' and rsi_value > 65: score += 1; factors.append(f'rsi_{rsi_value}') # 6. At swing extreme if sr_context.get('at_swing_low') and direction == 'Bullish': score += 1; factors.append('swing_low') elif sr_context.get('at_swing_high') and direction == 'Bearish': score += 1; factors.append('swing_high') # 7. Session quality if session_quality in ('PRIME', 'FAVORABLE'): score += 1; factors.append(f'session_{session_quality}') return score, factors def fb_compute_details(df, idx, pinfo, current_atr, sl_mult, tp_mult, forward_candles, cfg=None, d1_df=None, vol_confirmed=True, tf_label='H4', d1_trend='N/A', atr_tf=None): """Compute SL/TP/R-levels + forward evaluation + confluence for one pattern occurrence. Enhanced with: - Variable R:R by pattern (rr_by_pattern config override) - Support/Resistance context (swing level detection) - RSI value at signal candle - Confluence score (0-7) and factor list - Time-to-SL/TP (bars_to_sl, bars_to_tp) - MAE/MFE (Max Adverse/Favorable Excursion in R) """ if cfg is None: cfg = CFG row = df.iloc[idx] direction = pinfo['Direction'] pip_divisor = cfg.get('pip_divisor', 0.0001) max_r_levels = cfg.get('max_r_levels', 5) # Variable R:R by pattern — override tp_mult if pattern is listed rr_overrides = cfg.get('rr_by_pattern', {}) pattern_name = pinfo['Pattern'] if pattern_name in rr_overrides: effective_tp_mult = rr_overrides[pattern_name] rr_ratio = effective_tp_mult / sl_mult else: effective_tp_mult = tp_mult rr_ratio = tp_mult / sl_mult # SL placement: ATR-based (default) or structure-based sl_mode = cfg.get('sl_mode', 'atr') struct_sl = None sl_reason = '' if sl_mode == 'structure' and direction in ('Bullish', 'Bearish'): struct_result = compute_structure_sl(pattern_name, direction, df, idx, cfg) if struct_result is not None: struct_sl, sl_reason = struct_result if direction == 'Bullish': if struct_sl is not None: sl = struct_sl else: sl = row['LOW'] - sl_mult * current_atr risk = row['CLOSE'] - sl tp = row['CLOSE'] + risk * rr_ratio elif direction == 'Bearish': if struct_sl is not None: sl = struct_sl else: sl = row['HIGH'] + sl_mult * current_atr risk = sl - row['CLOSE'] tp = row['CLOSE'] - risk * rr_ratio else: sl_val = row['LOW'] - sl_mult * current_atr risk_bull = row['CLOSE'] - sl_val risk_bear = (row['HIGH'] + sl_mult * current_atr) - row['CLOSE'] sl = f"{sl_val:.5f}" tp = f"Long:{row['CLOSE']+risk_bull*rr_ratio:.5f}|Short:{row['CLOSE']-risk_bear*rr_ratio:.5f}" risk = None sl_pips = round(risk / pip_divisor, 1) if risk is not None else None r_levels = {} if direction == 'Bullish' and risk is not None and risk > 0: for r in range(1, max_r_levels+1): r_levels[f'R{r}'] = round(row['CLOSE'] + r * risk, 5) elif direction == 'Bearish' and risk is not None and risk > 0: for r in range(1, max_r_levels+1): r_levels[f'R{r}'] = round(row['CLOSE'] - r * risk, 5) body_top = max(row['OPEN'], row['CLOSE']) body_bottom = min(row['OPEN'], row['CLOSE']) if direction == 'Bullish': if pinfo['Pattern'] in ('Hammer', 'Inverted Hammer', 'Morning Star', 'Three White Soldiers', 'Tweezer Bottoms', 'Rising Three Methods') \ or 'Bullish Engulfing' in pinfo['Pattern'] or 'Bullish Harami' in pinfo['Pattern']: entry_type = 'Buy Stop'; entry_price = round(body_top, 5) elif 'Marubozu' in pinfo['Pattern'] and 'Bullish' in pinfo['Pattern']: entry_type = 'Market Buy'; entry_price = round(row['CLOSE'], 5) else: entry_type = 'Buy Stop'; entry_price = round(body_top, 5) elif direction == 'Bearish': if pinfo['Pattern'] in ('Evening Star', 'Shooting Star', 'Hanging Man', 'Three Black Crows', 'Falling Three Methods', 'Tweezer Tops') \ or 'Bearish Engulfing' in pinfo['Pattern'] or 'Bearish Harami' in pinfo['Pattern']: entry_type = 'Sell Stop'; entry_price = round(body_bottom, 5) elif 'Marubozu' in pinfo['Pattern'] and 'Bearish' in pinfo['Pattern']: entry_type = 'Market Sell'; entry_price = round(row['CLOSE'], 5) else: entry_type = 'Sell Stop'; entry_price = round(body_bottom, 5) else: entry_type = 'Breakout'; entry_price = None # Entry verification entry_filled = True; fill_price = entry_price; no_fill = False; gap_fill = False if cfg.get('verify_entry', True) and direction in ('Bullish', 'Bearish') and idx + 1 < len(df): next_c = df.iloc[idx+1] if entry_type == 'Buy Stop': if next_c['HIGH'] >= entry_price: fill_price = round(max(next_c['OPEN'], entry_price), 5) gap_fill = next_c['OPEN'] > entry_price else: entry_filled = False; no_fill = True elif entry_type == 'Sell Stop': if next_c['LOW'] <= entry_price: fill_price = round(min(next_c['OPEN'], entry_price), 5) gap_fill = next_c['OPEN'] < entry_price else: entry_filled = False; no_fill = True elif entry_type in ('Market Buy', 'Market Sell'): fill_price = round(df.iloc[idx+1]['OPEN'], 5) # Recalculate risk from fill price if verified if cfg.get('verify_entry', True) and fill_price is not None and entry_filled and direction in ('Bullish', 'Bearish'): if direction == 'Bullish' and isinstance(sl, float): risk = fill_price - sl if risk > 0: tp = fill_price + risk * rr_ratio for r in range(1, max_r_levels+1): r_levels[f'R{r}'] = round(fill_price + r * risk, 5) sl_pips = round(risk / pip_divisor, 1) elif direction == 'Bearish' and isinstance(sl, float): risk = sl - fill_price if risk > 0: tp = fill_price - risk * rr_ratio for r in range(1, max_r_levels+1): r_levels[f'R{r}'] = round(fill_price - r * risk, 5) sl_pips = round(risk / pip_divisor, 1) # ── Context analysis: S/R, RSI, confluence ────────────────────── hour = row['DATETIME'].hour session = classify_session(hour, cfg) trend = fb_detect_trend(df, idx, cfg) # Support/Resistance context sr_context = fb_detect_swing_levels(df, idx, lookback=50, cfg=cfg) # RSI rsi_value = fb_compute_rsi(df, idx, period=14) # Session quality (for confluence scoring) # We need stats to compute session quality, but during backtest we don't have stats yet. # Use a simple heuristic based on session name instead. prime_sessions = {'London/NY Overlap', 'London Open'} favorable_sessions = {'London Morning'} if session in prime_sessions: session_quality = 'PRIME' elif session in favorable_sessions: session_quality = 'FAVORABLE' elif session in ('NY Afternoon', 'Asia'): session_quality = 'NEUTRAL' else: session_quality = 'UNFAVORABLE' # Confluence score confluence_score, confluence_factors = fb_compute_confluence( direction, trend, d1_trend, vol_confirmed, sr_context, rsi_value, session_quality, cfg) # Forward evaluation prediction_success = sl_hit_result = tp_hit_result = None outcome = 'Timeout'; max_r = 0 r_hits = {f'R{r}_Hit': None for r in range(1, max_r_levels+1)} bars_to_sl = None; bars_to_tp = None mae_r = 0.0; mfe_r = 0.0 exit_r = 0.0; sl_moved_to_be = False; partial_closed = False; remaining_pct = 1.0 if no_fill: outcome = 'No_Fill'; entry_filled = False elif direction in ('Bullish', 'Bearish') and isinstance(sl, float) and idx + 1 < len(df): fwd = simulate_forward_evaluation(df, idx, direction, sl, tp, r_levels, forward_candles, cfg, fill_price=fill_price) sl_hit_result = fwd['sl_hit']; tp_hit_result = fwd['tp_hit'] outcome = fwd['outcome']; max_r = fwd['max_r']; r_hits = fwd['r_hits'] bars_to_sl = fwd.get('bars_to_sl'); bars_to_tp = fwd.get('bars_to_tp') mae_r = fwd.get('mae_r', 0.0); mfe_r = fwd.get('mfe_r', 0.0) exit_r = fwd.get('exit_r', 0.0) sl_moved_to_be = fwd.get('sl_moved_to_be', False) partial_closed = fwd.get('partial_closed', False) remaining_pct = fwd.get('remaining_pct', 1.0) prediction_success = (True if outcome in ('TP_Hit', 'Marginal_Win') else False if outcome in ('SL_Hit', 'Marginal_Loss', 'No_Fill', 'Expired') else None) result = { 'Timeframe': tf_label, 'DateTime': row['DATETIME'], 'Date': row['DATE'], 'Time': row['TIME'], 'Pattern': pinfo['Pattern'], 'Category': pinfo['Category'], 'Direction': direction, 'Session': session, 'Trend_Context': trend, 'D1_Trend': d1_trend, 'Open': row['OPEN'], 'High': row['HIGH'], 'Low': row['LOW'], 'Close': row['CLOSE'], 'ATR': round(current_atr, 5) if not pd.isna(current_atr) else None, 'ATR_TF': atr_tf or tf_label, 'SL': round(sl, 5) if isinstance(sl, float) else sl, 'TP': round(tp, 5) if isinstance(tp, float) else tp, 'SL_Pips': sl_pips, 'Risk_1R': round(risk, 5) if risk is not None else None, 'TP_R_Multiple': round(rr_ratio, 2), 'Entry_Type': entry_type, 'Entry_Price': entry_price, 'Fill_Price': fill_price, 'Entry_Filled': entry_filled, 'Gap_Fill': gap_fill, 'Outcome': outcome, 'Max_R': max_r, 'Prediction_Success': prediction_success, 'SL_Hit': sl_hit_result, 'TP_Hit': tp_hit_result, 'Volume_Confirmed': vol_confirmed, 'Candles_in_Pattern': pinfo['Candles'], 'Forward_Candles': forward_candles, # New fields 'Bars_to_SL': bars_to_sl, 'Bars_to_TP': bars_to_tp, 'MAE_R': mae_r, 'MFE_R': mfe_r, 'RSI': rsi_value, 'Near_Support': sr_context['near_support'], 'Near_Resistance': sr_context['near_resistance'], 'At_Swing_Low': sr_context['at_swing_low'], 'At_Swing_High': sr_context['at_swing_high'], 'Confluence_Score': confluence_score, 'Confluence_Factors': '|'.join(confluence_factors) if confluence_factors else '', 'RR_Override': pattern_name if pattern_name in rr_overrides else '', 'Exit_R': exit_r, 'SL_Moved_to_BE': sl_moved_to_be, 'Partial_Closed': partial_closed, 'Remaining_Pct': remaining_pct, } for r in range(1, max_r_levels+1): rk = f'R{r}' result[rk] = r_levels.get(rk) result[f'R{r}_Hit'] = r_hits.get(f'R{r}_Hit') result[f'R{r}_Pips'] = (round(r * risk / pip_divisor, 1) if r_levels.get(rk) is not None and risk is not None else None) return result def compute_equity_curve(detections, cfg=None): """Compute equity curve and drawdown statistics from backtest detections. Simulates sequential trading with fixed position sizing (1R risk per trade), tracking cumulative P&L in R-multiples, then derives key metrics: - Cumulative P&L curve - Max drawdown (R and %) - Sharpe ratio (annualised, assuming 252 trading days) - Calmar ratio (annualised return / max drawdown) - Max consecutive wins/losses - Profit factor (gross profit / gross loss) - Expectancy (average R per trade) Returns dict with equity curve data and statistics, or None if insufficient data. """ if cfg is None: cfg = CFG if not detections or len(detections) < 5: return None det_df = pd.DataFrame(detections) directional = det_df[det_df['Direction'] != 'Neutral'].copy() if len(directional) < 5: return None # Sort by DateTime to ensure sequential order if 'DateTime' in directional.columns: directional = directional.sort_values('DateTime').reset_index(drop=True) # Determine R-multiple for each trade # Use exit_r if available (v8 trade management), else derive from outcome r_multiples = [] for _, row in directional.iterrows(): if 'Exit_R' in row and not pd.isna(row.get('Exit_R')): r_mult = float(row['Exit_R']) elif row.get('Outcome') == 'TP_Hit': r_mult = float(row.get('TP_R_Multiple', 1.0)) elif row.get('Outcome') == 'SL_Hit': # Check if SL was moved to breakeven if row.get('SL_Moved_to_BE', False): r_mult = 0.0 else: r_mult = -1.0 elif row.get('Outcome') == 'Marginal_Win': r_mult = 0.1 # Small positive elif row.get('Outcome') == 'Marginal_Loss': r_mult = -0.1 # Small negative elif row.get('Outcome') == 'Expired': r_mult = 0.0 elif row.get('Outcome') == 'No_Fill': r_mult = 0.0 else: r_mult = 0.0 # Timeout r_multiples.append(r_mult) directional = directional.copy() directional['R_Multiple'] = r_multiples # Cumulative equity curve (starting at 0) directional['Cumulative_R'] = directional['R_Multiple'].cumsum() # Drawdown calculation directional['Peak_R'] = directional['Cumulative_R'].cummax() directional['Drawdown_R'] = directional['Cumulative_R'] - directional['Peak_R'] max_dd_r = directional['Drawdown_R'].min() # Max drawdown percentage (relative to peak equity) peak_at_dd = directional.loc[directional['Drawdown_R'].idxmin(), 'Peak_R'] if max_dd_r < 0 else 0 max_dd_pct = abs(max_dd_r / peak_at_dd * 100) if peak_at_dd > 0 else 0 # Consecutive streaks wins = (directional['R_Multiple'] > 0).values losses = (directional['R_Multiple'] < 0).values max_consec_wins = 0 max_consec_losses = 0 current_streak = 0 current_type = None for w, l in zip(wins, losses): if w: if current_type == 'win': current_streak += 1 else: current_type = 'win' current_streak = 1 max_consec_wins = max(max_consec_wins, current_streak) elif l: if current_type == 'loss': current_streak += 1 else: current_type = 'loss' current_streak = 1 max_consec_losses = max(max_consec_losses, current_streak) else: current_streak = 0 current_type = None # Profit factor gross_profit = directional.loc[directional['R_Multiple'] > 0, 'R_Multiple'].sum() gross_loss = abs(directional.loc[directional['R_Multiple'] < 0, 'R_Multiple'].sum()) profit_factor = gross_profit / gross_loss if gross_loss > 0 else float('inf') # Expectancy expectancy = directional['R_Multiple'].mean() # Sharpe ratio (annualised) if directional['R_Multiple'].std() > 0: # Assume ~4 trades per day average across all TFs trades_per_year = 252 * 4 sharpe = (directional['R_Multiple'].mean() / directional['R_Multiple'].std()) * np.sqrt(trades_per_year) else: sharpe = 0.0 # Calmar ratio (annualised return / max drawdown) total_trades = len(directional) annual_return = directional['Cumulative_R'].iloc[-1] * (252 * 4 / max(total_trades, 1)) calmar = annual_return / abs(max_dd_r) if max_dd_r != 0 else 0.0 # Win/loss statistics n_wins = int((directional['R_Multiple'] > 0).sum()) n_losses = int((directional['R_Multiple'] < 0).sum()) avg_win = directional.loc[directional['R_Multiple'] > 0, 'R_Multiple'].mean() if n_wins > 0 else 0 avg_loss = directional.loc[directional['R_Multiple'] < 0, 'R_Multiple'].mean() if n_losses > 0 else 0 return { 'total_trades': total_trades, 'n_wins': n_wins, 'n_losses': n_losses, 'final_equity_r': round(directional['Cumulative_R'].iloc[-1], 2), 'max_dd_r': round(max_dd_r, 2), 'max_dd_pct': round(max_dd_pct, 1), 'max_consec_wins': max_consec_wins, 'max_consec_losses': max_consec_losses, 'profit_factor': round(profit_factor, 2), 'expectancy': round(expectancy, 3), 'sharpe': round(sharpe, 2), 'calmar': round(calmar, 2), 'avg_win_r': round(avg_win, 3) if avg_win else 0, 'avg_loss_r': round(avg_loss, 3) if avg_loss else 0, 'gross_profit_r': round(gross_profit, 2), 'gross_loss_r': round(gross_loss, 2), 'equity_curve': directional['Cumulative_R'].tolist(), 'drawdown_curve': directional['Drawdown_R'].tolist(), } # ============================================================ # BACKTEST REPORT GENERATOR # ============================================================ def fb_generate_report(detections, df, symbol, tf_label, cfg=None): """Generate full text report for one timeframe backtest.""" if cfg is None: cfg = CFG max_r_levels = cfg.get('max_r_levels', 5) forward_candles = get_forward_candles(tf_label, cfg) tf_minutes = TIMEFRAME_MAP.get(tf_label, {}).get('minutes', 240) lines = [] L = lines.append L("=" * 120) L(f"{symbol} [{tf_label}] PRICE ACTION PATTERN BACKTEST REPORT") L("=" * 120) L(f"Timeframe : {tf_label} ({tf_minutes} min candles)") L(f"Data Period : {df.loc[df['IN_RANGE'],'DATE'].iloc[0]} to {df.loc[df['IN_RANGE'],'DATE'].iloc[-1]}") L(f"Total Candles : {df['IN_RANGE'].sum()}") L(f"Total Detections : {len(detections)}") L(f"ATR Period : {cfg.get('atr_period', 14)}") atr_src = get_atr_tf(tf_label, cfg) if atr_src != tf_label: L(f"ATR Source TF : {atr_src} (higher-TF ATR for wider SL/TP)") else: L(f"ATR Source TF : {tf_label} (native)") L(f"SL Multiplier : {cfg.get('sl_multiplier', 1.5)} x ATR") L(f"SL Mode : {cfg.get('sl_mode', 'atr')}") L(f"TP R:R : 1:{cfg.get('tp_multiplier', 1.5)/cfg.get('sl_multiplier', 1.5):.1f}") L(f"Forward Eval : {forward_candles} candles = {forward_candles * tf_minutes // 60:.0f} hours") L(f"D1 Trend Filter : {cfg.get('d1_trend_filter', False)}") L(f"Volume Filter : {cfg.get('volume_filter', False)}") L(f"Verify Entry : {cfg.get('verify_entry', True)}") L(f"Trade Management : {cfg.get('trade_management_mode', 'fixed')}") if cfg.get('trade_management_mode', 'fixed') != 'fixed': L(f" Breakeven at : {cfg.get('breakeven_at_r', 1.0)}R") L(f" Trail at : {cfg.get('trail_at_r', 1.5)}R x {cfg.get('trail_atr_mult', 1.0)} ATR") L(f" Partial close : {cfg.get('partial_close_pct', 0.5)*100:.0f}% at {cfg.get('partial_close_r', 1.0)}R") L(f" Time stop : {cfg.get('time_stop_pct', 0.7)*100:.0f}% of forward window") L(f"Deduplicate : {cfg.get('deduplicate_signals', True)}") L(f"Timeout Mode : {cfg.get('timeout_mode', 'marginal')}") L("") if not detections: L("No patterns detected.") return "\n".join(lines) det_df = pd.DataFrame(detections) directional = det_df[det_df['Direction'] != 'Neutral'] def bc(s): s_ = int((s == True).sum()); f_ = int((s == False).sum()) return s_, f_, round(s_ / (s_ + f_) * 100, 1) if (s_ + f_) > 0 else 0 L("-" * 120); L("SECTION 1: PATTERN FREQUENCY"); L("-" * 120) for pat, cnt in det_df['Pattern'].value_counts().items(): L(f" {pat:30s} | {det_df[det_df['Pattern']==pat]['Direction'].iloc[0]:10s} | Count: {cnt}") L(""); L("-" * 120); L("SECTION 2: SESSION DISTRIBUTION"); L("-" * 120) for sess, cnt in det_df['Session'].value_counts().items(): L(f" {sess:25s} | {cnt:4d} | {cnt/len(det_df)*100:.1f}%") L(""); L("-" * 120); L("SECTION 3: WIN RATE BY PATTERN"); L("-" * 120) hdr = f" {'Pattern':30s} | {'Total':>6s} | {'Win':>5s} | {'Loss':>5s} | {'WR%':>6s} | {'SL%':>6s} | {'TP%':>6s} | {'AvgSL pips':>11s}" L(hdr); L(" " + "-" * (len(hdr)-2)) for pat in det_df['Pattern'].unique(): ds = det_df[(det_df['Pattern'] == pat) & (det_df['Direction'] != 'Neutral')] total = len(det_df[det_df['Pattern'] == pat]) if len(ds) > 0: s, f_, wr = bc(ds['Prediction_Success']) slp = round((ds['SL_Hit'] == True).sum() / len(ds) * 100, 1) tpp = round((ds['TP_Hit'] == True).sum() / len(ds) * 100, 1) asp = ds['SL_Pips'].dropna().mean() else: s = f_ = 0; wr = slp = tpp = 0; asp = float('nan') L(f" {pat:30s} | {total:6d} | {s:5d} | {f_:5d} | {wr:5.1f}% | {slp:5.1f}% | {tpp:5.1f}% | {asp:.1f}" if not pd.isna(asp) else f" {pat:30s} | {total:6d} | {s:5d} | {f_:5d} | {wr:5.1f}% | {slp:5.1f}% | {tpp:5.1f}% | N/A") L(""); L("-" * 120); L("SECTION 4: OUTCOME BREAKDOWN"); L("-" * 120) for outcome_name in ['TP_Hit', 'SL_Hit', 'Marginal_Win', 'Marginal_Loss', 'Expired', 'Timeout', 'No_Fill']: cnt = int((directional['Outcome'] == outcome_name).sum()) if len(directional) > 0 else 0 pct = round(cnt / len(directional) * 100, 1) if len(directional) > 0 else 0 L(f" {outcome_name:20s} | {cnt:6d} | {pct:5.1f}%") L(""); L("-" * 120); L("SECTION 5: R-LEVEL HIT RATES BY PATTERN"); L("-" * 120) rh = f" {'Pattern':30s} | {'Sigs':>5s}" + ''.join([f" | {'R'+str(r)+'%':>6s}" for r in range(1, max_r_levels+1)]) + " | AvgMaxR" L(rh); L(" " + "-" * (len(rh)-2)) for pat in det_df['Pattern'].unique(): ds = det_df[(det_df['Pattern'] == pat) & (det_df['Direction'] != 'Neutral')] if len(ds) == 0: continue rp = [f" {pat:30s} | {len(ds):5d}"] for r in range(1, max_r_levels+1): col = f'R{r}_Hit' if col in ds.columns: hc = int((ds[col] == True).sum()); ec = int((ds[col].notna()).sum()) rp.append(f" | {round(hc/ec*100, 0) if ec > 0 else 0:5.0f}%") else: rp.append(f" | {'N/A':>6s}") amr = ds['Max_R'].dropna().mean() rp.append(f" | {amr:.2f}" if not pd.isna(amr) else " | N/A") L(''.join(rp)) L(""); L("-" * 120); L("SECTION 6: WIN RATE BY SESSION"); L("-" * 120) for sess in directional['Session'].unique() if len(directional) > 0 else []: sd = directional[directional['Session'] == sess] if len(sd) == 0: continue s, f_, wr = bc(sd['Prediction_Success']) amr = sd['Max_R'].dropna().mean() L(f" {sess:25s} | Signals: {len(sd):4d} | WR: {wr:.1f}% | AvgMaxR: {amr:.2f}R") L(""); L("-" * 120); L("SECTION 7: KEY STATISTICS"); L("-" * 120) td = len(directional) if td > 0: s, f_, owr = bc(directional['Prediction_Success']) L(f" Total directional signals : {td}") L(f" Overall win rate : {owr:.1f}%") L(f" SL hit rate : {round((directional['SL_Hit']==True).sum()/td*100, 1):.1f}%") L(f" TP hit rate : {round((directional['TP_Hit']==True).sum()/td*100, 1):.1f}%") L(f" Avg SL pips : {directional['SL_Pips'].dropna().mean():.1f}") L(f" Avg Max R : {directional['Max_R'].dropna().mean():.2f}R") for r in range(1, max_r_levels+1): col = f'R{r}_Hit' if col in directional.columns: hc = int((directional[col] == True).sum()); ec = int(directional[col].notna().sum()) L(f" R{r} hit rate : {round(hc/ec*100,1) if ec>0 else 0:.1f}%") # ── Equity Curve & Drawdown ── if cfg.get('equity_curve_enabled', True) and len(directional) >= 5: eq = compute_equity_curve(detections, cfg) if eq: L(""); L("-" * 120); L("SECTION 8: EQUITY CURVE & DRAWDOWN"); L("-" * 120) L(f" Total Trades : {eq['total_trades']}") L(f" Final Equity : {eq['final_equity_r']:.2f}R") L(f" Max Drawdown : {eq['max_dd_r']:.2f}R ({eq['max_dd_pct']:.1f}%)") L(f" Max Consec Wins : {eq['max_consec_wins']}") L(f" Max Consec Losses : {eq['max_consec_losses']}") L(f" Profit Factor : {eq['profit_factor']:.2f}") L(f" Expectancy : {eq['expectancy']:.3f}R per trade") L(f" Avg Win : {eq['avg_win_r']:.3f}R") L(f" Avg Loss : {eq['avg_loss_r']:.3f}R") L(f" Gross Profit : {eq['gross_profit_r']:.2f}R") L(f" Gross Loss : {eq['gross_loss_r']:.2f}R") L(f" Sharpe Ratio : {eq['sharpe']:.2f}") L(f" Calmar Ratio : {eq['calmar']:.2f}") L(""); L("=" * 120) return "\n".join(lines) # ============================================================ # MODE 1: LIVE MULTI-TIMEFRAME SCANNER # ============================================================ def run_scanner(cfg=None): """Live scanner loop — monitors all active timeframes for new candle closes.""" if cfg is None: cfg = CFG active_tfs = cfg.get('active_timeframes', ['M5', 'M15', 'H1', 'H4', 'D1']) symbol = cfg['symbol'] watchlist = cfg.get('watchlist', [symbol]) if len(watchlist) > 1: log_message(f"Multi-symbol watchlist: {', '.join(watchlist)}", cfg) log_message(C('cyan', '=' * 70), cfg) log_message(C('bold', f" {symbol} MULTI-TIMEFRAME PATTERN SCANNER v8 — STARTING"), cfg) log_message(C('cyan', '=' * 70), cfg) watchlist_display = ', '.join(cfg.get('watchlist', [symbol])) if len(cfg.get('watchlist', [])) > 1: log_message(f" Watchlist: {watchlist_display} (live scanner: {symbol})", cfg) log_message(f"Active timeframes: {C('yellow', ', '.join(active_tfs))}", cfg) sl_str = f"{cfg['sl_multiplier']}x ATR" log_message(f"SL: {C('red', sl_str)} | TP R:R = 1:{cfg['tp_multiplier']/cfg['sl_multiplier']:.1f}", cfg) # Show ATR source per TF atr_map_display = [] for tf in active_tfs: atr_src = get_atr_tf(tf, cfg) atr_map_display.append(f"{tf}→{atr_src}" if atr_src != tf else tf) log_message(f"ATR Source: {', '.join(atr_map_display)}", cfg) if cfg.get('d1_trend_filter', False): log_message(f"D1 Trend Filter: {C('green', 'ENABLED')} (SMA {cfg['d1_sma_period']})", cfg) if cfg.get('volume_filter', False): log_message(f"Volume Filter: {C('green', 'ENABLED')} ({cfg['volume_threshold']}x avg)", cfg) # Sound alert status if cfg.get('sound_enabled', True) and _WINSOUND: buy_hz = cfg.get('sound_buy_hz', 1200) sell_hz = cfg.get('sound_sell_hz', 400) threshold = cfg.get('sound_strong_threshold', 65.0) log_message(f"Sound Alerts: {C('green', 'ENABLED')} | Buy: {buy_hz}Hz | Sell: {sell_hz}Hz | Threshold: {threshold:.0f}", cfg) log_message(f"Sound is {C('red', 'MUTED')} — Type {C('yellow', '\"m\" + Enter')} to unmute", cfg) elif not _WINSOUND: log_message(C('yellow', "Sound Alerts: DISABLED (winsound not available — Windows only)"), cfg) if len(cfg.get('watchlist', [])) > 1: log_message(f"Watchlist: {C('yellow', ', '.join(cfg['watchlist']))} (live scanner uses first symbol; use --mode scan for multi-symbol)", cfg) # Start background keyboard listener for mute toggle if cfg.get('sound_enabled', True) and _WINSOUND: start_sound_key_listener() # Load backtest stats for historical edge display stats = load_latest_backtest_stats(cfg=cfg) stats_last_refresh = datetime.now() if stats.get('overall', {}).get('total_signals', 0) > 0: owr = stats['overall'].get('win_rate', 0) on = stats['overall'].get('total_signals', 0) log_message(f"Backtest stats loaded: Overall WR {owr:.1f}% ({on} signals)", cfg) else: log_message("No backtest stats found. Run fullbacktest first for historical edge data.", cfg) # Print dashboard on start if cfg.get('show_dashboard_on_start', True) and stats.get('overall', {}).get('total_signals', 0) > 0: print_top_setups(stats, cfg) if not connect_mt5(cfg): return # Track last candle time per timeframe last_candle_time = {tf: None for tf in active_tfs} d1_rates_cache = None try: while True: try: # Refresh D1 data periodically for trend filter if cfg.get('d1_trend_filter', False): d1_rates_cache = fetch_rates(symbol, 'D1', cfg.get('bars_to_fetch', 50), cfg) # Auto-refresh stats cache periodically if (datetime.now() - stats_last_refresh).total_seconds() > cfg.get('stats_cache_hours', 4) * 3600: stats = load_latest_backtest_stats(cfg=cfg) stats_last_refresh = datetime.now() if stats.get('overall', {}).get('total_signals', 0) > 0: log_message(f"Stats refreshed: Overall WR {stats['overall'].get('win_rate',0):.1f}%", cfg) # Fetch higher-timeframe ATR rates once per loop iteration htf_atr_rates_cache = {} # tf_label → rates atr_tfs_needed = set() for tf in active_tfs: atr_src = get_atr_tf(tf, cfg) if atr_src != tf: atr_tfs_needed.add(atr_src) for atr_src in atr_tfs_needed: htf_rates = fetch_rates(symbol, atr_src, cfg.get('bars_to_fetch', 50), cfg) if htf_rates is not None: htf_atr_rates_cache[atr_src] = htf_rates for tf_label in active_tfs: tf_info = TIMEFRAME_MAP[tf_label] poll_interval = cfg.get('poll_interval_by_tf', {}).get(tf_label, 30) rates = fetch_rates(symbol, tf_label, cfg.get('bars_to_fetch', 50), cfg) if rates is None: continue # Resolve ATR source for this TF atr_src = get_atr_tf(tf_label, cfg) htf_atr_rates = htf_atr_rates_cache.get(atr_src) if atr_src != tf_label else None bar_time = rates[-1]['time'] if isinstance(bar_time, (int, float, np.integer, np.floating)): bar_time = broker_time(int(bar_time)) if last_candle_time[tf_label] is None: last_candle_time[tf_label] = bar_time # Scan the most recent closed candle on startup if len(rates) >= 2: pats = scan_patterns(list(rates[:-1]), cfg, d1_rates_cache, tf_label, htf_atr_rates) pats = apply_signal_score_filter(pats, stats, cfg, tf_label=tf_label) log_message(format_pattern_output(rates[-2], pats, cfg, stats, tf_label), cfg) # Play sound alert for strong signals on startup scan for pat in pats: if pat.get('direction') in ('Bullish', 'Bearish'): score = pat.get('signal_score') if score is None: score = compute_signal_score(pat['name'], pat['session'], pat['direction'], stats, cfg, tf_label=tf_label) play_signal_beep(pat['direction'], score, cfg) continue if bar_time != last_candle_time[tf_label]: next_close = bar_time + timedelta(minutes=tf_info['minutes']) log_message( C('bold', C('yellow', f"\nNEW {tf_label} CANDLE CLOSED! | Next: {next_close.strftime('%Y-%m-%d %H:%M')}" )), cfg ) pats = scan_patterns(list(rates[:-1]), cfg, d1_rates_cache, tf_label, htf_atr_rates) pats = apply_signal_score_filter(pats, stats, cfg, tf_label=tf_label) output = format_pattern_output(rates[-2], pats, cfg, stats, tf_label) log_message(output, cfg) # Play sound alert for strong directional signals for pat in pats: if pat.get('direction') in ('Bullish', 'Bearish'): score = pat.get('signal_score') if score is None: score = compute_signal_score(pat['name'], pat['session'], pat['direction'], stats, cfg, tf_label=tf_label) play_signal_beep(pat['direction'], score, cfg) last_candle_time[tf_label] = bar_time # Keyboard listener runs in background thread — no manual check needed time.sleep(min(cfg.get('poll_interval_by_tf', {}).get(tf, 30) for tf in active_tfs)) except Exception as e: log_message(f"Scanner iteration error: {e}", cfg) if not mt5_reconnect(cfg): break except KeyboardInterrupt: log_message("\nScanner stopped by user (Ctrl+C)", cfg) finally: try: mt5.shutdown() except Exception: pass log_message("MT5 connection closed.", cfg) # ============================================================ # MODE 2: ONE-SHOT SCAN (all active timeframes) # ============================================================ def run_single_scan(cfg=None): """Single scan of the latest closed candle on all active timeframes.""" if cfg is None: cfg = CFG active_tfs = cfg.get('active_timeframes', ['M5', 'M15', 'H1', 'H4', 'D1']) log_message(f"Running single scan on: {', '.join(active_tfs)}", cfg) # Load backtest stats stats = load_latest_backtest_stats(cfg=cfg) if stats.get('overall', {}).get('total_signals', 0) > 0: owr = stats['overall'].get('win_rate', 0) on = stats['overall'].get('total_signals', 0) log_message(f"Backtest stats loaded: Overall WR {owr:.1f}% ({on} signals)", cfg) else: log_message("No backtest stats found. Run fullbacktest first for historical edge data.", cfg) # Print dashboard if cfg.get('show_dashboard_on_start', True) and stats.get('overall', {}).get('total_signals', 0) > 0: print_top_setups(stats, cfg) if not connect_mt5(cfg): return d1_rates = None if cfg.get('d1_trend_filter', False): d1_rates = fetch_rates(cfg['symbol'], 'D1', cfg.get('bars_to_fetch', 50), cfg) # Pre-fetch higher-timeframe ATR rates htf_atr_rates_cache = {} atr_tfs_needed = set() for tf in active_tfs: atr_src = get_atr_tf(tf, cfg) if atr_src != tf: atr_tfs_needed.add(atr_src) for atr_src in atr_tfs_needed: htf_rates = fetch_rates(cfg['symbol'], atr_src, cfg.get('bars_to_fetch', 50), cfg) if htf_rates is not None: htf_atr_rates_cache[atr_src] = htf_rates for tf_label in active_tfs: rates = fetch_rates(cfg['symbol'], tf_label, cfg.get('bars_to_fetch', 50), cfg) if rates is None: log_message(f"No data for {tf_label}.", cfg) continue closed = rates[-2] if len(rates) >= 2 else rates[-1] scan_src = list(rates[:-1]) if len(rates) >= 2 else list(rates) # Resolve ATR source for this TF atr_src = get_atr_tf(tf_label, cfg) htf_atr_rates = htf_atr_rates_cache.get(atr_src) if atr_src != tf_label else None pats = scan_patterns(scan_src, cfg, d1_rates, tf_label, htf_atr_rates) pats = apply_signal_score_filter(pats, stats, cfg, tf_label=tf_label) log_message(format_pattern_output(closed, pats, cfg, stats, tf_label), cfg) # Play sound alert for strong directional signals for pat in pats: if pat.get('direction') in ('Bullish', 'Bearish'): score = pat.get('signal_score') if score is None: score = compute_signal_score(pat['name'], pat['session'], pat['direction'], stats, cfg, tf_label=tf_label) play_signal_beep(pat['direction'], score, cfg) try: mt5.shutdown() except Exception: pass log_message("Single scan complete.", cfg) # ============================================================ # MODE 3: QUICK BACKTEST (N recent bars, single TF) # ============================================================ def run_quick_backtest(num_bars=500, cfg=None): """Quick backtest over N recent bars. Supports all active timeframes.""" if cfg is None: cfg = CFG active_tfs = cfg.get('active_timeframes', ['H4']) symbol = cfg['symbol'] log_message(f"Quick backtest: {num_bars} bars on {', '.join(active_tfs)}", cfg) if not connect_mt5(cfg): return # Pre-fetch higher-timeframe ATR rates htf_atr_rates_cache = {} atr_tfs_needed = set() for tf in active_tfs: atr_src = get_atr_tf(tf, cfg) if atr_src != tf: atr_tfs_needed.add(atr_src) for atr_src in atr_tfs_needed: htf_rates = fetch_rates(symbol, atr_src, num_bars, cfg) if htf_rates is not None: htf_atr_rates_cache[atr_src] = htf_rates for tf_label in active_tfs: log_message(f"\n--- [{tf_label}] ---", cfg) rates = fetch_rates(symbol, tf_label, num_bars, cfg) if rates is None: log_message(f"No data for {tf_label}.", cfg) continue # Resolve ATR source atr_src = get_atr_tf(tf_label, cfg) htf_atr_rates = htf_atr_rates_cache.get(atr_src) if atr_src != tf_label else None rates_list = list(rates) total_patterns = 0 pattern_counts = {} all_detections = [] for i in range(5, len(rates_list) - 1): subset = rates_list[:i+1] pats = scan_patterns(subset, cfg, tf_label=tf_label, htf_atr_rates=htf_atr_rates) if pats: candle = rates_list[i] total_patterns += len(pats) for p in pats: pattern_counts[p['name']] = pattern_counts.get(p['name'], 0) + 1 ct = candle['time'] if isinstance(ct, (int, float, np.integer, np.floating)): ct = broker_time(int(ct)) all_detections.append({ 'Timeframe': tf_label, 'DateTime': ct, 'Pattern': p['name'], 'Direction': p['direction'], 'Session': p['session'], 'Open': candle['open'], 'High': candle['high'], 'Low': candle['low'], 'Close': candle['close'], 'Entry_Type': p.get('entry_type'), 'Entry_Price': p.get('entry_price'), 'ATR': p.get('atr'), 'SL': p.get('sl'), 'TP': p.get('tp'), 'SL_Dist_Pips': p.get('sl_dist_pips'), }) log_message(f"[{tf_label}] Total patterns: {total_patterns}", cfg) for name, count in sorted(pattern_counts.items(), key=lambda x: -x[1]): log_message(f" {name:35s}: {count}", cfg) if all_detections: csv_path = os.path.join(_LOG_DIR, f"quick_backtest_{symbol}_{tf_label}.csv") pd.DataFrame(all_detections).to_csv(csv_path, index=False) log_message(f" → {csv_path}", cfg) try: mt5.shutdown() except Exception: pass log_message("\nQuick backtest complete.", cfg) # ============================================================ # MODE 4: FULL DATE-RANGED BACKTEST (all active timeframes) # ============================================================ def run_full_backtest(args, cfg=None): """Full backtest with date range, R-levels, forward evaluation across all active TFs.""" if cfg is None: cfg = CFG active_tfs = cfg.get('active_timeframes', ['M5', 'M15', 'H1', 'H4', 'D1']) symbol = args.symbol date_from = datetime.strptime(args.date_from, "%Y-%m-%d") date_to = datetime.strptime(args.date_to, "%Y-%m-%d") + timedelta(days=1) - timedelta(seconds=1) out_dir = args.output print("=" * 70) print(f" {symbol} MULTI-TIMEFRAME BACKTESTER v8") print("=" * 70) print(f" Timeframes : {', '.join(active_tfs)}") print(f" From : {args.date_from}") print(f" To : {args.date_to}") print(f" ATR : {cfg.get('atr_period', 14)}") # Show ATR source per TF atr_map_display = [] for tf in active_tfs: atr_src = get_atr_tf(tf, cfg) atr_map_display.append(f"{tf}→{atr_src}" if atr_src != tf else tf) print(f" ATR Source : {', '.join(atr_map_display)}") print(f" SL/TP : {cfg.get('sl_multiplier', 1.5)}x / {cfg.get('tp_multiplier', 1.5)}x ATR") print(f" SL Mode : {cfg.get('sl_mode', 'atr')}") print(f" Trade Mgmt : {cfg.get('trade_management_mode', 'fixed')}") print(f" Output : {out_dir}") print() print("[1] Connecting to MT5...") if not connect_mt5(cfg): print("FATAL: Could not connect to MT5."); sys.exit(1) # Fetch D1 data for trend filter (shared across TFs if needed) d1_df_cache = None if cfg.get('d1_trend_filter', False): print("[2] Fetching D1 data for trend filter...") d1_df_cache = fetch_rates_range(symbol, 'D1', date_from, date_to, cfg) if d1_df_cache is not None: d1_df_cache['D1_SMA'] = d1_df_cache['CLOSE'].rolling(window=cfg.get('d1_sma_period', 20), min_periods=1).mean() d1_df_cache['D1_TREND'] = np.where(d1_df_cache['CLOSE'] > d1_df_cache['D1_SMA'], 'uptrend', np.where(d1_df_cache['CLOSE'] < d1_df_cache['D1_SMA'], 'downtrend', 'ranging')) # Pre-fetch higher-timeframe data for ATR calculation # For example, if M5 uses H1 ATR, fetch H1 data once and reuse it htf_atr_cache = {} # tf_label → DataFrame atr_tf_needed = set() for tf in active_tfs: atr_src = get_atr_tf(tf, cfg) if atr_src != tf: atr_tf_needed.add(atr_src) for atr_src in atr_tf_needed: print(f"[ATR] Fetching {atr_src} data for higher-timeframe ATR...") htf_df = fetch_rates_range(symbol, atr_src, date_from, date_to, cfg) if htf_df is not None: htf_atr_cache[atr_src] = htf_df print(f" [ATR] {atr_src} data ready ({len(htf_df)} bars)") else: print(f" [ATR] WARNING: Could not fetch {atr_src} data — will fall back to native ATR") all_results = {} # tf_label → list of detection dicts for tf_label in active_tfs: print(f"\n[TF] Fetching {tf_label} data...") df = fetch_rates_range(symbol, tf_label, date_from, date_to, cfg) if df is None: print(f" [{tf_label}] No data — skipping.") continue # Use D1 data as trend filter for all TFs below D1 d1_for_filter = None if tf_label == 'D1' else d1_df_cache # Resolve the ATR source TF and its DataFrame atr_src = get_atr_tf(tf_label, cfg) htf_atr_df = htf_atr_cache.get(atr_src) if atr_src != tf_label else None print(f" [{tf_label}] Running pattern detection...") detections = fb_detect_all_patterns(df, cfg, d1_for_filter, tf_label, htf_atr_df) all_results[tf_label] = detections print(f" [{tf_label}] {len(detections)} pattern detections") if not detections: print(f" [{tf_label}] No patterns found.") continue os.makedirs(out_dir, exist_ok=True) tag = f"{symbol}_{tf_label}_{args.date_from}_to_{args.date_to}" det_csv = os.path.join(out_dir, f"{tag}_detections.csv") sum_csv = os.path.join(out_dir, f"{tag}_pattern_summary.csv") sess_csv = os.path.join(out_dir, f"{tag}_session_summary.csv") rpt_file = os.path.join(out_dir, f"{tag}_report.txt") det_df_out = pd.DataFrame(detections) det_df_out.to_csv(det_csv, index=False, encoding='utf-8') print(f" → {det_csv}") # Pattern summary CSV directional = det_df_out[det_df_out['Direction'] != 'Neutral'] max_r_levels = cfg.get('max_r_levels', 5) srows = [] for pat in det_df_out['Pattern'].unique(): ps = det_df_out[det_df_out['Pattern'] == pat] ds = ps[ps['Direction'] != 'Neutral'] row_s = {'Timeframe': tf_label, 'Pattern': pat, 'Category': ps['Category'].iloc[0], 'Direction': ps['Direction'].iloc[0], 'Total': len(ps)} if len(ds) > 0: s_ = int((ds['Prediction_Success'] == True).sum()) f_ = int((ds['Prediction_Success'] == False).sum()) wr_ = round(s_ / (s_ + f_) * 100, 1) if (s_ + f_) > 0 else 0 row_s.update({ 'Wins': s_, 'Losses': f_, 'Win_Rate_%': wr_, 'SL_Hit_%': round((ds['SL_Hit'] == True).sum() / len(ds) * 100, 1), 'TP_Hit_%': round((ds['TP_Hit'] == True).sum() / len(ds) * 100, 1), 'Avg_SL_Pips': round(ds['SL_Pips'].dropna().mean(), 1) if not ds['SL_Pips'].dropna().empty else 0, 'Avg_Max_R': round(ds['Max_R'].dropna().mean(), 2) if not ds['Max_R'].dropna().empty else 0, # New fields 'Avg_MAE_R': round(ds['MAE_R'].dropna().mean(), 3) if 'MAE_R' in ds.columns and not ds['MAE_R'].dropna().empty else None, 'Avg_MFE_R': round(ds['MFE_R'].dropna().mean(), 3) if 'MFE_R' in ds.columns and not ds['MFE_R'].dropna().empty else None, 'Avg_Bars_to_TP': round(ds['Bars_to_TP'].dropna().mean(), 1) if 'Bars_to_TP' in ds.columns and not ds['Bars_to_TP'].dropna().empty else None, 'Avg_RSI': round(ds['RSI'].dropna().mean(), 1) if 'RSI' in ds.columns and not ds['RSI'].dropna().empty else None, 'At_Support_Pct': round((ds['Near_Support'] == True).sum() / max(len(ds),1) * 100, 1) if 'Near_Support' in ds.columns else None, 'At_Resistance_Pct': round((ds['Near_Resistance'] == True).sum() / max(len(ds),1) * 100, 1) if 'Near_Resistance' in ds.columns else None, 'Avg_Confluence': round(ds['Confluence_Score'].dropna().mean(), 1) if 'Confluence_Score' in ds.columns and not ds['Confluence_Score'].dropna().empty else None, 'Avg_Exit_R': round(ds['Exit_R'].dropna().mean(), 3) if 'Exit_R' in ds.columns and not ds['Exit_R'].dropna().empty else None, 'BE_Move_Pct': round((ds['SL_Moved_to_BE'] == True).sum() / max(len(ds),1) * 100, 1) if 'SL_Moved_to_BE' in ds.columns else None, }) for r in range(1, max_r_levels+1): col = f'R{r}_Hit' if col in ds.columns: hc = int((ds[col] == True).sum()); ec = int(ds[col].notna().sum()) row_s[f'R{r}_Hit_%'] = round(hc / ec * 100, 1) if ec > 0 else 0 else: row_s[f'R{r}_Hit_%'] = 0 else: row_s.update({'Wins': 0, 'Losses': 0, 'Win_Rate_%': 0, 'SL_Hit_%': 0, 'TP_Hit_%': 0, 'Avg_SL_Pips': 0, 'Avg_Max_R': 0}) for r in range(1, max_r_levels+1): row_s[f'R{r}_Hit_%'] = 0 srows.append(row_s) pd.DataFrame(srows).to_csv(sum_csv, index=False, encoding='utf-8') print(f" → {sum_csv}") # Session summary CSV srows2 = [] for sess in directional['Session'].unique() if len(directional) > 0 else []: sd = directional[directional['Session'] == sess] if len(sd) == 0: continue s_ = int((sd['Prediction_Success'] == True).sum()) f_ = int((sd['Prediction_Success'] == False).sum()) wr_ = round(s_ / (s_ + f_) * 100, 1) if (s_ + f_) > 0 else 0 row_s2 = {'Timeframe': tf_label, 'Session': sess, 'Signals': len(sd), 'Wins': s_, 'Losses': f_, 'Win_Rate_%': wr_, 'SL_Hit_%': round((sd['SL_Hit'] == True).sum() / len(sd) * 100, 1), 'TP_Hit_%': round((sd['TP_Hit'] == True).sum() / len(sd) * 100, 1), 'Avg_SL_Pips': round(sd['SL_Pips'].dropna().mean(), 1) if not sd['SL_Pips'].dropna().empty else 0, 'Avg_Max_R': round(sd['Max_R'].dropna().mean(), 2) if not sd['Max_R'].dropna().empty else 0} for r in range(1, max_r_levels+1): col = f'R{r}_Hit' if col in sd.columns: hc = int((sd[col] == True).sum()); ec = int(sd[col].notna().sum()) row_s2[f'R{r}_Hit_%'] = round(hc / ec * 100, 1) if ec > 0 else 0 else: row_s2[f'R{r}_Hit_%'] = 0 srows2.append(row_s2) pd.DataFrame(srows2).to_csv(sess_csv, index=False, encoding='utf-8') print(f" → {sess_csv}") # Text report report = fb_generate_report(detections, df, symbol, tf_label, cfg) with open(rpt_file, 'w', encoding='utf-8') as fh: fh.write(report) print(f" → {rpt_file}") # Quick TF summary print(f"\n [{tf_label}] Quick Summary:") if len(directional) > 0: s_ = int((directional['Prediction_Success'] == True).sum()) f_ = int((directional['Prediction_Success'] == False).sum()) wr_ = round(s_ / (s_ + f_) * 100, 1) if (s_ + f_) > 0 else 0 print(f" Directional signals : {len(directional)}") print(f" Win rate : {wr_}%") print(f" Avg SL pips : {directional['SL_Pips'].dropna().mean():.1f}") print(f" Avg Max R : {directional['Max_R'].dropna().mean():.2f}R") # Save combined stats JSON — ENRICHED with per-TF patterns/sessions/cross/confluence try: combined_stats = {'symbol': symbol, 'generated_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S'), 'backtest_range': f"{args.date_from} to {args.date_to}", 'timeframes': {}} for tf_label, dets in all_results.items(): if not dets: continue df_tf = pd.DataFrame(dets) dirdf = df_tf[df_tf['Direction'] != 'Neutral'] tf_stats = {} if len(dirdf) > 0: s_ = int((dirdf['Prediction_Success'] == True).sum()) f_ = int((dirdf['Prediction_Success'] == False).sum()) tf_stats['overall'] = { 'win_rate': round(s_ / (s_ + f_) * 100, 1) if (s_ + f_) > 0 else 0, 'total_signals': len(dirdf), 'avg_max_r': round(float(dirdf['Max_R'].dropna().mean()), 2), 'sl_hit_pct': round(float((dirdf['SL_Hit'] == True).sum() / len(dirdf) * 100), 1), 'tp_hit_pct': round(float((dirdf['TP_Hit'] == True).sum() / len(dirdf) * 100), 1), 'avg_mae_r': round(float(dirdf['MAE_R'].dropna().mean()), 3) if 'MAE_R' in dirdf.columns else None, 'avg_mfe_r': round(float(dirdf['MFE_R'].dropna().mean()), 3) if 'MFE_R' in dirdf.columns else None, 'avg_bars_to_tp': round(float(dirdf['Bars_to_TP'].dropna().mean()), 1) if 'Bars_to_TP' in dirdf.columns else None, 'avg_exit_r': round(float(dirdf['Exit_R'].dropna().mean()), 3) if 'Exit_R' in dirdf.columns else None, 'be_move_pct': round(float((dirdf['SL_Moved_to_BE'] == True).sum() / max(len(dirdf),1) * 100), 1) if 'SL_Moved_to_BE' in dirdf.columns else None, } # Per-pattern stats tf_stats['patterns'] = {} for pat in dirdf['Pattern'].unique(): ps = dirdf[dirdf['Pattern'] == pat] ps_ = int((ps['Prediction_Success'] == True).sum()) pf_ = int((ps['Prediction_Success'] == False).sum()) tf_stats['patterns'][pat] = { 'win_rate': round(ps_ / (ps_ + pf_) * 100, 1) if (ps_ + pf_) > 0 else 0, 'total': len(ps), 'avg_max_r': round(float(ps['Max_R'].dropna().mean()), 2) if not ps['Max_R'].dropna().empty else 0, 'sl_hit_pct': round(float((ps['SL_Hit'] == True).sum() / len(ps) * 100), 1), 'tp_hit_pct': round(float((ps['TP_Hit'] == True).sum() / len(ps) * 100), 1), } # Per-session stats tf_stats['sessions'] = {} for sess in dirdf['Session'].unique(): sd = dirdf[dirdf['Session'] == sess] ss_ = int((sd['Prediction_Success'] == True).sum()) sf_ = int((sd['Prediction_Success'] == False).sum()) tf_stats['sessions'][sess] = { 'win_rate': round(ss_ / (ss_ + sf_) * 100, 1) if (ss_ + sf_) > 0 else 0, 'signals': len(sd), 'avg_max_r': round(float(sd['Max_R'].dropna().mean()), 2) if not sd['Max_R'].dropna().empty else 0, } # Cross stats (pattern x session) tf_stats['cross'] = {} for pat in dirdf['Pattern'].unique(): for sess in dirdf['Session'].unique(): cs = dirdf[(dirdf['Pattern'] == pat) & (dirdf['Session'] == sess)] if len(cs) >= 3: cs_ = int((cs['Prediction_Success'] == True).sum()) cf_ = int((cs['Prediction_Success'] == False).sum()) tf_stats['cross'][f"{pat}|{sess}"] = { 'win_rate': round(cs_ / (cs_ + cf_) * 100, 1) if (cs_ + cf_) > 0 else 0, 'signals': len(cs), 'avg_max_r': round(float(cs['Max_R'].dropna().mean()), 2) if not cs['Max_R'].dropna().empty else 0, } # Confluence breakdown if 'Confluence_Score' in dirdf.columns: tf_stats['confluence'] = {} for cs_val in sorted(dirdf['Confluence_Score'].dropna().unique()): csd = dirdf[dirdf['Confluence_Score'] == cs_val] cs_ = int((csd['Prediction_Success'] == True).sum()) cf_ = int((csd['Prediction_Success'] == False).sum()) tf_stats['confluence'][str(int(cs_val))] = { 'win_rate': round(cs_ / (cs_ + cf_) * 100, 1) if (cs_ + cf_) > 0 else 0, 'signals': len(csd), 'avg_max_r': round(float(csd['Max_R'].dropna().mean()), 2) if not csd['Max_R'].dropna().empty else 0, } # Equity curve if cfg.get('equity_curve_enabled', True): eq = compute_equity_curve(dets, cfg) if eq: tf_stats['equity'] = { 'final_equity_r': eq['final_equity_r'], 'max_dd_r': eq['max_dd_r'], 'max_dd_pct': eq['max_dd_pct'], 'max_consec_wins': eq['max_consec_wins'], 'max_consec_losses': eq['max_consec_losses'], 'profit_factor': eq['profit_factor'], 'expectancy': eq['expectancy'], 'sharpe': eq['sharpe'], 'calmar': eq['calmar'], 'avg_win_r': eq['avg_win_r'], 'avg_loss_r': eq['avg_loss_r'], } combined_stats['timeframes'][tf_label] = tf_stats stats_path = os.path.join(out_dir, 'latest_stats_multitf.json') os.makedirs(out_dir, exist_ok=True) with open(stats_path, 'w', encoding='utf-8') as sf: json.dump(combined_stats, sf, indent=2, ensure_ascii=False) print(f"\n Stats → {stats_path}") except Exception as e: print(f" [WARNING] Could not save stats: {e}") try: mt5.shutdown() except Exception: pass print("\nFull backtest complete.") # ============================================================ # ARGUMENT PARSER & MAIN # ============================================================ def parse_args(cfg=None): if cfg is None: cfg = CFG p = argparse.ArgumentParser( description="MT5 Multi-Timeframe Candlestick Pattern Scanner & Backtester v8", formatter_class=argparse.RawTextHelpFormatter, epilog=""" Examples: # Live scanner — all timeframes python mt5_multitf_pattern_scanner_v8.py # Live scanner — specific timeframes python mt5_multitf_pattern_scanner_v8.py --timeframes M5 H1 H4 # One-shot scan python mt5_multitf_pattern_scanner_v8.py --mode scan # Quick backtest (500 bars) on H4 only python mt5_multitf_pattern_scanner_v8.py --mode backtest --bars 500 --timeframes H4 # Full backtest on all TFs, 2024 full year python mt5_multitf_pattern_scanner_v8.py --mode fullbacktest --from 2024-01-01 --to 2024-12-31 # Full backtest with filters on H4 only python mt5_multitf_pattern_scanner_v8.py --mode fullbacktest --timeframes H4 \\ --d1-trend-filter --volume-filter --forward 15 """ ) p.add_argument("--mode", choices=['live', 'scan', 'backtest', 'fullbacktest'], default='live', help="Operating mode (default: live)") p.add_argument("--timeframes", nargs='+', choices=list(TIMEFRAME_MAP.keys()), default=cfg['active_timeframes'], help="Active timeframes (default: M5 M15 H1 H4 D1)") p.add_argument("--bars", type=int, default=500, help="Bars for quick backtest (default: 500)") # Full backtest p.add_argument("--from", dest="date_from", default="2024-01-01", help="Full backtest start date YYYY-MM-DD") p.add_argument("--to", dest="date_to", default="2024-12-31", help="Full backtest end date YYYY-MM-DD") # Core parameters p.add_argument("--symbol", default=cfg['symbol']) p.add_argument('--symbols', nargs='+', default=None, help='Watchlist of symbols to scan/backtest (default: EURUSD from CFG). ' 'Example: --symbols EURUSD GBPUSD USDJPY') p.add_argument('--sl-mode', choices=['atr', 'structure'], default=None, help='SL placement mode: atr (default, ATR-based) or structure (pattern invalidation level)') p.add_argument('--trade-management', choices=['fixed', 'breakeven', 'trail', 'partial'], default=None, help='Trade management mode in backtest: fixed (default), breakeven, trail, or partial') p.add_argument('--timeout-mode', choices=['marginal', 'expired'], default=None, help='Timeout classification: marginal (Marginal_Win/Loss) or expired (flat 0R)') p.add_argument("--atr", type=int, default=cfg['atr_period']) p.add_argument("--atr-tf", type=str, default=None, help="Override ATR source timeframe for ALL timeframes (e.g. H1, H4). " "By default, atr_tf_by_tf config is used (M5→H1, M15→H1, etc.)") p.add_argument("--sl", type=float, default=cfg['sl_multiplier']) p.add_argument("--tp", type=float, default=cfg['tp_multiplier']) p.add_argument("--forward",type=int, default=cfg['default_forward_candles'], help="Default forward candles for evaluation (H4 default)") p.add_argument("--output", default=DEFAULT_OUTPUT_DIR) # MT5 connection overrides — credentials always come from .env p.add_argument("--mt5-path", default=cfg['mt5_path']) p.add_argument("--account", type=int, default=cfg['account']) p.add_argument("--password", default=cfg['password']) p.add_argument("--server", default=cfg['server']) # Pattern thresholds p.add_argument("--doji-body-ratio", type=float, default=cfg['doji_body_ratio']) p.add_argument("--spinning-top-body-ratio", type=float, default=cfg['spinning_top_body_ratio']) p.add_argument("--marubozu-wick-ratio", type=float, default=cfg['marubozu_wick_ratio']) p.add_argument("--hammer-lower-wick-ratio", type=float, default=cfg['hammer_lower_wick_ratio']) p.add_argument("--hammer-upper-wick-ratio", type=float, default=cfg['hammer_upper_wick_ratio']) p.add_argument("--long-candle-ratio", type=float, default=cfg['long_candle_ratio']) p.add_argument("--small-candle-ratio", type=float, default=cfg['small_candle_ratio']) p.add_argument("--tweezer-tolerance", type=float, default=cfg['tweezer_tolerance_pips']) p.add_argument("--engulf-tolerance-pips", type=float, default=cfg['engulf_tolerance_pips']) p.add_argument("--trend-lookback", type=int, default=cfg['trend_lookback']) p.add_argument("--broker-utc-offset", type=int, default=cfg['broker_utc_offset']) # Filters p.add_argument("--deduplicate", dest="deduplicate_signals", action="store_true") p.add_argument("--no-deduplicate", dest="deduplicate_signals", action="store_false") p.add_argument("--verify-entry", dest="verify_entry", action="store_true") p.add_argument("--no-verify-entry", dest="verify_entry", action="store_false") p.add_argument("--volume-filter", dest="volume_filter", action="store_true") p.add_argument("--no-volume-filter", dest="volume_filter", action="store_false") p.add_argument("--volume-ma-period", type=int, default=cfg['volume_ma_period']) p.add_argument("--volume-threshold", type=float, default=cfg['volume_threshold']) p.add_argument("--d1-trend-filter", dest="d1_trend_filter", action="store_true") p.add_argument("--no-d1-trend-filter", dest="d1_trend_filter", action="store_false") p.add_argument("--d1-sma-period", type=int, default=cfg['d1_sma_period']) # Reconnect p.add_argument("--max-reconnect-attempts", type=int, default=cfg['max_reconnect_attempts']) p.add_argument("--reconnect-backoff", type=int, default=cfg['reconnect_backoff_base']) # Live signal filtering p.add_argument("--min-signal-score", type=float, default=cfg['min_signal_score']) p.add_argument("--alert-only-strong", dest="alert_only_strong", action="store_true") p.add_argument("--no-alert-only-strong", dest="alert_only_strong", action="store_false") p.add_argument("--show-dashboard", dest="show_dashboard_on_start", action="store_true") p.add_argument("--no-dashboard", dest="show_dashboard_on_start", action="store_false") # Position sizing p.add_argument("--account-balance", type=float, default=cfg['account_balance']) p.add_argument("--risk-percent", type=float, default=cfg['risk_percent']) # Misc p.add_argument("--warmup-bars", type=int, default=cfg['warmup_bars']) p.add_argument("--bars-to-fetch", type=int, default=cfg['bars_to_fetch']) p.add_argument("--test-sound", action="store_true", help="Play test beeps (STRONG BUY then STRONG SELL) and exit") p.set_defaults( deduplicate_signals=cfg['deduplicate_signals'], verify_entry=cfg['verify_entry'], volume_filter=cfg['volume_filter'], d1_trend_filter=cfg['d1_trend_filter'], alert_only_strong=cfg['alert_only_strong'], show_dashboard_on_start=cfg['show_dashboard_on_start'], ) return p.parse_args() def main(): args = parse_args() # Build runtime CFG from defaults + CLI overrides runtime_cfg = dict(CFG) runtime_cfg['active_timeframes'] = args.timeframes cli_to_cfg = { 'symbol': 'symbol', 'atr': 'atr_period', 'sl': 'sl_multiplier', 'tp': 'tp_multiplier', 'forward': 'default_forward_candles', 'mt5_path': 'mt5_path', 'account': 'account', 'password': 'password', 'server': 'server', 'doji_body_ratio': 'doji_body_ratio', 'spinning_top_body_ratio': 'spinning_top_body_ratio', 'marubozu_wick_ratio': 'marubozu_wick_ratio', 'hammer_lower_wick_ratio': 'hammer_lower_wick_ratio', 'hammer_upper_wick_ratio': 'hammer_upper_wick_ratio', 'long_candle_ratio': 'long_candle_ratio', 'small_candle_ratio': 'small_candle_ratio', 'tweezer_tolerance': 'tweezer_tolerance_pips', 'engulf_tolerance_pips': 'engulf_tolerance_pips', 'trend_lookback': 'trend_lookback', 'broker_utc_offset': 'broker_utc_offset', 'deduplicate_signals': 'deduplicate_signals', 'verify_entry': 'verify_entry', 'volume_filter': 'volume_filter', 'volume_ma_period': 'volume_ma_period', 'volume_threshold': 'volume_threshold', 'd1_trend_filter': 'd1_trend_filter', 'd1_sma_period': 'd1_sma_period', 'max_reconnect_attempts': 'max_reconnect_attempts', 'reconnect_backoff': 'reconnect_backoff_base', 'warmup_bars': 'warmup_bars', 'bars_to_fetch': 'bars_to_fetch', 'min_signal_score': 'min_signal_score', 'alert_only_strong': 'alert_only_strong', 'show_dashboard_on_start': 'show_dashboard_on_start', 'account_balance': 'account_balance', 'risk_percent': 'risk_percent', } for cli_key, cfg_key in cli_to_cfg.items(): if hasattr(args, cli_key): runtime_cfg[cfg_key] = getattr(args, cli_key) # Handle --atr-tf override: if specified, override all ATR source TFs if hasattr(args, 'atr_tf') and args.atr_tf is not None: override_tf = args.atr_tf.upper() if override_tf not in TIMEFRAME_MAP: print(f"ERROR: --atr-tf '{override_tf}' not in {list(TIMEFRAME_MAP.keys())}") sys.exit(1) # Override the per-TF mapping to use the specified TF for all runtime_cfg['atr_tf_by_tf'] = {tf: override_tf for tf in TIMEFRAME_MAP.keys()} # Handle --sl-mode, --trade-management, --timeout-mode overrides if args.sl_mode: runtime_cfg['sl_mode'] = args.sl_mode if args.trade_management: runtime_cfg['trade_management_mode'] = args.trade_management if args.timeout_mode: runtime_cfg['timeout_mode'] = args.timeout_mode # Handle --test-sound: play both test beeps and exit if args.test_sound: test_sound(runtime_cfg) return # Determine symbol watchlist if args.symbols: watchlist = args.symbols else: watchlist = runtime_cfg.get('watchlist', [runtime_cfg.get('symbol', 'EURUSD')]) if args.mode == 'live': run_scanner(runtime_cfg) # Scanner handles its own symbol via cfg elif args.mode == 'scan': for sym in watchlist: if len(watchlist) > 1: print(f"\n{'='*60}") print(f" SCANNING: {sym}") print(f"{'='*60}") runtime_cfg['symbol'] = sym run_single_scan(runtime_cfg) elif args.mode == 'backtest': for sym in watchlist: if len(watchlist) > 1: print(f"\n{'='*60}") print(f" QUICK BACKTEST: {sym}") print(f"{'='*60}") runtime_cfg['symbol'] = sym run_quick_backtest(args.bars, runtime_cfg) elif args.mode == 'fullbacktest': for sym in watchlist: if len(watchlist) > 1: print(f"\n{'='*60}") print(f" FULL BACKTEST: {sym}") print(f"{'='*60}") args.symbol = sym runtime_cfg['symbol'] = sym run_full_backtest(args, runtime_cfg) if __name__ == '__main__': main()