class InternationalFuturesDataAlgorithm(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
        self._future = self.add_future(Futures.Indices.HANG_SENG)
        # Set our contract filter for this Future chain.
        self._future.set_filter(lambda universe: universe.standards_only().front_month())
        # Get the entire Futures chain for the current day.
        chain = self.futures_chain(self._future.symbol, flatten=True).data_frame

public class InternationalFuturesDataAlgorithm : QCAlgorithm
{
    private Future _future;
        
    public override void Initialize()
    {
        SetStartDate(2013, 12, 20);
        SetEndDate(2014, 2, 20);
        SetCash(1000000);
        UniverseSettings.Asynchronous = true;
        var future = AddFuture(Futures.Indices.HangSeng);
        // Set our contract filter for this Future chain.
        _future.SetFilter((universe) => universe.StandardsOnly().FrontMonth());
        // Get the entire Futures chain for the current day.
        var chain = FuturesChain(_future.Symbol);
    }
}

# Subscribe to the underlying Future and save a reference to the Symbol.
symbol = self.add_future(Futures.Indices.HANG_SENG).symbol
# Get the contracts available on this day.
contracts = [x.symbol for x in self.futures_chain(symbol)]

# Request the historical data to obtain the data.
# DataFrame objects
history_df = self.history(contracts, 10, Resolution.DAILY, flatten=True)
open_interest = self.history(OpenInterest, contracts, 10, Resolution.DAILY, flatten=True)

# Open Interest objects
open_interest = self.history[OpenInterest](contracts, 10, Resolution.DAILY)

// Subscribe to the underlying Future and save a reference to the Symbol.
var symbol = AddFuture(Futures.Indices.HangSeng).Symbol
// Get the contracts available on this day.
var contracts = contracts = FuturesChain(symbol).Select(x => x.Symbol).ToList();

// Request the historical data to obtain the data.
// Slice objects
var history = History(contracts, 10, Resolution.Daily);

// Open Interest objects
var openInterest = History<OpenInterest>(contracts, 10, Resolution.Daily);

qb = QuantBook()
future = qb.add_future(Futures.Indices.HANG_SENG) 
future.set_filter(0, 90)
history = qb.future_history(future.symbol, datetime(2020, 6, 1), datetime(2020, 6, 5), Resolution.DAILY)
history_df = history.data_frame
all_history = history.get_all_data()
expiries = history.get_expiry_dates()

var qb = new QuantBook();
var future = qb.AddFuture(Futures.Indices.HangSeng);
future.SetFilter(0, 90);
var history = qb.FutureHistory(future.Symbol, new DateTime(2020, 6, 1), new DateTime(2020, 6, 5));

qb = QuantBook()
end = datetime(2020, 6, 5)
qb.set_start_date(end)
symbol = qb.add_future(Futures.Indices.HANG_SENG).symbol
# Get the contracts available on this day.
contracts = [x.symbol for x in qb.futures_chain(symbol)]

# Request the historical data to obtain the data.
history_df = qb.history(contracts, datetime(2020, 6, 1), end, Resolution.DAILY, flatten=True)
open_interest = qb.history(OpenInterest, contracts, datetime(2020, 6, 1), end, Resolution.DAILY, flatten=True)

var qb = new QuantBook();
var end = new DateTime(2020, 6, 5);
qb.SetStartDate(end)
var future = qb.AddFuture(Futures.Indices.HangSeng);
// Get the contracts available on the day.
var contracts = qb.FuturesChain(future.Symbol).Select(x => x.Symbol);

// Request the historical data to obtain the data.
var history = qb.History(contracts, new DateTime(2020, 6, 1), end, Resolution.Daily);
var openInterest = qb.History<OpenInterest>(contracts, new DateTime(2020, 6, 1), end, Resolution.Daily);

class InternationalFuturesDataAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2021, 7, 1)
        # Set the time zone to HKT to make it more comparable with the exchange.
        self.set_time_zone(TimeZones.HONG_KONG)
        # Set the account currency as HKD to trade HSI Futures.
        self.set_account_currency("HKD", 1000000)
        # Seed the last price of the contracts for filling.
        self.set_security_initializer(BrokerageModelSecurityInitializer(self.brokerage_model, FuncSecuritySeeder(self.get_last_known_prices)))

        # Request HSI Futures to trade. 
        # Note that we will trade the contract with the highest open interest for liquidity.
        self.hsi_future = self.add_future(
            Futures.Indices.HANG_SENG,
            extended_market_hours=True,
            data_mapping_mode=DataMappingMode.LAST_TRADING_DAY,
            contract_depth_offset=0
        )
        # Adds contracts that expiry within 90 days. We will trade the farthest contract
        self.hsi_future.set_filter(0,90)
        # Request the corresponding underlying Index for feeding indicator for trade signal generation.
        hsi_index = self.add_index("HSI").symbol

        # Create a ZigZag indicator to trade Hang Seng Index price pivot points.
        self._zz = self.zz(hsi_index, 0.15, 5, Resolution.DAILY)
        # Warm up indicator for immediate readiness to trade.
        self.warm_up_indicator(hsi_index, self._zz, Resolution.DAILY)

    def on_data(self, slice: Slice) -> None:
        # Only place trade if the Future contracts is in market opening hours to avoid stale fills.
        if self.is_market_open(self.hsi_future.symbol) and self._zz.is_ready:
            pivot = self._zz.pivot_type
            # If the last pivot point is a low point, the current trend is increasing after this low point.
            if pivot == PivotPointType.LOW:
                contracts = sorted([x.symbol for x in slice.future_chains.get(self.hsi_future.symbol)],
                    key=lambda x: x.id.date)
                self.set_holdings(contracts[-1], 0.2)
            # If the last pivot point is a high point, the current trend is decreasing after this high point.
            if pivot == PivotPointType.HIGH:
                contracts = sorted([x.symbol for x in slice.future_chains.get(self.hsi_future.symbol)],
                    key=lambda x: x.id.date)
                self.set_holdings(contracts[-1], -0.2)

public class InternationalFuturesDataAlgorithm : QCAlgorithm
{
    private Future _hsiFuture;
    private ZigZag _zz;

    public override void Initialize()
    {
        SetStartDate(2021, 1, 1);
        SetEndDate(2021, 7, 1);
        // Set the time zone to HKT to make it more comparable with the exchange.
        SetTimeZone(TimeZones.HongKong);
        // Set the account currency as HKD to trade HSI Futures.
        SetAccountCurrency("HKD", 1000000);

        // Seed the last price of the contracts for filling.
        SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));

        // Request HSI Futures to trade. 
        // Note that we will trade the contract with the highest open interest for liquidity.
        _hsiFuture = AddFuture(
            Futures.Indices.HangSeng,
            extendedMarketHours: true,
            dataMappingMode: DataMappingMode.LastTradingDay,
            contractDepthOffset: 0
        );
        // Adds contracts that expiry within 90 days. We will trade the farthest contract
        _hsiFuture.SetFilter(0,90);
        // Request the corresponding underlying index for feeding indicators for trade signal generation.
        var hsiIndex = AddIndex("HSI").Symbol;

        // Create a ZigZag indicator to trade Hang Seng Index price pivot points.
        _zz = ZZ(hsiIndex, 0.15m, 5, Resolution.Daily);
        // Warm up indicator for immediate readiness to trade.
        WarmUpIndicator(hsiIndex, _zz, Resolution.Daily);
    }

    public override void OnData(Slice slice)
    {
        // Only place trade if the Future contracts is in market opening hours to avoid stale fills.
        if (IsMarketOpen(_hsiFuture.Symbol) && _zz.IsReady)
        {
            var pivot = _zz.PivotType;
            FuturesChain chain;
            // If the last pivot point is low, the current trend is increasing after this low point.
            if (pivot == PivotPointType.Low && slice.FutureChains.TryGetValue(_hsiFuture.Symbol, out chain))
            {
                var contract = chain.OrderBy(x => x.Expiry).LastOrDefault()?.Symbol;                    
                SetHoldings(contract, 0.2m);
            }
            // If the last pivot point is high, the current trend decreases after this high point.
            if (pivot == PivotPointType.High && slice.FutureChains.TryGetValue(_hsiFuture.Symbol, out chain))
            {
                var contract = chain.OrderBy(x => x.Expiry).LastOrDefault()?.Symbol;                    
                SetHoldings(contract, -0.2m);
            }
        }
    }
}