Execution at market mid price

Yes, it is possible to model order execution at mid-market. You would need to create a custom ExecutionModel to achieve this. The ExecutionModel class in QuantConnect allows you to customize how orders are executed. You would need to extend this class and implement the Execute method.

Here is a basic scaffolding structure for a custom ExecutionModel in Python:

class MyExecutionModel(ExecutionModel):
    # Fill the supplied portfolio targets efficiently.
    def Execute(self, algorithm, targets):
        # NOP

    # Optional: Securities changes event for handling new securities.
    def OnSecuritiesChanged(self, algorithm, changes):
        # Security additions and removals are pushed here.
        # This can be used for setting up algorithm state.
        # changes.AddedSecurities
        # changes.RemovedSecurities

In the Execute method, you would need to implement your logic for executing orders at the mid-market price.

As for the slippage model, you could potentially use a negative slippage model to simulate the effect of getting filled at mid-market price. However, this might not be the most accurate representation of the market dynamics. It would be better to create a custom ExecutionModel that accurately models your desired behavior.

For more information on creating custom models, you can refer to the QuantConnect documentation.

I've looked through examples of implementations of StandardDeviationExecutionModel.py, VolumeWeightedAveragePriceExecutionModel.py etc, and see that they use Market order execution.  Any hints of how mid-price execution could be implemented or similar examples in the code base? 
 

Based on the information provided in the extracts, there isn't a direct example of implementing mid-price execution. However, you can create a custom ExecutionModel and use the QuoteBar data to calculate the mid-price and place your orders.

Here's a basic example of how you might implement this in Python:

class MidPriceExecutionModel(ExecutionModel):
    def Execute(self, algorithm, targets):
        for target in targets:
            # Get the current QuoteBar for the target security
            quoteBar = algorithm.CurrentSlice[target.Symbol]

            if quoteBar is None:
                continue

            # Calculate the mid price
            mid_price = (quoteBar.Bid.Close + quoteBar.Ask.Close) / 2

            # Place a market order at the mid price
            algorithm.MarketOrder(target.Symbol, target.Quantity, asynchronous=True)

In this example, the Execute method iterates over the portfolio targets. For each target, it retrieves the current QuoteBar for the target security. It then calculates the mid-price as the average of the bid and ask prices. Finally, it places a market order at the mid-price.

Please note that this is a simplified example and may not cover all possible edge cases. For example, it assumes that there is always a valid QuoteBar available for the target security, which may not always be the case. You may need to add additional error checking and handling code to make this robust for a live trading environment.

Also, please note that this code places a market order, not a limit order at the mid-price. The order will be filled at the best available price, not necessarily the mid-price. If you want to ensure that your order is filled at the mid-price, you would need to use a limit order instead. However, keep in mind that a limit order may not be filled immediately if the mid-price is not within the current bid-ask spread.

Could you clarify what it means by “Finally, it places a market order at the mid-price”? I do not see that calculated mid-price is used at all. As I can see just a regular Marker order is placed and the fill will come at the best bid / ask price (given there is enough size quoted)

I apologize for the confusion. You're correct. The provided example does not use the calculated mid-price in the order execution. It was a mistake in the explanation. The MarketOrder method does not take a price argument, and it will execute at the best available price, not at the mid-price.

To execute an order at the mid-price, you would need to use a LimitOrder instead. However, keep in mind that a limit order may not be filled immediately if the mid-price is not within the current bid-ask spread.

Here's how you might modify the example to use a limit order:

class MidPriceExecutionModel(ExecutionModel):
    def Execute(self, algorithm, targets):
        for target in targets:
            # Get the current QuoteBar for the target security
            quoteBar = algorithm.CurrentSlice[target.Symbol]

            if quoteBar is None:
                continue

            # Calculate the mid price
            mid_price = (quoteBar.Bid.Close + quoteBar.Ask.Close) / 2

            # Place a limit order at the mid price
            algorithm.LimitOrder(target.Symbol, target.Quantity, mid_price, asynchronous=True)

In this revised example, the LimitOrder method is used instead of MarketOrder. The LimitOrder method takes an additional argument for the limit price, which is set to the calculated mid-price. This will place a limit order at the mid-price, but as mentioned earlier, it may not be filled immediately if the mid-price is not within the current bid-ask spread.

Is it possible to make immediate execution at mid-price at all? Just presume that the fill price is mid-price?

In real-world trading, it's not guaranteed to have an immediate execution at the mid-price because the mid-price might not be within the current bid-ask spread. However, in a simulation or backtesting environment, you can create a custom FillModel to assume that all orders are filled at the mid-price.

Here's a basic example of how you might implement this in Python:

class MidPriceFillModel(FillModel):
    def MarketFill(self, asset, order):
        # Get the current QuoteBar for the target security
        quoteBar = self.CurrentSlice[order.Symbol]

        if quoteBar is None:
            return OrderEvent(order, self.UtcTime, OrderStatus.Invalid, "No quote bar available")

        # Calculate the mid price
        mid_price = (quoteBar.Bid.Close + quoteBar.Ask.Close) / 2

        # Create an order event with the fill price set to the mid price
        fill = OrderEvent(order, self.UtcTime, OrderStatus.Filled, order.Quantity, mid_price)

        return fill

In this example, the MarketFill method retrieves the current QuoteBar for the order's security and calculates the mid-price. It then creates an OrderEvent with the fill price set to the mid-price.

Please note that this is a simplified example and may not cover all possible edge cases. For example, it assumes that there is always a valid QuoteBar available for the order's security, which may not always be the case. You may need to add additional error checking and handling code to make this robust for a live trading environment.

Also, please note that this model assumes that all market orders are filled immediately at the mid-price, which may not accurately reflect real-world trading conditions. Use this model with caution when backtesting your strategies.

Do I understand correctly that FillModel is set for each security separately? 

I.e. if I have an option I can attach FillModel using self.Securities?

self.index_symbol = self.AddIndex('SPX').Symbol
option = self.AddIndexOption(self.index_symbol, Resolution.Minute)
self.Securities[option.Symbol].SetFillModel(MidPriceFillModel())

Yes, you understand correctly. The FillModel can be set for each security separately. You can use the SetFillModel method on the Security object to set the fill model for a specific security. Your code snippet is correct for setting the MidPriceFillModel for an index option.

Here's the relevant part of your code:

self.Securities[option.Symbol].SetFillModel(MidPriceFillModel())

This line of code sets the MidPriceFillModel for the security identified by option.Symbol.

Remember that you need to define the MidPriceFillModel class in your algorithm. You can refer to the previous example for how to implement a basic MidPriceFillModel.

Also, keep in mind that the FillModel is used by the algorithm to simulate order fills during backtesting. It does not affect live trading. In live trading, order fills are determined by the exchange or broker.

I've added MidPriceFillModel() to the algorithm code, set self.Securities[option.Symbol].SetFillModel(MidPriceFillModel()) and use self.MarketOrder to place the order. However, I still get the execution at best bid / ask for Market Order. I've tried to debug the code and it seems MidPriceFillModel() is never used. Any ideas of what's wrong with the code? 

# region imports
from AlgorithmImports import *
# endregion


class MidPriceFillModel(FillModel):
    def MarketFill(self, asset, order) -> OrderEvent:
        # Get the current QuoteBar for the target security
        quoteBar = self.CurrentSlice[order.Symbol]
        if quoteBar is None:
            return OrderEvent(order, self.UtcTime, OrderStatus.Invalid, "No quote bar available")
        # Calculate the mid price
        mid_price = (quoteBar.Bid.Close + quoteBar.Ask.Close) / 2
        # Create an order event with the fill price set to the mid price
        fill = OrderEvent(order, self.UtcTime, OrderStatus.Filled, order.Quantity, mid_price)
        return fill


class Options(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2021, 1, 4)
        self.SetEndDate(2021, 1, 5)
        self.SetCash(1000000)

        # data = self.AddEquity("SPY", Resolution.Minute)
        # data.SetLeverage(5)
        # self.symbol = data.Symbol
        #
        # option = self.AddOption("SPY", Resolution.Minute)
        # # option.SetFilter(-20, 20, 25, 35)
        self.index_symbol = self.AddIndex('SPX').Symbol
        option = self.AddIndexOption(self.index_symbol, Resolution.Minute)

        self.Securities[option.Symbol].SetFillModel(MidPriceFillModel())
        self.Securities[self.index_symbol].SetFillModel(MidPriceFillModel())

        self.last_day = -1

    def OnData(self, slice: Slice):
        # Check once a day.
        # if self.Time.day == self.last_day:
        #     return
        # self.last_day = self.Time.day

        for i in slice.OptionChains:
            chains = i.Value

            if not self.Portfolio.Invested:
                # divide option chains into call and put options
                calls = list(filter(lambda x: x.Right == OptionRight.Call, chains))
                puts = list(filter(lambda x: x.Right == OptionRight.Put, chains))

                # if lists are empty return
                if not calls or not puts:
                    return

                underlying_price = self.Securities[self.index_symbol].Price
                self.Debug(f'underlying={underlying_price}')

                expiries = [i.Expiry for i in puts]

                # determine expiration date nearly one month
                expiry = min(expiries, key=lambda x: abs((x.date() - self.Time.date()).days - 30))
                strikes = [i.Strike for i in puts]

                # determine at-the-money strike
                strike = min(strikes, key=lambda x: abs(x - underlying_price))

                atm_calls = [i for i in calls if i.Expiry == expiry and i.Strike == strike]
                atm_puts = [i for i in puts if i.Expiry == expiry and i.Strike == strike]

                if atm_calls and atm_puts:
                    self.Debug(f'MarginRemaining={self.Portfolio.MarginRemaining}')

                    options_q = int(self.Portfolio.MarginRemaining / (underlying_price * 100))
                    self.Debug(f'options_q={options_q}')

                    atm_call: OptionContract = atm_calls[0]; atm_put: OptionContract = atm_puts[0]

                    self.Debug(f'atm_call={atm_call} bidPrice={atm_call.BidPrice} askPrice={atm_call.AskPrice}')
                    self.Debug(f'atm_put={atm_put} bidPrice={atm_put.BidPrice} askPrice={atm_put.AskPrice}')

                    # sell at-the-money straddle
                    self.MarketOrder(atm_call.Symbol, -options_q)
                    self.MarketOrder(atm_put.Symbol, -options_q)

                    self.Debug(f'atm_call fill price={self.Portfolio[atm_call.Symbol].AveragePrice}')
                    self.Debug(f'atm_put fill price={self.Portfolio[atm_put.Symbol].AveragePrice}')

managed to do it by implementing

class MidPriceFillModel(FillModel):
    def MarketFill(self, asset, order) -> OrderEvent:
        # Get the current QuoteBar for the target security
        # Calculate the mid price
        mid_price = (asset.BidPrice + asset.AskPrice) / 2.
        # Create an order event with the fill price set to the mid price
        fill = OrderEvent(orderId=order.Id, symbol=order.Symbol, utcTime=order.Time, status=OrderStatus.Filled,
                          direction=order.Direction,
                          fillPrice=mid_price, fillQuantity=order.Quantity, orderFee=OrderFee.Zero)

        return fill