When selecting the contract closest to expiration and handling rollovers using the QuantConnect platform, here is a refined Python script to guide you through setting it up effectively:

from datetime import timedelta
from AlgorithmImports import *
class FutureRolloverAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2022, 1, 1)
        self.set_end_date(2022, 12, 31)
        self.set_cash(100000)
        # Assume you're trading future contract e.g., S&P 500 E-mini
        future = self.add_future(Futures.Indices.SP500E_MINI, Resolution.DAILY)
        future.set_filter(timedelta(0), timedelta(90))  # Filter for contracts expiring within 90 days
        self.contract_symbol = None
        # Schedule rollover before expiry
        self.schedule.on(
            self.date_rules.every_day(),
            self.time_rules.before_market_close(future.symbol, 1),
            self.rollover_contract
        )
    def rollover_contract(self):
        # Get active contracts
        contracts = self.future_chain_provider.get_future_contract_list(self.contract_symbol, self.Time)
        # Filter and select contract closest to expiration, avoiding weekends
        self.contract_symbol = min(
            [c for c in contracts if c.id.date > self.Time],
            key=lambda c: c.id.date
        ).Symbol
    def on_data(self, slice: Slice):
        if self.contract_symbol in slice.bars:
            bar = slice.bars[self.contract_symbol]
            # Implement your trading logic here
+ Expand
- Collapse

Key Points

• Filter by Expiry: The set_filter method is for defining the range of expirations you are interested in. Here, we filter for contracts expiring within the next 90 days.
• Scheduled Events: These are set up to regularly check and handle the rollover of contracts. The date_rules.every_day() checks daily, while rollover_contract manages the rollover logic.
• Handling Timedelta and Dates: Use Python's timedelta for setting up correct time intervals.
• Contract Fetching: This script fetches contracts based on availability and selects the closest current contract in terms of expiry.

This setup ensures your algorithm trades on the most current and liquid futures contracts efficiently.

Sources: Basic Template Future Rollover Algorithm, Handling Data - QuantConnect.com, Handling Data - QuantConnect.com, Security Identifiers - QuantConnect.com, Universes - QuantConnect.com

Thanks! Also, should the timedelta on line 10 be updated?

Mia Alissi should I also call self.rollover_contract in initialize?

While it's not directly necessary to call self.rollover_contract in initialize, calling it at the beginning can be beneficial to ensure that your algorithm starts with the correct future contract immediately. This way, you avoid having to wait for the scheduled event when your algorithm starts.

Here's an example of how you can incorporate this in your initialize method:

from datetime import timedelta
class FutureRolloverAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2022, 1, 1)
        self.set_end_date(2022, 12, 31)
        self.set_cash(100000)
        future = self.add_future(Futures.Indices.SP_500_E_MINI, Resolution.DAILY)
        future.set_filter(0, 182)
        self.contract_symbol = None
        self.rollover_contract()
        self.schedule.on(
            self.date_rules.every_day(),
            self.time_rules.before_market_close(future), 
            self.rollover_contract
        )
    def rollover_contract(self):
        contracts = self.future_chain_provider.get_future_contract_list(Futures.Indices.SP_500_E_MINI, self.Time)
        self.contract_symbol = min(
            [c for c in contracts if c.id.date >= self.Time.date() + timedelta(2)],
            key=lambda c: c.id.date
        ).Symbol
    def on_data(self, slice: Slice):
        if self.contract_symbol in slice.bars:
            bar = slice.bars[self.contract_symbol]
            # Your trading logic goes here
+ Expand
- Collapse

By calling self.rollover_contract() in initialize, you start with the most appropriate future contract for trading immediately. Additionally, the scheduled rollover event ensures that you continue trading the correct contract as time progresses.

Sources: Basic Template Future Rollover Algorithm, Handling Data - QuantConnect.com, Rolling Window Algorithm, Initialization - QuantConnect.com, Getting Started - QuantConnect.com