Continuous Futures Support

Tom M - Hi Tom, the easiest way to use indicators with this implementation is to add the indicator you want to the FuturesContract class and then you can access the indicator value from the CurrentContract in the FuturesChain. By default, the FuturesChain class adds contracts that expire in the next 120 days down to the 2 days before expiry. This means as each contract is added it will also begin collecting data for the indicator you added to the contract so that by the time its in the front month it should be fully warmed up.

Hopefully that helps, but let me know if you have any queries.

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
        
        #----------------
        # Get the indicator value
        #---------------- 
        sma = self.wti.CurrentContract.SMA.Current.Value



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)
        
        #----------------
        # Add Indicator to Class
        #----------------
        self.SMA = algo.SMA(contract.Symbol, 100, Resolution.Daily)

        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 and self.SMA.IsReady  # <------ Add to IsReady to make sure its warmed up

Thanks Flame … I am having other issues with continuous futures at the moment (see attached post), so going to wait until I figure out what's going on before proceeding. I will reference your post when I come back to futures. But conceptually what you sent thru makes sense

In case others find it useful, this is an example of using NQ futures history to warm up some indicators using custom consolidators and then purchasing one NQ contract.As of when I wrote this it should work on backtests and live, though it does require the 3.0 beta.Enabling the 3.0 beta also required me to turn off the new Firefox privacy feature as it was interfering with the new dev environment.

I'm curious how I should expect backwards panama series to work in a live trading scenario, as the way I see it:

• If you're internally using and storing pre-calculated panama stitching offsets, you'll see a consistent series in backtests, but not in live trading (as you won't a priori know the stitching offsets until the rollover day) OR
• You are rescaling past prices on-the-fly at every rollover date, but presumably this invalidates any accumulated prices in any rolling window buffers in the algorithm, and would need to be refreshed on roll day. This might be possible to automate for traditional indicators but I don't see any description of how this should be done for custom indicators or accumulating logic.

Is my understanding correct, or is there some trick to avoid this tradeoff I'm missing?

Hi Joshua

Your understanding is correct. The last contract data is the true one, and all previous ones will be refactored after an update. But remember, price adjustment of continuous futures is just a data smoothing technique actually, which gives us a more realistic study of the underlying asset's past price changes. So we shouldn't aggregate the raw data for comparison with the previously processed data. Instead, call a History object/dataframe every time you need a study of that. 

Best
Louis

Can anyone help a noob with creating an algorithm to purchase VIX continuous futures? When I tried it said that it's not available to buy but I think there is a continuous VIX futures contract that interactive brokers has available for live trade. I just don't know how to call it out on Quantconnect.

Hi Lukel

You have to call .Mapped property and trade the underlying contract. Continuous future is just a method to map over contracts for studying historical data like it was traded continuously under single symbol.

self.MarketOrder(self.continuous_future.Mapped, 1)

Read the Future Security Master docs for details.

Best
Louis

I'm having trouble using the continuous contract symbol to access the data in a historical dataframe.

self.continuous_contract = self.AddFuture(
            Futures.Indices.SP500EMini,
            Resolution.Minute,
            dataNormalizationMode=DataNormalizationMode.BackwardsRatio,
            dataMappingMode=DataMappingMode.OpenInterest,
            contractDepthOffset=0,
            extendedMarketHours=True,
        )
hist = self.History([self.continuous_contract], 2, Resolution.Daily)
hist.loc[self.continuous_contract.Mapped]
#----
Runtime Error: ES VZ0LUIY9VWU9
  at _check_indexing_error
    raise InvalidIndexError(key)

Hi Brian,

Use the following snippet:

hist = self.History([self.continuous_contract.Symbol], 2, Resolution.Daily).droplevel(0)
hist.loc[self.continuous_contract.Symbol]

See the attached backtest for reference.

Best,
Derek Melchin

Want to invest in QuantConnect as we build the Linux of quant finance? Checkout our Wefunder campaign to join the revolution.

How do I access the minimum tick size of the altered tick price. like 0.23222556 instead of 0.25 due to it being mathematically changed. Or how can I access the multiplier of the contract price? future.SymbolProperties.MinimumPriceVariation will only get me 0.25 when I am using open interest and backwards ratio for continuous futures.

Hi Garrison,

How do I access the minimum tick size of the altered tick price. like 0.23222556 instead of 0.25 due to it being mathematically changed.

Please provide an example.

how can I access the multiplier of the contract price?

future.SymbolProperties.ContractMultiplier

See the attached backtest for reference.

future.SymbolProperties.MinimumPriceVariation will only get me 0.25 when I am using open interest and backwards ratio for continuous futures.

We were able to get the minimum price variation of 0.25 with other data normalization modes and and data mapping modes. See the attached backtest for reference.

Best,
Derek Melchin

Want to invest in QuantConnect as we build the Linux of quant finance? Checkout our Wefunder campaign to join the revolution.

Derek Melchin the contract multiplier you mentioned is 50 which is the dollars to tick multiplier, I am looking for something like the backwards ratio scale on this page: Lean: QuantConnect.Data.Auxiliary.MappingContractFactorRow Class Reference or the backwards ratio scale referenced on this page: Algorithmic Trading Platform - QuantConnect.com . 

When I use continuous futures with the backwards ratio and open interest the ticks get altered and in order for me to find out how many ticks away the price has gone the 0.25 default tick does not help me because all the ticks and prices get multiplied by the backwards ratio scale, so they become 0.25 times the scale 0.9914163090128755364806866953 and is now 0.2478…

All I am looking for is a way to quickly get that altered tick size or the backwards ratio scale used for the current futures contract that is selected,

Hi Garrison,

It's not currently possible to access the backwards ratio scale of continuous futures. To be notified when it's possible, subscribe to the following GitHub Issue:

Best,
Derek Melchin

Want to invest in QuantConnect as we build the Linux of quant finance? Checkout our Wefunder campaign to join the revolution.

How can I prevent this continuous futures algo from erroring out when using Futures.Energies.CrudeOilWTI contract on 9/22/2020 after the market has closed? is says: “Runtime Error: (,)” Stack Trace: “(<QuantConnect.Symbol object at 0x7fbbd1eaa540>,)”

It errors the same time that the EndofDay function runs

Same thing happens when using Futures.Grains.Corn contracts on 12/14/2020 Stack Trace: “(<QuantConnect.Symbol object at 0x7f94f23bdcc0>,)”

from AlgorithmImports import *

#endregion
class RetrospectiveTanButterfly(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2020, 9, 17)  # Set Start Date
        self.SetEndDate(2020, 10, 23)
        self.SetCash(1000000000)  # Set Strategy Cash
        self.symbolData = {}
        self.contract = self.AddFuture(Futures.Energies.CrudeOilWTI , Resolution.Tick, extendedMarketHours = False, dataNormalizationMode = DataNormalizationMode.BackwardsRatio, dataMappingMode = DataMappingMode.OpenInterest , contractDepthOffset = 0)
        symbol = self.contract.Symbol
        #symbol.SetFilter(0, 90)
        #Futures.Grains.Corn, Futures.Indices.SP500EMini, Futures.Energies.CrudeOilWTI
        self.symbolData[symbol] = SymbolData()

            
    def OnData(self, data):
        for changedEvent in data.SymbolChangedEvents.Values:
            if changedEvent.Symbol == self._continuousContract.Symbol:
                self.Log(f"SymbolChanged event: {changedEvent}")
                self.Log(f"contract mapped symbol: {self.contract.Mapped}")

        for symbol, symbolData in self.symbolData.items():
            if not data.Ticks.ContainsKey(symbol): continue

    def OnEndOfDay(self, symbol):
        symbolData = self.symbolData[symbol]
        self.Log(f"end of day")
        
class SymbolData:
    
    def __init__(self):
        self.buyVolume = 0
        self.sellVolume = 0

Hi Garrison

You only stored the canonical symbol of CL in the dict self.symbolData. It will direct to the current mapped symbol. However, when the symbol mapped is changed, your algorithm is still subscribing to the old contract’s data. So, the old symbol will get called in the OnEndOfDay handler and it is not linked to the canonical symbol. It can be easily solved if you add a if-condition to check whether the symbol is in the dict

Best
Louis

Is there a property or a helper method that returns the current offset factor (the difference between the prices of continuous future and the current mapped contract?). If not, how to compute the proper limit and/or stop prices when placing orders?     

I thought I found a way to compute the offset, but it doesn't work as expected. I'm using ForwardPanamaCanal and expected constant offset for a given mapped contract but instead seeing varying offset which doesn't make sense. Can someone explain what's missing and how to do this properly?        

Martin Molinero This is fantastic news! I recently noticed that TradingView and IB also added this feature. So this will make backtesting much easier. For beginners to learn what all these “panama canal” means, I would love to see some lessons that we could take. What is the plan for adding this to the Futures learning course ?

Hi Sri Quant

That would be a great idea, but we currently have not planned to do so yet. Right now, please refer to the continuous contract documentation and Future Security Master‘s dataset page for information. You might also seeks some external sources (e.g. quantpedia) to learn more about the adjustment methods.

Best
Louis

Hi all,

I've been working with the continuous futures functionality and have been seeing some strange behavior whereby there is a rather large discrepancy between prices passed to onData and those used by order handling. I'm including a simple code example that buys then sells 5 futures. For comparison, this code prints the onData bar prices and the order details. You can see that the prices for the onData bars are consistently about $30-40 higher than the prices returned by the market order fills. I'm hoping this is a subtle configuration issue that maybe I don't understand or am missing regarding this feature, but I haven't been able to pinpoint why these discrepancies are present and I'm hoping someone from the community can help.

Thanks!