forex-scalping.com

Code: Select all

//+------------------------------------------------------------------+
//|                                          SessionSlippageLog.mq4  |
//+------------------------------------------------------------------+
#property strict

// Adjust these to match your broker's server time GMT offset
input int LondonStartHour = 8;
input int NYStartHour = 13; // NY open / Overlap start
input int NYEndHour = 17;   // London Close / Pure NY afternoon starts here

string logFileName = "Slippage_Log.csv";

// Call this function immediately after a successful OrderSend() 
// or when detecting a pending order trigger.
void LogTradeExecution(int ticket, double requestedPrice, double filledPrice, int cmd)
{
    if(ticket <= 0) return;

    int fileHandle = FileOpen(logFileName, FILE_READ|FILE_WRITE|FILE_CSV|FILE_ANSI, ",");
    if(fileHandle == INVALID_HANDLE)
    {
        Print("Failed to open slippage log file. Error: ", GetLastError());
        return;
    }

    // Move to end of file to append new records
    FileSeek(fileHandle, 0, SEEK_END);

    // Write headers if the file is newly created
    if(FileSize(fileHandle) == 0)
    {
        FileWrite(fileHandle, "Ticket", "Time", "Symbol", "Side", "Session", "Requested", "Filled", "Slippage_Points");
    }

    string side = (cmd == OP_BUY) ? "Buy" : "Sell";
    string session = GetSession(TimeCurrent());
    double slippage = 0;

    // Calculate slippage in points (positive = bad slippage, negative = positive slippage)
    if(cmd == OP_BUY)
        slippage = (filledPrice - requestedPrice) / Point;
    else if(cmd == OP_SELL)
        slippage = (requestedPrice - filledPrice) / Point;

    FileWrite(fileHandle,
              IntegerToString(ticket),
              TimeToString(TimeCurrent(), TIME_DATE|TIME_MINUTES|TIME_SECONDS),
              Symbol(),
              side,
              session,
              DoubleToString(requestedPrice, Digits),
              DoubleToString(filledPrice, Digits),
              DoubleToString(slippage, 1));

    FileClose(fileHandle);
}

// Determines the session bucket based on execution time
string GetSession(datetime time)
{
    int hour = TimeHour(time);

    if(hour >= LondonStartHour && hour < NYStartHour) return "London";
    if(hour >= NYStartHour && hour < NYEndHour) return "Overlap";
    if(hour >= NYEndHour && hour < 22) return "New York";
    
    return "Asia"; // Catch-all for 22:00 to 08:00 server time
}

Code: Select all

import pandas as pd
import requests

def fetch_economic_calendar():
    # Forex Factory provides a free, public JSON feed for the current week
    url = "https://nfs.faireconomy.media/ff_calendar_thisweek.json"
    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
    
    response = requests.get(url, headers=headers)
    response.raise_for_status()
    
    # Load into a DataFrame and filter for High impact events
    df = pd.DataFrame(response.json())
    high_impact = df[df['impact'] == 'High'].copy()
    
    # The 'date' field includes the timezone offset (e.g., 2026-09-23T08:30:00-04:00)
    # Convert it to a standardized UTC datetime
    high_impact['datetime_utc'] = pd.to_datetime(high_impact['date'], utc=True)
    
    return high_impact

def tag_trade_logs(csv_path, output_path, broker_utc_offset=3, window_minutes=15):
    # Load your MT4 slippage log
    trades = pd.read_csv(csv_path)
    
    # 1. Timezone Normalization
    # MT4 server time is typically EET (UTC+2 in winter, UTC+3 in summer)
    # We must subtract the offset and localize to UTC to match the news calendar
    trades['Time_UTC'] = pd.to_datetime(trades['Time']) - pd.Timedelta(hours=broker_utc_offset)
    trades['Time_UTC'] = trades['Time_UTC'].dt.tz_localize('UTC')
    
    news_df = fetch_economic_calendar()
    
    def apply_tag(row):
        trade_time = row['Time_UTC']
        symbol = str(row['Symbol']) # e.g., "EURUSD"
        
        # 2. Currency Parsing
        # Split symbol into base and quote (EUR and USD)
        base_ccy, quote_ccy = symbol[:3], symbol[3:6]
        
        # Filter the high-impact calendar for events affecting these specific currencies
        relevant_news = news_df[news_df['country'].isin([base_ccy, quote_ccy, 'ALL'])]
        
        # 3. Proximity Check
        for _, event in relevant_news.iterrows():
            time_diff_minutes = abs((trade_time - event['datetime_utc']).total_seconds()) / 60
            
            if time_diff_minutes <= window_minutes:
                return f"News: {event['title']} ({event['country']})"
                
        return "Normal"

    # Apply the tagging logic row by row
    trades['Execution_Context'] = trades.apply(apply_tag, axis=1)
    
    # Clean up and export
    trades = trades.drop(columns=['Time_UTC'])
    trades.to_csv(output_path, index=False)
    print(f"Tagged log saved to {output_path}")

# Example Usage:
# tag_trade_logs("Slippage_Log.csv", "Slippage_Log_Tagged.csv", broker_utc_offset=3, window_minutes=15)

Code: Select all

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

def analyze_slippage(csv_path):
    # Load the tagged execution log
    df = pd.read_csv(csv_path)

    # 1. Standardize the Environment column
    # Converts specific tags like "News: FOMC (USD)" into a broader "News" category
    df['Environment'] = df['Execution_Context'].apply(
        lambda x: 'Normal' if x == 'Normal' else 'News'
    )

    # 2. Calculate Medians and Summary Statistics
    # Group by Session and Environment to isolate the metrics
    summary_stats = df.groupby(['Session', 'Environment'])['Slippage_Points'].agg(
        Trade_Count='count',
        Median_Slippage='median',
        Mean_Slippage='mean',
        Max_Adverse_Tail='max'
    ).round(2).reset_index()

    print("--- Slippage Summary by Session ---")
    print(summary_stats.to_string(index=False))
    print("\n")

    # 3. Generate Comparative Histograms
    sns.set_theme(style="darkgrid")
    
    # Create a faceted grid with one plot per session
    g = sns.displot(
        data=df,
        x='Slippage_Points',
        hue='Environment',
        col='Session',         # Creates a separate chart for Asia, London, and NY Overlap
        kind='hist',
        stat='density',        # Normalizes the area under the curve to 1 for visual comparison
        common_norm=False,     # Calculates density independently for News vs Normal
        bins=30,
        alpha=0.6,
        height=5,
        aspect=1.2,
        palette={'Normal': '#3498db', 'News': '#e74c3c'}
    )

    # Format the charts
    g.set_axis_labels("Slippage (Points)", "Density")
    g.set_titles(col_template="{col_name} Session")
    plt.subplots_adjust(top=0.85)
    g.fig.suptitle('Slippage Shape: Normal vs News Environments', fontsize=16)
    
    # Display the plot
    plt.show()

# Example Usage:
# analyze_slippage("Slippage_Log_Tagged.csv")