In This Page

Introduction

Create Universes

Continous Contracts

Filter Contracts

Navigate Futures Chains

Selection Frequency

Examples

Universes

Futures

Introduction

A Futures universe lets you select a basket of contracts for a single Future. LEAN models Future subscriptions as a universe of Future contracts. A Future universe is similar to an Option universe, except Future contracts don't have a strike price, so the universe filter primarily focuses on the contract expiration date.

Create Universes

To add a universe of Future contracts, in the Initializeinitialize method, call the AddFutureadd_future method. This method returns an Future object, which contains the continuous contract Symbolsymbol. The continuous contract Symbolsymbol is the key to access the contracts in the FutureChain that LEAN passes to the OnDataon_data method. The continuous contract Mappedmapped property references the current contract in the continuous contract series. When you create the Future subscription, save a reference to the Future object so you can use it later in your algorithm.

Select Language:

public class BasicFutureAlgorithm : QCAlgorithm
{
    private Future _future;
    public override void Initialize()
    {
        UniverseSettings.Asynchronous = true;
        _future = AddFuture(Futures.Currencies.BTC,
            extendedMarketHours: true,
            dataMappingMode: DataMappingMode.LastTradingDay,
            dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
            contractDepthOffset: 0);
        _future.SetFilter(0, 62);
    }

    public override void OnData(Slice data)
    {
        if (Portfolio.Invested)
        {
            return;
        }
        data.Bars.TryGetValue(_future.Symbol, out var continuousTradeBar);
        data.Bars.TryGetValue(_future.Mapped, out var mappedTradeBar);
        MarketOrder(_future.Mapped, 1);
    }

    // Track events when security changes its ticker, allowing the algorithm to adapt to these changes.
    public override void OnSymbolChangedEvents(SymbolChangedEvents symbolChangedEvents)
    {
        foreach (var (symbol, changedEvent) in symbolChangedEvents)
        {
            var oldSymbol = changedEvent.OldSymbol;
            var newSymbol = changedEvent.NewSymbol;
            var quantity = Portfolio[oldSymbol].Quantity;

            // Rolling over: to liquidate any position of the old mapped contract and switch to the newly mapped contract
            var tag = $"Rollover - Symbol changed at {Time}: {oldSymbol} -> {newSymbol}";
            Liquidate(oldSymbol, tag: tag);
            if (quantity != 0) MarketOrder(newSymbol, quantity, tag: tag);
        }
    }
}

class BasicFutureAlgorithm(QCAlgorithm):
    def initialize(self):
        self.universe_settings.asynchronous = True
        self._future = self.add_future(Futures.Currencies.BTC,
            extended_market_hours=True,
            data_mapping_mode=DataMappingMode.LAST_TRADING_DAY,
            data_normalization_mode=DataNormalizationMode.BACKWARDS_RATIO,
            contract_depth_offset=0)
        self._future.set_filter(0,62)

    def on_data(self, data):
        if self.portfolio.invested:
            return
        continuous_trade_bar = data.bars.get(self._future.symbol)
        mapped_trade_bar = data.bars.get(self._future.mapped)
        self.market_order(self._future.mapped, 1)
   
    # Track events when security changes its ticker allowing algorithm to adapt to these changes.
    def on_symbol_changed_events(self, symbol_changed_events):
        for symbol, changed_event in  symbol_changed_events.items():
            old_symbol = changed_event.old_symbol
            new_symbol = changed_event.new_symbol
            quantity = self.portfolio[old_symbol].quantity

            # Rolling over: to liquidate any position of the old mapped contract and switch to the newly mapped contract
            tag = f"Rollover - Symbol changed at {self.time}: {old_symbol} -> {new_symbol}"
            self.liquidate(old_symbol, tag=tag)
            if quantity: self.market_order(new_symbol, quantity, tag=tag)

The following table describes the AddFutureadd_future method arguments:

Argument: `ticker`

The Future ticker. To view the supported assets in the US Futures dataset, see Supported Assets.

Data Type: stringstr | Default Value: None

Argument: `resolution`

The resolution of the market data. To view the supported resolutions, see Resolutions. If you don't provide a value, it uses Resolution.MinuteResolution.MINUTE by default.

Data Type: Resolution?Resolution/NoneType | Default Value: Nonenull

Argument: `market`

The Futures market. To view the supported markets in the US Futures dataset, see Supported Markets. If you don't provide a value, it uses the default Future market of your brokerage model.

Data Type: stringstr | Default Value: Nonenull

Argument: `fillForwardfill_forward`

If true, the current slice contains the last available data even if there is no data at the current time.

Data Type: bool | Default Value: Truetrue

Argument: `leverage`

The leverage for this Future.

Data Type: decimalfloat | Default Value: Security.NullLeverageSecurity.NULL_LEVERAGE

Argument: `extendedMarketHoursextended_market_hours`

If true, use data from the pre and post market sessions

Data Type: bool | Default Value: Falsefalse

Argument: `dataMappingModedata_mapping_mode`

The contract mapping mode to use for the continuous future contract

Data Type: DataMappingMode?DataMappingMode/NoneType | Default Value: Nonenull

Argument: `dataNormalizationModedata_normalization_mode`

The price scaling mode to use for the continuous future contract

Data Type: DataNormalizationMode?DataNormalizationMode/NoneType | Default Value: Nonenull

Argument: `contractDepthOffsetcontract_depth_offset`

The continuous future contract desired offset from the current front month. For example, 0 is the front month, 1 is the back month contract.

Data Type: int | Default Value: 0

Continous Contracts

By default, LEAN only subscribes to the continuous Future contract. A continuous Future contract represents a series of separate contracts stitched together to form a continuous price. If you need a lot of historical data to warm up an indicator, apply the indicator to the continuous contract price series. The Future object has a Symbolsymbol property and a Mappedmapped property. The price of the Symbolsymbol property is the adjusted price of the continuous contract. The price of the Mappedmapped property is the raw price of the currently selected contract in the continuous contract series.

Select Language:

// Get the adjusted price of the continuous contract.
var adjustedPrice = Securities[_future.Symbol].Price; 

// Get the raw price of the currently selected contract in the continuous contract series.
var rawPrice = Securities[_future.Mapped].Price;

# Get the adjusted price of the continuous contract.
adjusted_price = self.securities[self._future.symbol].price 

# Get the raw price of the currently selected contract in the continuous contract series.
raw_price = self.securities[self._future.mapped].price

The continuous Futures contract isn't a tradable security. You must place orders for a specific Futures contract. To access the currently selected contract in the continuous contract series, use the Mappedmapped property of the Future object.

Select Language:

// Place a market order for the currently selected contract in the continuous contract series.
MarkerOrder(_future.Mapped, 1);

# Place a market order for the currently selected contract in the continuous contract series.
self.market_order(self._future.mapped, 1)

To configure how LEAN identifies the current Future contract in the continuous series and how it forms the adjusted price between each contract, provide dataMappingModedata_mapping_mode, dataNormalizationModedata_normalization_mode, and contractDepthOffsetcontract_depth_offset arguments to the AddFutureadd_future method. The Future object that the AddFutureadd_future method returns contains a Mappedmapped property that references the current contract in the continuous contract series. As the contracts roll over, the Mappedmapped property references the next contract in the series and you receive a SymbolChangedEvent object in the OnDataon_data method. The SymbolChangedEvent references the old contract Symbol and the new contract Symbol. You can use SymbolChangedEvents to roll over contracts.

Select Language:

public class BasicFutureAlgorithm : QCAlgorithm
{
    // Track when the continuous contract switches from one contract to the next.
    public override void OnSymbolChangedEvents(SymbolChangedEvents symbolChangedEvents)
    {
        foreach (var (symbol, changedEvent) in symbolChangedEvents)
        {
            var oldSymbol = changedEvent.OldSymbol;
            var newSymbol = changedEvent.NewSymbol;
            var quantity = Portfolio[oldSymbol].Quantity;

            // Rolling over: To liquidate the old mapped contract and switch to the new mapped contract.
            var tag = $"Rollover - Symbol changed at {Time}: {oldSymbol} -> {newSymbol}";
            Liquidate(oldSymbol, tag: tag);
            if (quantity != 0) MarketOrder(newSymbol, quantity, tag: tag);
        }
    }
}

class BasicFutureAlgorithm(QCAlgorithm):
    # Track when the continuous contract switches from one contract to the next.
    def on_symbol_changed_events(self, symbol_changed_events):
        for symbol, changed_event in  symbol_changed_events.items():
            old_symbol = changed_event.old_symbol
            new_symbol = changed_event.new_symbol
            quantity = self.portfolio[old_symbol].quantity

            # Rolling over: To liquidate the old mapped contract and switch to the new mapped contract.
            tag = f"Rollover - Symbol changed at {self.time}: {old_symbol} -> {new_symbol}"
            self.liquidate(old_symbol, tag=tag)
            if quantity: self.market_order(new_symbol, quantity, tag=tag)

In backtesting, the SymbolChangedEvent occurs at midnight Eastern Time (ET). In live trading, the live data for continuous contract mapping arrives at 6/7 AM ET, so that's when it occurs.

Data Normalization Modes

The dataNormalizationModedata_normalization_mode argument defines how the price series of two contracts are stitched together when the contract rollovers occur. The following DataNormalizatoinMode enumeration members are available for continuous contracts:

DataNormalizationMode Select Language:

Eliminates price jumps between two consecutive contracts, adding a factor based on the difference of their prices. The first contract has the true price. Factor 0. (4)

FORWARD_PANAMA_CANAL: DataNormalizationMode

Eliminates price jumps between two consecutive contracts, adding a factor based on the difference of their prices. The last contract has the true price. Factor 0. (5)

BACKWARDS_PANAMA_CANAL: DataNormalizationMode

Eliminates price jumps between two consecutive contracts, multiplying the prices by their ratio. The last contract has the true price. Factor 1. (6)

BACKWARDS_RATIO: DataNormalizationMode

We use the entire Futures history to adjust historical prices. This process ensures you get the same adjusted prices, regardless of the backtest end date.

Data Mapping Modes

The dataMappingModedata_mapping_mode argument defines when contract rollovers occur. The DataMappingMode enumeration has the following members:

DataMappingMode Select Language:

The contract maps on the previous day of expiration of the front month (0)

LAST_TRADING_DAY: DataMappingMode

The contract maps on the first date of the delivery month of the front month. If the contract expires prior to this date, then it rolls on the contract's last trading date instead (1)

FIRST_DAY_MONTH: DataMappingMode

The contract maps when the following back month contract has a higher open interest that the current front month (2)

OPEN_INTEREST: DataMappingMode

The contract maps when any of the back month contracts of the next year have a higher volume that the current front month (3)

OPEN_INTEREST_ANNUAL: DataMappingMode

Futures.Indices.VIX (VX) doesn't support continous contract rolling with DataMappingMode.OpenInterestDataMappingMode.OPEN_INTEREST and DataMappingMode.OpenInterestAnnuakDataMappingMode.OPEN_INTEREST_ANNUAL.

Contract Depth Offsets

The contractDepthOffsetcontract_depth_offset argument defines which contract to use. 0 is the front month contract, 1 is the following back month contract, and 2 is the second back month contract.

Filter Contracts

By default, LEAN doesn't add any contracts to the FuturesChain it passes to the OnDataon_data method.

To set a contract filter, in the Initializeinitialize method, call the SetFilterset_filter method of the Future object. The following table describes the available filter techniques:

set_filter(minExpiry: int, maxExpiry: int)

Selects the contracts that expire within the range you set. This filter runs asynchronously by default.

set_filter(universeFunc: Callable[[FutureFilterUniverse], FutureFilterUniverse])

Selects the contracts that a function selects.

Select Language:

# Select the contracts that expire within 182 days.
self._future.set_filter(0, 182)

# Select the front month contract.
self._future.set_filter(lambda future_filter_universe: future_filter_universe.front_month())

// Select the contracts that expire within 182 days.
_future.SetFilter(0, 182);

// Select the front month contract.
_future.SetFilter(futureFilterUniverse => futureFilterUniverse.FrontMonth());

The following table describes the filter methods of the FutureFilterUniverse class:

standards_only()

Selects standard contracts

include_weeklys()

Selects non-standard weekly contracts

weeklys_only()

Selects weekly contracts

front_month()

Selects the front month contract

back_months()

Selects the non-front month contracts

back_month()

Selects the back month contracts

expiration(min_expiry: timedelta, max_expiry: timedelta)

Selects contracts that expire within a range of dates relative to the current day

expiration(min_expiry_days: int, max_expiry_days: int)

Selects contracts that expire within a range of dates relative to the current day

contracts(contracts: List[Symbol])

Selects a list of contracts

contracts(contractSelector: Callable[[List[Symbol]], List[Symbol]])

Selects contracts that a selector function selects

The preceding methods return an FutureFilterUniverse, so you can chain the methods together.

Select Language:

// Select the front month standard contracts
_future.SetFilter(futureFilterUniverse => futureFilterUniverse.StandardsOnly().FrontMonth());

# Select the front month standard contracts
self._future.set_filter(lambda future_filter_universe: future_filter_universe.standards_only().front_month())

You can also define an isolated filter method.

Select Language:

// In Initialize
_future.SetFilter(Selector);
    
private FutureFilterUniverse Selector(FutureFilterUniverse futureFilterUniverse)
{
    return futureFilterUniverse.StandardsOnly().FrontMonth();
}

# In Initialize
self._future.set_filter(self._contract_selector)
    
def _contract_selector(self, 
    future_filter_universe: Callable[[FutureFilterUniverse], FutureFilterUniverse]) -> FutureFilterUniverse:
    return future_filter_universe.standards_only().front_month()

Navigate Futures Chains

FuturesChain objects represent an entire chain of contracts for a single underlying Future. They have the following properties:

FuturesChain Select Language:

Gets the most recent trade information for the underlying. This may be a QuantConnect.Data.Market.Tick or a QuantConnect.Data.Market.TradeBar

underlying: BaseData

Gets all ticks for every futures contract in this chain, keyed by symbol

ticks: Ticks

Gets all trade bars for every futures contract in this chain, keyed by symbol

trade_bars: TradeBars

Gets all quote bars for every futures contract in this chain, keyed by symbol

quote_bars: QuoteBars

Gets all contracts in the chain, keyed by symbol

contracts: FuturesContracts

Gets the set of symbols that passed the QuantConnect.Securities.Future.Future.ContractFilter

filtered_contracts: HashSet<Symbol>

Market Data Type of this data - does it come in individual price packets or is it grouped into OHLC.

data_type: MarketDataType

True if this is a fill forward piece of data

is_fill_forward: bool

Current time marker of this data packet.

time: DateTime

The end time of this data. Some data covers spans (trade bars) and as such we want to know the entire time span covered

end_time: DateTime

Symbol representation for underlying Security

symbol: Symbol

Value representation of this data packet. All data requires a representative value for this moment in time. For streams of data this is the price now, for OHLC packets this is the closing price.

value: decimal

As this is a backtesting platform we'll provide an alias of value as price.

price: decimal

To get the FuturesChain, index the FuturesChainsfutures_chains property of the Slice with the continuous contract Symbol.

Select Language:

public override void OnData(Slice slice)
{
    if (slice.FuturesChains.TryGetValue(_symbol, out var chain))
    {
        // Example: Select the contract with the greatest open interest
        var contract = chain.OrderBy(x => x.OpenInterest).Last();
    }
}

def on_data(self, slice: Slice) -> None:
    chain = slice.futures_chains.get(self._symbol)
    if chain:
        # Example: Select the contract with the greatest open interest
        contract = sorted(chain, key=lambda contract: contract.open_interest, reverse=True)[0]

You can also loop through the FuturesChainsfutures_chains property to get each FuturesChain.

Select Language:

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.FuturesChains)
    {
        var continuousContractSymbol = kvp.Key;
        var chain = kvp.Value;
    }
}

public void OnData(FuturesChains futuresChains)
{
    foreach (var kvp in futuresChains)
    {
        var continuousContractSymbol = kvp.Key;
        var chain = kvp.Value;
    }
}

def on_data(self, slice: Slice) -> None:
    for continuous_contract_symbol, chain in slice.futures_chains.items():
        pass

Selection Frequency

By default, Futures universes run at the first time step of each day to select their contracts.

Examples

The following examples demonstrate some common Futures universes.

Example 1: Contracts Expiring On Quarter End

If you run strategies with a quarterly trading cycle, you can filter Future contracts that expire only on quarter ends to reduce the need of rollovers.

Select Language:

public class QuarterlyFuturesAlgorithm : QCAlgorithm
The following examples demonstrate some common Futures universes.


Example 1: Contracts Expiring On Quarter End
 To reduce the need for rolling over, you can filter Future contracts that expire only on quarter ends to save transaction costs. The following example trades a simple EMA cross strategy on SP500 EMini Future contracts that expire on quarter ends.

 Select Language: 
 public class QuarterlyFuturesAlgorithm : QCAlgorithm
{
    private Future _future;
    private ExponentialMovingAverage _ema;
    // A variable to control the algorithm trading in daily frequency only, since the indicator signal is by daily.
    private int _day = -1;

    public override void Initialize()
    {
        SetStartDate(2024, 3, 1);
        SetEndDate(2024, 5, 1);
        SetCash(10000000);

        // Request ES Future data for trading. We only use the continuous contract for indicator values.
        _future = AddFuture(
            Futures.Indices.SP500EMini,
            extendedMarketHours: true,
            dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
            dataMappingMode: DataMappingMode.OpenInterest
        );
        // We only filter the ones expiring on quarter ends to reduce the transaction cost needed for rolling over contracts.
        _future.SetFilter(futureFilterUniverse => futureFilterUniverse.ExpirationCycle(new int[] { 3, 6, 9, 12 }));

        // Create an EMA indicator to track trends for trade signal generation.
        _ema = EMA(_future.Symbol, 20, Resolution.Daily);
        // Warm up the indicator for immediate readiness.
        WarmUpIndicator(_future.Symbol, _ema, Resolution.Daily);

    }

    public override void OnData(Slice slice)
    {
        // Get the chain to trade from the filtered contracts.
        if (_day != slice.Time.Day && slice.FutureChains.TryGetValue(_future.Symbol, out var chain))
        {
            // Select the contract with the nearest expiry.
            var contract = chain.MinBy(x => x.Expiry);

            // Trade an EMA cross strategy to follow the trend.
            var quantity = Portfolio[_future.Symbol].Quantity;
            if (contract.LastPrice > _ema && quantity <= 0)
            {
                MarketOrder(contract.Symbol, 1-quantity);
            }
            else if (contract.LastPrice < _ema && quantity >= 0)
            {
                MarketOrder(contract.Symbol, -1-quantity);
            }

            _day = slice.Time.Day;
        }
    }
}
 class QuarterlyFuturesAlgorithm(QCAlgorithm):
    
    def initialize(self) -> None:
        self.set_start_date(2024, 3, 1)
        self.set_end_date(2024, 5, 1)
        self.set_cash(10000000)
        
        # Request ES Future data for trading.
        self.future = self.add_future(
            Futures.Indices.SP_500_E_MINI,
            extended_market_hours=True,
            data_normalization_mode=DataNormalizationMode.BACKWARDS_RATIO,
            data_mapping_mode=DataMappingMode.OPEN_INTEREST,
        )
        # We only filter the ones expiring on quarter ends to reduce the transaction cost needed for rolling over contracts.
        self.future.set_filter(lambda future_filter_universe: future_filter_universe.expiration_cycle([3, 6, 9, 12]))

        # Create an EMA indicator to track trends for trade signal generation.
        self._ema = self.ema(self.future.symbol, 20, Resolution.DAILY)
        # Warm up the indicator for immediate readiness.
        self.warm_up_indicator(self.future.symbol, self._ema, Resolution.DAILY)

        # A variable to control the algorithm trading in daily frequency only, since the indicator signal is by daily.
        self._day = -1

    def on_data(self, slice: Slice) -> None:
        # Get the chain to trade from the filtered contracts.
        chain = slice.future_chains.get(self.future.symbol)
        if self._day != slice.time.day and chain:
            # Select the contract with the nearest expiry.
            contract = min(chain, key=lambda x: x.expiry)

            # Trade an EMA cross strategy to follow the trend.
            quantity = self.portfolio[self.future.symbol].quantity
            if contract.last_price > self._ema.current.value and quantity <= 0:
                self.market_order(contract.symbol, 1-quantity)
            elif contract.last_price < self._ema.current.value and quantity >= 0:
                self.market_order(contract.symbol, -1-quantity)
            
            self._day = slice.time.day



 Example 2: Contracts Expiring Within One Week
  The trading volume of Futures reaches its maximum during the last week of the trading period. 
	The following algorithm selects contracts that expire within a week:

 Select Language: 
 public class WeeklyFuturesAlgorithm : QCAlgorithm
{
    private Future _future;
    private BollingerBands _bb;

    public override void Initialize()
    {
        SetStartDate(2024, 6, 1);
        SetEndDate(2024, 7, 1);
        SetCash(100000000);

        // Request ES Future data for trading. The continuous contract data is only used for indicator values.
        _future = AddFuture(
            Futures.Indices.SP500EMini,
            extendedMarketHours: true,
            dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
            dataMappingMode: DataMappingMode.OpenInterest
        );
        // Select the contracts expiring within a week since they have the highest liquidity.
        _future.SetFilter(futureFilterUniverse => futureFilterUniverse.Expiration(0, 7));

        // Create a BollingerBand indicator to identify extreme prices for trade signal generation.
        _bb = BB(_future.Symbol, 60, 2);
        // Warm up the indicator for immediate readiness.
        WarmUpIndicator(_future.Symbol, _bb, Resolution.Minute);
    }

    public override void OnData(Slice slice)
    {
        // Trade based on updated data.
        if (slice.FutureChains.TryGetValue(_future.Symbol, out var chain))
        {
            // Select the contract with the nearest expiry.
            var contract = chain.MinBy(x => x.Expiry);

            // Trade a mean-reversal strategy based on Bollinger Band signal.
            var quantity = Portfolio[_future.Symbol].Quantity;
            if (contract.LastPrice > _bb.UpperBand && quantity >= 0)
            {
                MarketOrder(contract.Symbol, -1-quantity);
            }
            else if (contract.LastPrice < _bb.LowerBand && quantity <= 0)
            {
                MarketOrder(contract.Symbol, 1-quantity);
            }
            else if ((Portfolio[_future.Symbol].IsLong && contract.LastPrice > _bb.MiddleBand) ||
            (Portfolio[_future.Symbol].IsShort && contract.LastPrice < _bb.MiddleBand))
            {
                Liquidate(contract.Symbol);
            }
        }
    }
}
 class WeeklyFuturesAlgorithm(QCAlgorithm):
    
    def initialize(self) -> None:
        self.set_start_date(2024, 6, 1)
        self.set_end_date(2024, 7, 1)
        self.set_cash(100000000)
        
        # Request ES Future data for trading. The continuous contract data is only used for indicator values.
        self.future = self.add_future(
            Futures.Indices.SP_500_E_MINI,
            extended_market_hours=True,
            data_normalization_mode=DataNormalizationMode.BACKWARDS_RATIO,
            data_mapping_mode=DataMappingMode.OPEN_INTEREST
        )
        # Select the contracts expiring within a week since they have the highest liquidity.
        self.future.set_filter(lambda future_filter_universe: future_filter_universe.expiration(0, 7))

        # Create a BollingerBand indicator to identify extreme prices for trade signal generation.
        self._bb = self.bb(self.future.symbol, 60, 2)
        # Warm up the indicator for immediate readiness.
        self.warm_up_indicator(self.future.symbol, self._bb, Resolution.MINUTE)

    def on_data(self, slice: Slice) -> None:
        # Trade based on updated data.
        chain = slice.future_chain.get(self.future.symbol)
        if chain:
            # Select the contract with the nearest expiry.
            contract = min(chain, key=lambda x: x.expiry)

            # Trade a mean-reversal strategy based on Bollinger Band signal.
            quantity = self.portfolio[self.future.symbol].quantity
            if contract.last_price > self._bb.upper_band.current.value and quantity >= 0:
                self.market_order(contract.symbol, -1-quantity)
            elif contract.last_price < self._bb.lower_band.current.value and quantity <= 0:
                self.market_order(contract.symbol, 1-quantity)
            elif (self.portfolio[self.future.symbol].is_short and contract.last_price < self._bb.middle_band.current.value)\
            or (self.portfolio[self.future.symbol].is_long and contract.last_price > self._bb.middle_band.current.value):
                self.liquidate(contract.symbol)



 Other Examples
  For more examples, see the following algorithms:


 
  Demonstration Algorithms
 

 
  EmaCrossFuturesFrontMonthAlgorithm.cs
  
   C#
  
 
 
  EmaCrossFuturesFrontMonthAlgorithm.py
  
   Python

You can also see our Videos. You can also get in touch with us via Discord.

Did you find this page helpful?

Contribute to the documentation:

SIGN IN

Browse

Cloud Platform

Writing Algorithms

▶Key Concepts

Initialization

▶Securities

▶Portfolio

▶Universes

▶Datasets

▶Importing Data

▶Consolidating Data

▶Historical Data

▶Trading and Orders

▶Reality Modeling

Scheduled Events

▶Indicators

Object Store

▶Optimization

▶Machine Learning

▶Algorithm Framework

Charting

Logging

▶Statistics

▶Live Trading

Strategy Library

API Reference

▶Migrations

Research Environment

Local Platform

LEAN CLI

LEAN Engine

Hello

Universes

Futures

Introduction

Create Universes

Argument: ticker

Argument: resolution

Argument: market

Argument: fillForwardfill_forward

Argument: leverage

Argument: extendedMarketHoursextended_market_hours

Argument: dataMappingModedata_mapping_mode

Argument: dataNormalizationModedata_normalization_mode

Argument: contractDepthOffsetcontract_depth_offset

Continous Contracts

Data Normalization Modes

Data Mapping Modes

Contract Depth Offsets

Filter Contracts

Navigate Futures Chains

Selection Frequency

Examples

Example 1: Contracts Expiring On Quarter End

Example 1: Contracts Expiring On Quarter End

Example 2: Contracts Expiring Within One Week

Other Examples

▶
Key Concepts

▶
Securities

▶
Portfolio

▶
Universes

▶
Datasets

▶
Importing Data

▶
Consolidating Data

▶
Historical Data

▶
Trading and Orders

▶
Reality Modeling

▶
Indicators

▶
Optimization

▶
Machine Learning

▶
Algorithm Framework

▶
Statistics

▶
Live Trading

▶
Migrations

Argument: `ticker`

Argument: `resolution`

Argument: `market`

Argument: `fillForwardfill_forward`

Argument: `leverage`

Argument: `extendedMarketHoursextended_market_hours`

Argument: `dataMappingModedata_mapping_mode`

Argument: `dataNormalizationModedata_normalization_mode`

Argument: `contractDepthOffsetcontract_depth_offset`