simulate_locked_portfolio.py

import pandas as pd
import numpy as np

print("Loading 4-Months of tickflow data...")
m1 = pd.read_parquet('tickflow_M1.parquet')
m5 = pd.read_parquet('tickflow_M5.parquet')
m15 = pd.read_parquet('tickflow_M15.parquet')

def calculate_adx(df, period=14):
    df['h_l'] = df['high'] - df['low']
    df['h_pc'] = (df['high'] - df['close'].shift(1)).abs()
    df['l_pc'] = (df['low'] - df['close'].shift(1)).abs()
    df['tr'] = df[['h_l', 'h_pc', 'l_pc']].max(axis=1)
    df['+dm'] = np.where((df['high'] - df['high'].shift(1)) > (df['low'].shift(1) - df['low']), np.maximum(df['high'] - df['high'].shift(1), 0), 0)
    df['-dm'] = np.where((df['low'].shift(1) - df['low']) > (df['high'] - df['high'].shift(1)), np.maximum(df['low'].shift(1) - df['low'], 0), 0)
    alpha = 1 / period
    df['tr_smooth'] = df['tr'].ewm(alpha=alpha, adjust=False).mean() * period
    df['+dm_smooth'] = df['+dm'].ewm(alpha=alpha, adjust=False).mean() * period
    df['-dm_smooth'] = df['-dm'].ewm(alpha=alpha, adjust=False).mean() * period
    df['+di'] = 100 * (df['+dm_smooth'] / df['tr_smooth'])
    df['-di'] = 100 * (df['-dm_smooth'] / df['tr_smooth'])
    df['dx'] = 100 * (df['+di'] - df['-di']).abs() / (df['+di'] + df['-di']).replace(0, 1)
    df['adx'] = df['dx'].ewm(alpha=alpha, adjust=False).mean()
    return df

m1 = calculate_adx(m1, 14)
m5 = calculate_adx(m5, 14)
m15 = calculate_adx(m15, 14)

df = m1[['open', 'high', 'low', 'close', 'adx', '+di', '-di', 'spread_avg']].copy()
if 'spread_avg' not in df.columns:
    df['spread_avg'] = 15.0
else:
    df['spread_avg'] = df['spread_avg'].fillna(15.0)
df.rename(columns={'adx': 'adx_M1', '+di': 'di_plus_M1', '-di': 'di_minus_M1'}, inplace=True)

m5_cols = m5[['adx', '+di', '-di']].rename(columns={'adx': 'adx_M5', '+di': 'di_plus_M5', '-di': 'di_minus_M5'})
df = df.join(m5_cols, how='left').ffill()

m15_cols = m15[['adx', '+di', '-di']].rename(columns={'adx': 'adx_M15', '+di': 'di_plus_M15', '-di': 'di_minus_M15'})
df = df.join(m15_cols, how='left').ffill()
df.dropna(inplace=True)

t = 18.0
df['phase'] = 1
df.loc[(df['adx_M15'] < t) & (df['adx_M5'] < t) & (df['adx_M1'] >= t), 'phase'] = 2
df.loc[(df['adx_M15'] < t) & (df['adx_M5'] >= t) & (df['adx_M1'] < t), 'phase'] = 3
df.loc[(df['adx_M15'] >= t) & (df['adx_M5'] < t) & (df['adx_M1'] < t), 'phase'] = 4
df.loc[(df['adx_M15'] < t) & (df['adx_M5'] >= t) & (df['adx_M1'] >= t), 'phase'] = 5
df.loc[(df['adx_M15'] >= t) & (df['adx_M5'] < t) & (df['adx_M1'] >= t), 'phase'] = 6
df.loc[(df['adx_M15'] >= t) & (df['adx_M5'] >= t) & (df['adx_M1'] < t), 'phase'] = 7
df.loc[(df['adx_M15'] >= t) & (df['adx_M5'] >= t) & (df['adx_M1'] >= t), 'phase'] = 8

df['phase_prev'] = df['phase'].shift(1)
df['phase_transition'] = df['phase'] != df['phase_prev']
df['dmi_dir_m15'] = np.where(df['di_plus_M15'] > df['di_minus_M15'], 1, -1)

portfolio = {
    'D0_Grinder': {'trades': 0, 'wins': 0, 'profit_usd': 0.0, 'tp': 15, 'sl': 15, 'lots': 1.0},
    'L0_Scout': {'trades': 0, 'wins': 0, 'profit_usd': 0.0, 'tp': 20, 'sl': 20, 'lots': 1.0},
    'L0_Snipe': {'trades': 0, 'wins': 0, 'profit_usd': 0.0, 'tp': 30, 'sl': 20, 'lots': 2.0},
    'L0_Mega': {'trades': 0, 'wins': 0, 'profit_usd': 0.0, 'tp': 40, 'sl': 20, 'lots': 3.0},
    'R0_Fade': {'trades': 0, 'wins': 0, 'profit_usd': 0.0, 'tp': 20, 'sl': 20, 'lots': 1.5},
    'R0_Mega_Fade': {'trades': 0, 'wins': 0, 'profit_usd': 0.0, 'tp': 30, 'sl': 20, 'lots': 2.0}
}

COMMISSION_PER_LOT = 7.0
PIP_VALUE = 10.0
SLIPPAGE_POINTS = 5.0
TRAIL_START_PIPS = 10.0

print("Simulating REAL BROKER + TRAILING LOCK SENTINEL...")

active_trades = []
avoided_overlaps = 0

for i in range(1, len(df)):
    current_high = df['high'].iloc[i]
    current_low = df['low'].iloc[i]
    current_close = df['close'].iloc[i]
    current_spread = df['spread_avg'].iloc[i] / 10.0
    
    # Process existing trades
    for trade in active_trades[:]: # copy to iterate and remove
        hit_tp = False
        hit_sl = False
        pnl = 0
        
        # Check Trailing Activation
        if not trade['trailing_unlocked']:
            if trade['dir'] == 1:
                if current_high >= trade['entry'] + (TRAIL_START_PIPS * 0.01):
                    trade['trailing_unlocked'] = True
                    trade['sl_price'] = trade['entry'] # Move SL to breakeven
            else:
                if current_low <= trade['entry'] - (TRAIL_START_PIPS * 0.01):
                    trade['trailing_unlocked'] = True
                    trade['sl_price'] = trade['entry']
        
        # Check SL/TP
        if trade['dir'] == 1:
            if current_high >= trade['tp_price']:
                hit_tp = True
                pnl = portfolio[trade['gun']]['tp']
            elif current_low <= trade['sl_price']:
                hit_sl = True
                pnl = ((trade['sl_price'] - trade['entry']) / 0.01) - (SLIPPAGE_POINTS / 10.0)
        else:
            if current_low <= trade['tp_price'] - (current_spread * 0.01):
                hit_tp = True
                pnl = portfolio[trade['gun']]['tp']
            elif current_high >= trade['sl_price'] - (current_spread * 0.01):
                hit_sl = True
                pnl = ((trade['entry'] - trade['sl_price']) / 0.01) - (SLIPPAGE_POINTS / 10.0)
                
        # Force close after 60 bars if not hit to prevent infinite holds in sim
        trade['age'] += 1
        force_close = False
        if not hit_tp and not hit_sl and trade['age'] > 60:
            force_close = True
            raw_pnl = (current_close - trade['entry']) / 0.01 * trade['dir']
            pnl = raw_pnl - (SLIPPAGE_POINTS / 10.0)
            
        if hit_tp or hit_sl or force_close:
            # Record Stats
            gun = trade['gun']
            win = 1 if pnl > 0 else 0
            net_profit_usd = (pnl * PIP_VALUE * portfolio[gun]['lots']) - (COMMISSION_PER_LOT * portfolio[gun]['lots'])
            
            portfolio[gun]['trades'] += 1
            portfolio[gun]['wins'] += win
            portfolio[gun]['profit_usd'] += net_profit_usd
            active_trades.remove(trade)
            
    # Check Lock
    is_locked = any(not t['trailing_unlocked'] for t in active_trades)
    
    if df['phase_transition'].iloc[i]:
        if is_locked:
            avoided_overlaps += 1
            continue
            
        p_prev = df['phase_prev'].iloc[i]
        p_curr = df['phase'].iloc[i]
        dir_m15 = df['dmi_dir_m15'].iloc[i]
        
        gun = None
        trade_dir = 1
        
        if (p_prev == 1 and p_curr == 2) or (p_prev == 2 and p_curr == 1):
            gun = 'D0_Grinder'
            trade_dir = 1 if df['close'].iloc[i] < df['open'].iloc[i] else -1
        elif (p_prev == 4 and p_curr in [7, 6]):
            gun = 'L0_Scout'
            trade_dir = dir_m15
        elif (p_prev == 5 and p_curr == 8) or (p_prev == 2 and p_curr == 5) or (p_prev == 8 and p_curr == 5):
            gun = 'L0_Snipe'
            trade_dir = dir_m15
        elif p_prev == 7 and p_curr == 8:
            gun = 'L0_Mega'
            trade_dir = dir_m15
        elif p_prev == 8 and p_curr == 7:
            gun = 'R0_Fade'
            trade_dir = -dir_m15
        elif p_prev == 8 and p_curr == 6 or p_prev == 6 and p_curr == 2 or p_prev == 7 and p_curr == 3:
            gun = 'R0_Mega_Fade'
            trade_dir = -dir_m15
            
        if gun:
            real_entry = df['close'].iloc[i] + (current_spread * 0.01) if trade_dir == 1 else df['close'].iloc[i]
            real_entry = real_entry + (SLIPPAGE_POINTS * 0.01) if trade_dir == 1 else real_entry - (SLIPPAGE_POINTS * 0.01)
            tp_price = real_entry + (portfolio[gun]['tp'] * 0.01) if trade_dir == 1 else real_entry - (portfolio[gun]['tp'] * 0.01)
            sl_price = real_entry - (portfolio[gun]['sl'] * 0.01) if trade_dir == 1 else real_entry + (portfolio[gun]['sl'] * 0.01)
            
            active_trades.append({
                'gun': gun,
                'dir': trade_dir,
                'entry': real_entry,
                'tp_price': tp_price,
                'sl_price': sl_price,
                'trailing_unlocked': False,
                'age': 0
            })

print("\n|=================================================|")
print(f"|  FULL LOCKED-PORTFOLIO (4 MONTHS XAUUSD)        |")
print(f"|  (Trailing Sentinel ACTIVE | Spread/Slip ACTIVE)|")
print(f"|=================================================|")

total_usd = 0
for name, p in portfolio.items():
    tr = p['trades']
    if tr == 0: continue
    wr = (p['wins'] / tr) * 100
    profit = p['profit_usd']
    total_usd += profit
    print(f" * {name:<14} (Lot {p['lots']}) | Trades: {tr:<4} | WinRate: {wr:>5.1f}% | Net USD: ${profit:+.2f}")

print(f"\\n [!] Trailing Sentinel Avoided {avoided_overlaps} overlapping/redundant risk exposures.")
print(f"|=================================================|")
print(f"| TOTAL NET PROFIT (4 MONTHS): ${total_usd:+.2f}")
print(f"|=================================================|")