AlgoSeek

from QuantConnect.DataSource import *

future = self.add_future(Futures.metals.gold)
future.set_filter(0, 90)

using QuantConnect.DataSource;

var future = AddFuture(Futures.Metals.Gold);
future.SetFilter(0, 90);

class USFuturesDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2013, 12, 20) 
        self.set_end_date(2014, 2, 20) 
        self.set_cash(1000000) 
        self.universe_settings.asynchronous = True
        future = self.add_future(Futures.metals.gold) 
        future.set_filter(0, 90)
        self.future_symbol = future.symbol

namespace QuantConnect
{
    public class USFuturesDataAlgorithm : QCAlgorithm
    {
        private Symbol _futureSymbol;
        
        public override void Initialize()
        {
            SetStartDate(2013, 12, 20);
            SetEndDate(2014, 2, 20);
            SetCash(1000000);
            UniverseSettings.Asynchronous = True;
            var future = AddFuture(Futures.Metals.Gold);
            future.SetFilter(0, 90);
            _futureSymbol = future.Symbol;
        }
    }
}

def on_data(self, slice: Slice) -> None:
    chain = slice.futures_chains.get(self.future_symbol)
    if chain:
        for contract in chain:
            self.log(f"{contract.symbol} price at {slice.time}: {contract.last_price}")

public override void OnData(Slice slice)
{
    if (slice.FuturesChains.TryGetValue(_futureSymbol, out var chain))
    {
        foreach (var contract in chain)
        {
            Log($"{contract.Symbol} price at {slice.Time}: {contract.LastPrice}");
        }
    }
}

def on_data(self, slice: Slice) -> None:
    for canonical_symbol, chain in slice.futures_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.FuturesChains)
    {
        var canonicalSymbol = kvp.Key;
        var chain = kvp.Value;
        foreach (var contract in chain)
        {
            Log($"{contract.Symbol} price at {slice.Time}: {contract.LastPrice}");
        }
    }
}

# DataFrame objects
contract_history_df = self.history(contract.symbol, 100, Resolution.MINUTE)
continuous_history_df = self.history(self.future_symbol,
    start=self.time - timedelta(days=15), 
    end=self.time, 
    resolution=Resolution.MINUTE, 
    fill_forward=False, 
    extended_market_hours=False,
    dataMappingMode=DataMappingMode.OPEN_INTEREST, 
    dataNormalizationMode=DataNormalizationMode.RAW, 
    contractDepthOffset=0)

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

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

# Tick objects
contract_history_ticks = self.history[Tick](self.symbol, timedelta(seconds=10), Resolution.TICK)
continous_history_ticks = self.history[Tick](self.future_symbol, timedelta(seconds=10), Resolution.TICK)

// TradeBar objects
var contractHistoryTradeBars = History(contract.Symbol, 100, Resolution.Minute);
var continuousHistoryTradeBars = History(
    symbols: new[] {_futureSymbol}, 
    start: Time - TimeSpan.FromDays(15),
    end: Time,
    resolution: Resolution.Minute,
    fillForward: False,
    extendedMarketHours: False,
    dataMappingMode: DataMappingMode.OpenInterest,
    dataNormalizationMode: DataNormalizationMode.Raw,
    contractDepthOffset: 0);

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

// Tick objects
var contractHistoryTicks = History<Tick>(contract.Symbol, TimeSpan.FromSeconds(10), Resolution.Tick);
var continuousHistoryTicks = History<Tick>(_futureSymbol, TimeSpan.FromSeconds(10), Resolution.Tick);

qb = QuantBook()
future = qb.add_future(Futures.metals.gold) 
future.set_filter(0, 90)
history = qb.future_history(future.symbol, datetime(2020, 6, 1), datetime(2020, 6, 5))

all_history = history.get_all_data()
expiries = history.get_expiry_dates()

var qb = new QuantBook();
var future = qb.AddFuture(Futures.Metals.Gold);
future.SetFilter(0, 90);
var history = qb.FutureHistory(future.Symbol, new DateTime(2020, 6, 1), new DateTime(2020, 6, 5));
    
var contracts = history.SelectMany(x => x.OptionChains.SelectMany(y => y.Value.Contracts.Keys)).Distinct().ToList();
var expiries = contracts.Select(x => x.ID.Date).Distinct().ToList();