Trade Fills

public override void Initialize()
{
    var security = AddEquity("SPY");
    // Set the fill model for the requested security to backtest with the most realistic scenario
    // ImmediateFillModel provide no delay from network issue or brokerage rules
    security.SetFillModel(new ImmediateFillModel());
}

def initialize(self) -> None:
    security = self.add_equity("SPY")
    # Set the fill model for the requested security to backtest with the most realistic scenario
    # ImmediateFillModel provide no delay from network issue or brokerage rules
    security.set_fill_model(ImmediateFillModel())

public class BrokerageModelExampleAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        // In the Initialize method, set the security initializer to seed initial the prices and models of assets.
        SetSecurityInitializer(new MySecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));
    }
}

public class MySecurityInitializer : BrokerageModelSecurityInitializer
{
    public MySecurityInitializer(IBrokerageModel brokerageModel, ISecuritySeeder securitySeeder)
        : base(brokerageModel, securitySeeder) {}    
    public override void Initialize(Security security)
    {
        // First, call the superclass definition.
        // This method sets the reality models of each security using the default reality models of the brokerage model.
        base.Initialize(security);

        // Next, overwrite some of the reality models
        security.SetFillModel(new ImmediateFillModel());    }
}

class BrokerageModelExampleAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        # In the Initialize method, set the security initializer to seed initial the prices and models of assets.
        self.set_security_initializer(MySecurityInitializer(self.brokerage_model, FuncSecuritySeeder(self.get_last_known_prices)))

# Outside of the algorithm class
class MySecurityInitializer(BrokerageModelSecurityInitializer):

    def __init__(self, brokerage_model: IBrokerageModel, security_seeder: ISecuritySeeder) -> None:
        super().__init__(brokerage_model, security_seeder)    
    def initialize(self, security: Security) -> None:
        # First, call the superclass definition.
        # This method sets the reality models of each security using the default reality models of the brokerage model.
        super().initialize(security)

        # Next, overwrite some of the reality models
        security.set_fill_model(ImmediateFillModel())

public class CustomFillModelExampleAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        // In the Initialize method, set the custom fill model for an added security to use the custom model
        var security = AddEquity("SPY");
        security.SetFillModel(new MyFillModel());
    }
}

// Define the custom fill model outside of the algorithm
public class MyFillModel : FillModel {

    public override OrderEvent MarketFill(Security asset, MarketOrder order) {
        return base.MarketFill(asset, order);
    }

    public override OrderEvent LimitFill(Security asset, LimitOrder order) {
        return base.LimitFill(asset, order);
    }

    public override OrderEvent LimitIfTouchedFill(Security asset, LimitIfTouchOrder order) {
        return base.LimitIfTouchedFill(asset, order);
    }

    public override OrderEvent StopMarketFill(Security asset, StopMarketOrder order) {
        return base.StopMarketFill(asset, order);
    }

    public override OrderEvent StopLimitFill(Security asset, StopLimitOrder order) {
        return base.StopLimitFill(asset, order);
    }

    public override OrderEvent TrailingStopFill(Security asset, TrailingStopOrder order) {
	    return TrailingStopFill(asset, order);
    }

    public override OrderEvent MarketOnOpenFill(Security asset, MarketOnOpenOrder order) {
        return base.MarketOnOpenFill(asset, order);
    }

    public override OrderEvent MarketOnCloseFill(Security asset, MarketOnCloseOrder order) {
        return base.MarketOnCloseFill(asset, order);
    }

    public override List<OrderEvent> ComboMarketFill(Order order, FillModelParameters parameters) {
        return base.ComboMarketFill(order, parameters);
    }

    public override List<OrderEvent> ComboLimitFill(Order order, FillModelParameters parameters) {
        return base.ComboLimitFill(order, parameters);
    }

    public override List<OrderEvent> ComboLegLimitFill(Order order, FillModelParameters parameters) {
        return base.ComboLegLimitFill(order, parameters);
    }
}

class CustomFillModelExampleAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        # In the Initialize method, set the custom fill model for an added security to use the custom model
        security = self.add_equity("SPY")
        security.set_fill_model(MyFillModel())

# Define the custom fill model outside of the algorithm
class MyFillModel(FillModel):

    def market_fill(self, asset: Security, order: MarketOrder) -> OrderEvent:
        return super().market_fill(asset, order)

    def limit_fill(self, asset: Security, order: LimitOrder) -> OrderEvent:
        return super().limit_fill(asset, order)

    def limit_if_touched_fill(self, asset: Security, order: LimitIfTouchedOrder) -> OrderEvent:
        return super().limit_if_touched_fill(asset, order)

    def stop_market_fill(self, asset: Security, order: StopMarketOrder) -> OrderEvent:
        return super().stop_market_fill(asset, order)

    def stop_limit_fill(self, asset: Security, order: StopLimitOrder) -> OrderEvent:
        return super().stop_limit_fill(asset, order)

    def trailing_stop_fill(self, asset: Security, order: TrailingStopOrder) -> OrderEvent:
        return super().trailing_stop_fill(asset, order)

    def market_on_open_fill(self, asset: Security, order: MarketOnOpenOrder) -> OrderEvent:
        return super().market_on_open_fill(asset, order)

    def market_on_close_fill(self, asset: Security, order: MarketOnCloseOrder) -> OrderEvent:
        return super().market_on_close_fill(asset, order)

    def combo_market_fill(self, order: Order, parameters: FillModelParameters) -> List[OrderEvent]:
        return super().combo_market_fill(order, parameters)
    
    def combo_limit_fill(self, order: Order, parameters: FillModelParameters) -> List[OrderEvent]:
        return super().combo_limit_fill(order, parameters)
    
    def combo_leg_limit_fill(self, order: Order, parameters: FillModelParameters) -> List[OrderEvent]:
        return super().combo_leg_limit_fill(order, parameters)