modeling slippage the right way

import numpy as np
import pandas as pd
from datetime import datetime

class DynamicSlippageModel:
    """
    Models realistic slippage for SPX credit spreads based on:
    - Bid-ask spread width
    - Time of day
    - VIX level (volatility)
    - Days to expiration
    """

    def __init__(self):
        # historical fill data from live trading
        self.fill_history = []
        self.bid_ask_history = []

    def estimate_slippage(self, option_price, dte, vix_level, time_of_day):
        """
        Estimate slippage for a single option leg

        Args:
            option_price: Mid price of option
            dte: Days to expiration
            vix_level: Current VIX reading
            time_of_day: Hour (0-23)

        Returns:
            Estimated slippage in dollars
        """
        # base slippage is function of option price
        # cheaper options have wider relative spreads
        if option_price < 0.50:
            base_slippage = 0.03
        elif option_price < 1.00:
            base_slippage = 0.04
        elif option_price < 2.00:
            base_slippage = 0.05
        else:
            base_slippage = 0.06

        # adjust for DTE (closer to expiration = wider spreads)
        if dte <= 2:
            dte_multiplier = 1.5
        elif dte <= 5:
            dte_multiplier = 1.2
        else:
            dte_multiplier = 1.0

        # adjust for VIX (high vol = wider spreads)
        if vix_level > 30:
            vix_multiplier = 1.4
        elif vix_level > 20:
            vix_multiplier = 1.2
        else:
            vix_multiplier = 1.0

        # adjust for time of day
        # 9:30-10:30 AM EST has tightest spreads (high volume)
        # after 3pm spreads widen
        if 9 <= time_of_day <= 10:  # 9:30-10:30 EST
            time_multiplier = 1.0
        elif 15 <= time_of_day <= 16:  # 3pm-4pm EST
            time_multiplier = 1.3
        else:
            time_multiplier = 1.15

        # calculate total slippage
        slippage = base_slippage * dte_multiplier * vix_multiplier * time_multiplier

        return slippage

    def record_fill(self, expected_price, actual_price, bid_ask_width,
                    dte, vix, time_of_day):
        """
        Record actual fill for model improvement
        """
        fill_data = {
            'timestamp': datetime.now(),
            'expected': expected_price,
            'actual': actual_price,
            'slippage': expected_price - actual_price,
            'bid_ask_width': bid_ask_width,
            'dte': dte,
            'vix': vix,
            'time': time_of_day
        }
        self.fill_history.append(fill_data)

    def get_average_slippage(self, lookback_trades=20):
        """
        Calculate average slippage from recent fills
        """
        if len(self.fill_history) < lookback_trades:
            return 0.05  # default assumption

        recent = self.fill_history[-lookback_trades:]
        slippages = [f['slippage'] for f in recent]
        return np.mean(slippages)

    def backtest_with_slippage(self, trades_df):
        """
        Apply slippage model to backtest trades

        Args:
            trades_df: DataFrame with columns [entry_price, exit_price,
                       dte_entry, dte_exit, vix_entry, vix_exit, time_entry, time_exit]

        Returns:
            DataFrame with slippage-adjusted returns
        """
        results = []

        for idx, trade in trades_df.iterrows():
            # entry slippage (we're selling, so we get worse price)
            entry_slip = self.estimate_slippage(
                trade['entry_price'],
                trade['dte_entry'],
                trade['vix_entry'],
                trade['time_entry']
            )

            # exit slippage (we're buying back, so we pay more)
            exit_slip = self.estimate_slippage(
                trade['exit_price'],
                trade['dte_exit'],
                trade['vix_exit'],
                trade['time_exit']
            )

            # calculate adjusted P&L
            # for credit spreads: profit = entry_price - exit_price
            theoretical_pnl = trade['entry_price'] - trade['exit_price']
            actual_pnl = (trade['entry_price'] - entry_slip) - (trade['exit_price'] + exit_slip)

            results.append({
                'trade_id': idx,
                'theoretical_pnl': theoretical_pnl,
                'actual_pnl': actual_pnl,
                'slippage_cost': theoretical_pnl - actual_pnl,
                'entry_slip': entry_slip,
                'exit_slip': exit_slip
            })

        return pd.DataFrame(results)


# integration with backtrader strategy
class SPXCreditSpreadWithSlippage(bt.Strategy):
    """
    Original strategy with realistic slippage modeling
    """

    def __init__(self):
        super().__init__()
        self.slippage_model = DynamicSlippageModel()

    def next(self):
        # ... strategy logic ...

        # when placing order, estimate slippage
        current_vix = self.get_vix()
        current_hour = self.datas[0].datetime.datetime(0).hour
        dte = self.get_dte_for_target()

        theoretical_credit = self.calculate_spread_price(short_strike, long_strike)

        # estimate slippage for both legs
        short_slippage = self.slippage_model.estimate_slippage(
            short_price, dte, current_vix, current_hour
        )
        long_slippage = self.slippage_model.estimate_slippage(
            long_price, dte, current_vix, current_hour
        )

        # adjust expected fill
        expected_credit = theoretical_credit - short_slippage - long_slippage

        # place order with adjusted expectations
        self.sell_spread(short_strike, long_strike, expected_credit)

    def notify_trade(self, trade):
        """
        Record actual fills for model improvement
        """
        if trade.isclosed:
            # extract actual fill prices and record
            self.slippage_model.record_fill(
                expected_price=trade.price,
                actual_price=trade.executed.price,
                bid_ask_width=self.get_bid_ask_width(),
                dte=self.get_current_dte(),
                vix=self.get_vix(),
                time_of_day=self.get_hour()
            )