To implement an option filter with two strike price ranges for call options, you can use the set_filter method in the initialize method of your algorithm. Here's how you can set up the filter function to achieve your goal:

1. Initialize the Algorithm: In the initialize method, add the equity and option for which you want to filter the option contracts.

2. Set Data Normalization Mode: Ensure the equity data normalization mode is set to RAW to handle options data correctly.

3. Add Option and Set Filter: Add the option to your algorithm and use the set_filter method to apply your custom filter function.

4. Define the Filter Function: Implement the filter_function to filter the option universe based on your specific strike price ranges.

5. Filter Call Options: Use the calls_only() method to select only call options.

6. Apply Strike Price Ranges: Use the contracts method with a lambda function to filter contracts based on the desired strike price ranges relative to the underlying price.

7. Return Filtered Universe: Ensure the filter function returns the filtered OptionFilterUniverse.

Here's a sample implementation of the filter function:

def filter_function(universe: OptionFilterUniverse) -> OptionFilterUniverse:
    current_equity_price = universe.underlying.price
    return universe.calls_only().contracts(lambda contracts: [
        contract for contract in contracts
        if (0.7 * current_equity_price <= contract.strike <= 0.8 * current_equity_price) or
           (1.03 * current_equity_price <= contract.strike <= 1.05 * current_equity_price)
    ])

Complete Example

class MySpreadOptionAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2023, 1, 1)
        self.set_end_date(2023, 12, 31)
        self.set_cash(100000)
        equity = self.add_equity("SOME EQUITY SYMBOL", Resolution.HOUR)
        equity.set_data_normalization_mode(DataNormalizationMode.RAW)
        self.symbol_equity = equity.symbol
        option = self.add_option(self.symbol_equity, Resolution.HOUR)
        option.set_filter(self.filter_function)
    def filter_function(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
        current_equity_price = universe.underlying.price
        return universe.calls_only().contracts(lambda contracts: [
            contract for contract in contracts
            if (0.7 * current_equity_price <= contract.strike <= 0.8 * current_equity_price) or
               (1.03 * current_equity_price <= contract.strike <= 1.05 * current_equity_price)
        ])
+ Expand
- Collapse

This setup will filter the option chain to include only call options with strike prices within the specified ranges relative to the underlying stock price.

Sources: Index Options - QuantConnect.com, Equity Options - QuantConnect.com, Universes - QuantConnect.com, Universes - QuantConnect.com, Basic Template Options Filter Universe Algorithm

Hello,

Mia emailed me a solution to this question that does not work. Mia's solution is:

    def filter_function(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
            current_equity_price = universe.underlying.price
            return universe.calls_only().contracts(lambda contracts: [
                contract for contract in contracts
                if (0.7 * current_equity_price <= contract.strike <= 0.8 * current_equity_price) or
                (1.03 * current_equity_price <= contract.strike <= 1.05 * current_equity_price)
            ])

This solution throws the error:

'OptionUniverse' object has no attribute 'strike' because the parameter to the lambda function is NOT a list of OptionContract instances, but, rather, an list of OptionUniverse instances.

The documentation indicates that .contracts takes as its parameter a callable with one parameter. Some of the documentation says that its a list of Symbols, other documentation says its a single OptionContract.

This makes no sense to me.

I am not the first person to algorithmically trade option spreads. This seems like a trivial request and the answer should not be this difficult.

Can anyone provide an feasible solution?