AlgoSeek

from QuantConnect.DataSource import *

future = self.add_future(Futures.metals.gold, Resolution.MINUTE)
future.set_filter(0, 90)
self.add_future_option(future.symbol, lambda universe: universe.strikes(-5, +5))

using QuantConnect.DataSource;

var future = AddFuture(Futures.Metals.Gold, Resolution.Minute);
future.SetFilter(0, 90);
AddFutureOption(future.Symbol, universe => universe.Strikes(-5, +5));

class FutureOptionDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2020, 1, 28)
        self.set_end_date(2020, 6, 1)
        self.set_cash(100000)
        self.universe_settings.asynchronous = True
        future = self.add_future(Futures.metals.gold, Resolution.MINUTE)
        future.set_filter(0, 90)
        self.add_future_option(future.symbol, lambda universe: universe.strikes(-5, +5))

namespace QuantConnect
{
    public class FutureOptionDataAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2020, 1, 28);
            SetEndDate(2020, 6, 1);
            SetCash(100000);
            UniverseSettings.Asynchronous = True;
            var future = AddFuture(Futures.Metals.Gold, Resolution.Minute);
            future.SetFilter(0, 90);
            AddFutureOption(future.Symbol, universe => universe.Strikes(-5, +5));
        }
    }
}

def on_data(self, slice: Slice) -> None:
    for canonical_fop_symbol, chain in slice.option_chains.items():
        for contract in chain:
            self.log(f"{contract.symbol} price at {slice.time}: {contract.last_price}")

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.OptionChains)
    {
        var canonicalFOPSymbol = kvp.Key;
        var chain = kvp.Value;
        foreach (var contract in chain)
        {
            Log($"{contract.Symbol} price at {slice.Time}: {contract.LastPrice}");
        }
    }
}

def on_data(self, slice: Slice) -> None:
    for continuous_future_symbol, futures_chain in slice.futures_chains.items():
        # Select a Future Contract and create its canonical FOP Symbol
        futures_contract = [contract for contract in futures_chain][0]
        canonical_fop_symbol = Symbol.create_canonical_option(futures_contract.symbol)
        option_chain = slice.option_chains.get(canonical_fop_symbol)
        if option_chain:
            for fop_contract in option_chain:
                 self.log(f"{fop_contract.symbol} price at {slice.time}: {fop_contract.last_price}")

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.FuturesChains)
    {
        var continuousContractSymbol = kvp.Key;
        var futuresChain = kvp.Value;
        
        // Select a Future Contract and create its canonical FOP Symbol
        var futuresContract = futuresChain.First();
        var canonicalFOPSymbol = QuantConnect.Symbol.CreateCanonicalOption(futuresContract.Symbol);
        if (slice.OptionChains.TryGetValue(canonicalFOPSymbol, out var optionChain))
        {
            foreach (var fopContract in optionChain)
            {
                Log($"{fopContract.Symbol} price at {slice.Time}: {fopContract.LastPrice}");
            }
        }
    }
}

# DataFrame
history_df = self.history(contract.symbol, 100, Resolution.MINUTE)

# TradeBar objects
history_trade_bars = self.history[TradeBar](contract.symbol, 100, Resolution.MINUTE)

# QuoteBar objects
history_quote_bars = self.history[QuoteBar](contract.symbol, 100, Resolution.MINUTE)

// TradeBar objects 
var historyTradeBars = History(contract.Symbol, 100, Resolution.Minute);

// QuoteBar objects 
var historyQuoteBars = History<QuoteBar>(contract.Symbol, 100, Resolution.Minute);

qb = QuantBook()
future = qb.add_future(Futures.indices.SP500EMini, Resolution.MINUTE)
future_symbols = qb.future_chain_provider.get_future_contract_list(future.symbol, datetime(2021, 12, 20))
future_contract_symbol = sorted(future_symbols, key=lambda s: s.id.date)[0]

start_time = datetime(2021, 12, 1)
end_time = datetime(2021, 12, 10)
option_history = qb.option_history(future_contract_symbol, start_time, end_time, Resolution.MINUTE)

all_history = option_history.get_all_data()
expiries = option_history.get_expiry_dates() 
strikes = option_history.get_strikes()

var qb = new QuantBook();
var future = qb.AddFuture(Futures.Indices.SP500EMini, Resolution.Minute);
var futureSymbols = qb.FutureChainProvider.GetFutureContractList(future.Symbol, new DateTime(2021, 12, 20));
var futureContractSymbol = futureSymbols.OrderBy(x => x.ID.Date).First();
    
var startTime = new DateTime(2021, 12, 1);
var endTime = new DateTime(2021, 12, 10);
var optionHistory = qb.OptionHistory(futureContractSymbol, startTime, endTime, Resolution.Minute);

var contracts = optionHistory.SelectMany(x => x.OptionChains.SelectMany(y => y.Value.Contracts.Keys)).Distinct().ToList();
var expiries = contracts.Select(x => x.ID.Date).Distinct().ToList();
var strikes = contracts.Select(x => x.ID.StrikePrice).Distinct().ToList();