class USFutureOptionsDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2020, 6, 1)
        self.set_end_date(2021, 6, 1)
        self.set_cash(100000)
        self.universe_settings.asynchronous = True
        
        self.future = self.add_future(Futures.Metals.GOLD, Resolution.MINUTE)
        self.future.set_filter(0, 90)
        # Set our strike/expiry filter for this option chain
        self.add_future_option(self.future.symbol, self._option_filter)

    def on_data(self, slice: Slice) -> None:
        # Get the entire Option chain for the current day.
        symbol = Symbol.create_canonical_option(self.future.mapped)
        chain = self.option_chain(symbol, flatten=True).data_frame

    def _option_filter(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
        # Contracts can be filtered by strike, and expiration
        return universe.strikes(-1, 1)

namespace QuantConnect
{
    public class USFutureOptionsDataAlgorithm : QCAlgorithm
    {
        private Future _future;
        
        public override void Initialize()
        {
            SetStartDate(2020, 6, 1);
            SetEndDate(2021, 6, 1);
            SetCash(100000);
            UniverseSettings.Asynchronous = true;
            
            _future = AddFuture(Futures.Metals.Gold, Resolution.Minute);
            _future.SetFilter(0, 90);
            // Set our strike/expiry filter for this option chain
            AddFutureOption(_future.Symbol, OptionFilter);
        }

        public override void OnData(Slice slice)
        {
            // Create canonical symbol for the mapped future contract, since option chains are mapped by canonical symbol.
            var symbol = QuantConnect.Symbol.CreateCanonicalOption(_future.Mapped);
            // Get the entire Option chain for the current day.
            var chain = OptionChain(symbol);
        }

        private virtual OptionFilterUniverse OptionFilter(OptionFilterUniverse universe)
        {
            // Contracts can be filtered by strike, and expiration
            return universe.Strikes(-1, 1);
        }
    }
}

future_option_symbol = Symbol.create_canonical_option(self.future.mapped)
# DataFrame
history_df = self.history(future_option_symbol, timedelta(10), flatten=True)
# OptionUniverse objects
history = self.history[OptionUniverse](future_option_symbol, timedelta(10))

var futureOptionSymbol = QuantConnect.Symbol.CreateCanonicalOption(_future.Mapped);
var history = History<OptionUniverse>(futureOptionSymbol, TimeSpan.FromDays(10)).ToList();

qb = QuantBook()
future = qb.add_future(Futures.Metals.GOLD, Resolution.MINUTE)
future.set_filter(0, 90)
symbol = Symbol.create_canonical_option(future.mapped)
history = qb.history(symbol, datetime(2020, 6, 1), datetime(2020, 6, 5), flatten=True)

var qb = new QuantBook();
var future = qb.AddFuture(Futures.Metals.Gold, Resolution.Minute);
var symbol = QuantConnect.Symbol.CreateCanonicalOption(future.Mapped);
var history = qb.History<OptionUniverse>(symbol, new DateTime(2020, 6, 1), new DateTime(2020, 6, 6));
foreach (var chain in history)
{
    var endTime = chain.EndTime;
    var filteredContracts = chain.Data
        .Select(contract => contract as OptionUniverse)
        .Where(contract => contract.Greeks.Delta > 0.3m);
    foreach (var contract in filteredContracts)
    {
        var price = contract.Price;
        var iv = contract.ImpliedVolatility;
    }
}

class FutureOptionAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2020,1,1)
        # Filter the underlying continuous Futures to narrow the FOP spectrum.
        self.underlying = self.add_future(Futures.Indices.SP_500_E_MINI,
            extended_market_hours=True,
            data_mapping_mode=DataMappingMode.OPEN_INTEREST,
            data_normalization_mode=DataNormalizationMode.BACKWARDS_RATIO,
            contract_depth_offset=0)
        self.underlying.set_filter(0, 182)
        # Use CallSpread filter to obtain the 2 best-matched contracts that forms a call spread.
        # It simplifies from further filtering and reduce computation on redundant subscription.
        self.add_future_option(self.underlying.symbol, lambda u: u.call_spread(5, 5, -5))
    
    def on_data(self, slice: Slice) -> None:
        if self.portfolio.invested:
            return
        # Create canonical symbol for the mapped future contract, since we need that to access the option chain.
        symbol = Symbol.create_canonical_option(self.underlying.mapped)
    
        # Get option chain data for the mapped future only.
        # It requires 2 contracts with different strikes to form a call spread, so we make sure at least 2 contracts are present.
        chain = slice.option_chains.get(symbol)
        if not chain or len(list(chain)) < 2:
            return
            
        # Separate the contracts by strike, as we need to access their strike.
        expiry = min([x.expiry for x in chain])
        sorted_by_strike = sorted([x.strike for x in chain])
        itm_strike = sorted_by_strike[0]
        otm_strike = sorted_by_strike[-1]
        
        # Use abstraction method to order a bull call spread to avoid manual error.
        option_strategy = OptionStrategies.bull_call_spread(symbol, itm_strike, otm_strike, expiry)
        self.buy(option_strategy, 1)

public class FutureOptionAlgorithm : QCAlgorithm
{
    private Future _underlying;

    public override void Initialize()
    {
        SetStartDate(2020,1,1);
        // Filter the underlying continuous Futures to narrow the FOP spectrum.
        _underlying = AddFuture(Futures.Indices.SP500EMini,
            extendedMarketHours: true,
            dataMappingMode: DataMappingMode.OpenInterest,
            dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
            contractDepthOffset: 0);
        _underlying.SetFilter(0, 182);
        // Use CallSpread filter to obtain the 2 best-matched contracts that forms a call spread.
        // It simplifies from further filtering and reduce computation on redundant subscription.
        AddFutureOption(_underlying.Symbol, (u) => u.CallSpread(5, 5, -5));
    }
    
    public override void OnData(Slice slice)
    {
        if (Portfolio.Invested)
            return;

        // Create canonical symbol for the mapped future contract, since we need that to access the option chain.
        var symbol = QuantConnect.Symbol.CreateCanonicalOption(_underlying.Mapped);
    
        // Get option chain data for the mapped future only.
        // It requires 2 contracts with different strikes to form a call spread, so we make sure at least 2 contracts are present.
        if (!slice.OptionChains.TryGetValue(symbol, out var chain) || chain.Count() < 2)
            return;
    
        // Separate the contracts by strike, as we need to access their strike.
        var expiry = chain.Min(x => x.Expiry);
        var itmStrike = chain.Min(x => x.Strike);
        var otmStrike = chain.Max(x => x.Strike);
    
        // Use abstraction method to order a bull call spread to avoid manual error.
        var optionStrategy = OptionStrategies.BullCallSpread(symbol, itmStrike, otmStrike, expiry);
        Buy(optionStrategy, 1);
    }
}