Continuous Futures Support

Jared Broad Martin Molinero 

But what actually will be bought when buying this canonical contract when using it on live trading?

And if the “oldest” contract will be bought, what happens if it's bought and during the holding period- the contract will be rolled/expired (again, asking on live trading)?

Excellent feature addition, it has eliminated a lot of headache for me. I was able to delete several hundred lines of code. 

Though, I wish following flag was supported by AddFutures:

Auto_roll_forward = True | False

I also suggest the following flags should be supported by indicators (important for live trading):

Auto_update_for_splits 

Auto_update_for_dividends

Auto_update_for_continuous_futures_symbol_change

Also, it will be awesome if you could bring similar type of complexity reduction in options. My first hand experience dealing with futures leads me to guesstimate tat continuous futures has led to 10x complexity reduction.

Hi,

regarding “The implementation that creates the mappings and factors is closed source at the moment sorry, the implementation that applies the factors and mappings is part of Lean itself, can see this with more detail in the linked PR.”, 

Is this closed source software installed in local lean installations, or it only works on the cloud? 

Are there other closed source components in the local lean installation?

Does the margin calculation support spread credits, as per CME SPAN calculator, or it only adds the out-rights margins? I am talking about any spread for which there is a SPAN credit, only exchange traded spreads. This is quite important also in live trading.

Thanks

could you provide one example for research env?

how to GetFutureHistory for continuous future contract?

thanks.

below code does not work.

qb = QuantBook()
es = qb.AddFuture(Futures.Energies.CrudeOilWTI,
                                                 dataNormalizationMode = DataNormalizationMode.BackwardsRatio,
                                                 dataMappingMode = DataMappingMode.OpenInterest,
                                                 contractDepthOffset = 0)
start_time = datetime(2021, 6, 18, 10, 30) 
end_time = datetime(2099, 7, 16, 16, 0) 
future_history = es.GetFutureHistory(es.Symbol, start_time, end_time)
history = future_history.GetAllData()
history

Hi Livermore,We recommend using the following: 

qb = QuantBook()
qb.SetStartDate(2019,1,1)
qb.SetEndDate(21,6,1)
es = qb.AddFuture(Futures.Energies.CrudeOilWTI,
                                                 dataNormalizationMode = DataNormalizationMode.BackwardsRatio,
                                                 dataMappingMode = DataMappingMode.OpenInterest,
                                                 contractDepthOffset = 0)
history = qb.History(es.Symbol,500,Resolution.Minute)
history

Refer to the attached notebook,Note that currently the default is es.SetFilter(0,0) therefore GetFutureHistory will not return any data. We can also use es.SetFilter(0,180) as an alternative to above.Best,Varad Kabade

Martin Molinero 

Regarding: “LastTradingDay: The contract maps on the previous day of expiration of the front month.”

I am not a future expert. But if I understand correctly, for physically settled contracts, such as gold (GC) and silver (si), brokers will close positions before the first notice date, which is usually 1 month before the last trade date. When the ticker is remapped using LastTradingDay, does it use the last trade date or the first notice date in the code?

Can someone give an example of how the data consolidation should be done with the continuous future price? For example, consolidating data into 15 minutes per bar. 

Do we still do the old way of consolidating future data like documented here? If not, what is the proper way to consolidate data?

I tried the following and it doesn't work out. I only get one-period data feed on 2021-12-26 18:15:00 from OnDataConsolidated. That is the first 15 min bar. After that, there is no log produced. 

from datetime import timedelta
from AlgorithmImports import *


class FutureAlgo(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2021, 12, 25)
        self.SetEndDate(2021, 12, 31)
        self.SetCash(60000)
        self.SetTimeZone("America/New_York")
        self.es = self.AddFuture(
            Futures.Indices.SP500EMini, dataNormalizationMode=DataNormalizationMode.Raw, dataMappingMode=DataMappingMode.OpenInterest, contractDepthOffset=0)
        consolidator = TradeBarConsolidator(timedelta(minutes=15))
        consolidator.DataConsolidated += self.OnDataConsolidated
        self.SubscriptionManager.AddConsolidator(self.es.Symbol, consolidator)

    def OnData(self, data: Slice):
        for changedEvent in data.SymbolChangedEvents.Values:
            if changedEvent.Symbol == self.es.Symbol:
                self.Log(f"SymbolChanged event: {changedEvent}")

    def OnDataConsolidated(self, sender, bar: TradeBar):
        self.Debug(bar.Symbol)

Hey Xinmin Cai !

Sorry for the delay. The code snippet you shared does work correctly, I'm attaching a backtest using it successfully.

Martin Molinero Thanks, Martin! 

A follow-up question on this. If I specify fillDataForward=False in the self.AddFuture() call, does it work? I changed this but it feels there is no data coming through. 

I am doing this is because I got a fill on a stale price. I want to make sure, my algo doesn't fill on stale price. 

Appreciate the help!

Xinmin Cai re first notice date: I don't think the dataset that QuantConnect has for futures includes first notice dates, I've asked them about this before and I ended up contacting AlgoSeek and I'm pretty sure AlgoSeek doesn't have first notice dates. Martin Molinero any comment on this?

Hi Richard Thomas Harrison,
For now, all futures are cash-settled as we don't allow underlying (Live Cattle?) to be posted on the account, thus the FDN is not required (and we don't support this element).

Best,

Varad Kabade

Is anyone else able to get tick level data in the research notebook? I can get second and minute level, but despite defining a time period or a specific bar count, I only get error messages like this:

NullReferenceException: Object reference not set to an instance of an object.

Hi Ariel Nechemia,
Unfortunately, we cannot get Tick data in the research environment. Sorry for the inconvenience caused. We have opened a GitHub issue to get it resolved to subscribe to the following for updates:
https://github.com/QuantConnect/Lean/issues/4297
Best,
Varad Kabade

Hello,

Could you please provide an example with front AND back contracts (contractDepthOffset = 1 for instance). I dont get any data on the back contracts when trying.

Thanks

Mathieu

Hi Mathieu

We've created a GH issue on the "back contract" support by contractDepthOffset. Please subscribe to this issue for the progress.

For now, a workaround would be using GetFutureContractList and AddFutureContract.

contracts = self.GetFutureContractList(future_symbol, self.Time)
if contracts:
    back_contract = sorted(contracts, lambda x: x.ID.Date, reverse=True)[0]
    self.AddFutureContract(back_contract)

Best
Louis

Hi Louis,

Ok, thanks !

I'll use the GetFutureContractList method for now

Best,

Mathieu

I've been doing more work with futures and I think that the mapping may need another option to change based on daily volume. I've been using the OpenInterest mapping mode, but I've found some issues. For example, Brent Last Day Financial (BZ) has a high open interest in December. This means that the current mapped contract is December 2022, but there is low daily volume compared to the June contract. Does anyone have any suggestions?

As Flame, I think that the daily volume (for instance the average of trading volume over the last 2 to 3 days?) would be the best to really trade the “most active future contract”.

For anyone wanting to trade front month futures based on daily trading volume I wrote the below code to help. Hopefully its useful

class SquareGreenDuck(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2016, 1, 1)  # Set Start Date
        self.SetCash(100000)  # Set Strategy Cash
        
        self.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Margin)

        self.wti = FuturesChain(self, Futures.Energies.CrudeOilWTI)
        self.brent = FuturesChain(self, Futures.Energies.BrentLastDayFinancial)	
		
		self.day = -1
	
	def OnData(self, data):

        if self.Time.day != self.day:
            for kvp in data.FuturesChains:
                for contract in kvp.Value:
                    symbol = kvp.Value.Symbol.Value
                    if 'CL' in symbol:
                        self.wti.ManageChain(contract)
                    elif 'BZ' in symbol:
                        self.brent.ManageChain(contract)

            self.wti.GetFrontMonthContract()
            self.brent.GetFrontMonthContract()

            self.day = self.Time.day

        if self.wti.CurrentContract == None or self.brent.CurrentContract == None:
            return



class FuturesChain:

    def __init__(self, algo, futures, resolution = Resolution.Minute, start = 2, end = 120):

        self.algo = algo
        
        self.futures = algo.AddFuture(futures, resolution)
        self.futures.SetFilter(start, end)
        
        self.symbol = self.futures.Symbol

        self.Chain = {}

        self.CurrentContract = None
        self.CurrentSymbol = None

    
    def ManageChain(self, contract):

        if contract.Symbol not in self.Chain and contract.Expiry > self.algo.Time:

            self.Chain[contract.Symbol] = FuturesContract(self.algo, contract)

        # Remove contracts from the chain that have expired
        keys_to_remove = []
        for contract in self.Chain.keys():
            if self.Chain[contract].contract.Expiry <= self.algo.Time:
                keys_to_remove.append(contract)
                if self.algo.Portfolio[contract].Invested:
                    self.algo.Liquidate(contract)

                self.algo.RemoveSecurity(contract)

        for contract in keys_to_remove:
            self.Chain.pop(contract)
    
    def GetFrontMonthContract(self):

        max_volume = 0
        front_month = None
        for contract, data in self.Chain.items():
            if data.volume.Count > 0:
                volume = data.volume[0]
                if volume > max_volume:
                    front_month = data
                    max_volume = volume

        if front_month != None:
            self.CurrentContract = front_month
            self.CurrentSymbol = front_month.contract.Symbol

    @property
    def Price(self):
        return self.CurrentContract.contract.Price if self.CurrentContract != None else 0


class FuturesContract:

    def __init__(self, algo, contract):

        self.algo = algo
        self.contract = algo.AddFutureContract(contract.Symbol, Resolution.Minute)

        self.volume = RollingWindow[int](3)

        algo.Consolidate(contract.Symbol, timedelta(days=1), self.consolidate_data)

    def consolidate_data(self, consolidated):
        self.volume.Add(consolidated.Volume)

    def IsReady(self):
        return self.volume.Count == 3

@Flame - thanks a lot for this. Do you know how you would add indicators to this framework? I was able to do so with the continuous contracts but, as you stated, ran into some issues i.e. open interest ≠ front month. So, trying to use yours but not sure how to do it. Thanks!