simulate_full_portfolio.py

import pandas as pd
import numpy as np

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

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')

# Aligning Data
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()
# Ensure spread exists, default to 15 points if missing
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
a1 = (df['adx_M1'] >= t).astype(int)
a5 = (df['adx_M5'] >= t).astype(int)
a15 = (df['adx_M15'] >= t).astype(int)

# Exact Phase Mapping
df['phase'] = 1
df.loc[(a15==0) & (a5==0) & (a1==1), 'phase'] = 2
df.loc[(a15==0) & (a5==1) & (a1==0), 'phase'] = 3
df.loc[(a15==1) & (a5==0) & (a1==0), 'phase'] = 4
df.loc[(a15==0) & (a5==1) & (a1==1), 'phase'] = 5
df.loc[(a15==1) & (a5==0) & (a1==1), 'phase'] = 6
df.loc[(a15==1) & (a5==1) & (a1==0), 'phase'] = 7
df.loc[(a15==1) & (a5==1) & (a1==1), '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 Setup
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}
}

# Costs
COMMISSION_PER_LOT = 7.0 # $7 round turn
PIP_VALUE = 10.0 # $10 per lot for 1 standard pip (Gold usually 100 points = 10 pips = $100. So 1 pip = $10)
SLIPPAGE_POINTS = 5.0 # 0.5 pips slippage

print("Simulating Full Broker Conditions (Spread + Comm + Slip) over 94,699 bars (4 Months)...")

for i in range(1, len(df)-60):
    if df['phase_transition'].iloc[i]:
        p_prev = df['phase_prev'].iloc[i]
        p_curr = df['phase'].iloc[i]
        
        dir_m15 = df['dmi_dir_m15'].iloc[i]
        entry = df['close'].iloc[i]
        spread_pips = df['spread_avg'].iloc[i] / 10.0 # points to pips
        
        # Determine strategy
        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 is None:
            continue
            
        # Execute Trade with Broker Costs
        # Effective Entry Price differs due to Spread (Long pays Ask, Short pays Bid)
        # Assuming Close is Bid. Ask = Bid + Spread.
        real_entry = entry + (spread_pips * 0.01) if trade_dir == 1 else entry
        
        # Add Entry Slippage
        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)
        
        future_highs = df['high'].iloc[i+1:i+61].values
        future_lows = df['low'].iloc[i+1:i+61].values
        
        pnl_pips = 0
        win = 0
        
        if trade_dir == 1:
            for h, l in zip(future_highs, future_lows):
                # We need Bid to hit TP for Long. High is Bid High.
                if h >= tp_price:
                    # Hit TP
                    pnl_pips = portfolio[gun]['tp']
                    win = 1
                    break
                elif l <= sl_price:
                    # Hit SL
                    pnl_pips = -portfolio[gun]['sl']
                    # Add slippage to Stop loss (market order exit)
                    pnl_pips -= (SLIPPAGE_POINTS / 10.0) 
                    break
        else:
            for h, l in zip(future_highs, future_lows):
                # For Short, we need Ask to hit TP. Ask = Bid + spread.
                # So Bid Low must be <= tp_price - spread.
                current_spread = df['spread_avg'].iloc[i] / 10.0
                if l <= tp_price - (current_spread * 0.01):
                    pnl_pips = portfolio[gun]['tp']
                    win = 1
                    break
                elif h >= sl_price - (current_spread * 0.01):
                    pnl_pips = -portfolio[gun]['sl']
                    pnl_pips -= (SLIPPAGE_POINTS / 10.0)
                    break
                    
        # If timeout (60 bars), close at market
        if pnl_pips == 0:
            exit_price = df['close'].iloc[i+60]
            # Market close slippage
            exit_price = exit_price - (SLIPPAGE_POINTS * 0.01) if trade_dir == 1 else exit_price + (SLIPPAGE_POINTS * 0.01)
            raw_pnl = (exit_price - real_entry) / 0.01 * trade_dir
            pnl_pips = raw_pnl
            if pnl_pips > 0: win = 1
            
        # Calculate Final Net USD
        # Swap ignored for 60-min scalps
        net_profit_usd = (pnl_pips * 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

print("\n|=================================================|")
print(f"|  FULL REAL-BROKER PORTFOLIO (4 MONTHS XAUUSD)   |")
print(f"|  (Spread Dynamic, Slip 1Pip, Comm $7/Lot)       |")
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"|=================================================|")
print(f"| TOTAL NET PROFIT (4 MONTHS): ${total_usd:+.2f}")
print(f"|=================================================|")