AlgoSeek

from AlgorithmImports import *

class FutureOptionExampleAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        # Subscribe the underlying since the updated price is needed for filtering
        self.underlying = self.add_future(Futures.Indices.SP_500_E_MINI,
            extended_market_hours=True,
            data_mapping_mode=DataMappingMode.OPEN_INTEREST,
            data_normalization_mode=DataNormalizationMode.BACKWARDS_RATIO,
            contract_depth_offset=0)
        # Filter the underlying continuous Futures to narrow the FOP spectrum
        self.underlying.set_filter(0, 182)
        # Filter for the current-week-expiring calls to formulate a covered call that expires at the end of week
        self.add_future_option(self.underlying.symbol, lambda u: u.include_weeklys().calls_only().expiration(0, 5))

    def on_data(self, slice: Slice) -> None:
        # Create canonical symbol for the mapped future contract, since option chains are mapped by canonical symbol
        symbol = Symbol.create_canonical_option(self.underlying.mapped)

        # Get option chain data for the mapped future, as both the underlying and FOP have the highest liquidity among all other contracts
        chain = slice.option_chains.get(symbol)
        if not self.portfolio.invested and chain:
            # Obtain the ATM call that expires at the end of week, such that both underlying and the FOP expires the same time
            expiry = max(x.expiry for x in chain)
            atm_call = sorted([x for x in chain if x.expiry == expiry],
                key=lambda x: abs(x.strike - x.underlying_last_price))[0]

            # Use abstraction method to order a covered call to avoid manual error
            option_strategy = OptionStrategies.covered_call(symbol, atm_call.strike,expiry)
            self.buy(option_strategy, 1)
        
    def on_securities_changed(self, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            if security.type == SecurityType.FUTURE_OPTION:
                # Historical data
                history = self.history(security.symbol, 10, Resolution.MINUTE)
                self.debug(f"We got {len(history)} from our history request for {security.symbol}")

public class FutureOptionExampleAlgorithm : QCAlgorithm
{
    private Future _underlying;

    public override void Initialize()
    {
        // Subscribe the underlying since the updated price is needed for filtering
        _underlying = AddFuture(Futures.Indices.SP500EMini,
            extendedMarketHours: True,
            dataMappingMode: DataMappingMode.OpenInterest,
            dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
            contractDepthOffset: 0);
        // Filter the underlying continuous Futures to narrow the FOP spectrum
        _underlying.SetFilter(0, 182);
        // Filter for the current-week-expiring calls to formulate a covered call that expires at the end of week
        AddFutureOption(_underlying.Symbol, (u) => u.IncludeWeeklys().CallsOnly().Expiration(0, 5));
    }

    public override void OnData(Slice slice)
    {
        // Create canonical symbol for the mapped future contract, since option chains are mapped by canonical symbol
        var symbol = QuantConnect.Symbol.CreateCanonicalOption(_underlying.Mapped);

        // Get option chain data for the mapped future, as both the underlying and FOP have the highest liquidity among all other contracts
        if (!Portfolio.Invested && 
            slice.OptionChains.TryGetValue(symbol, out var chain))
        {
            // Obtain the ATM call that expires at the end of week, such that both underlying and the FOP expires the same time
            var expiry = chain.Max(x => x.Expiry);
            var atmCall = chain.Where(x => x.Expiry == expiry)
                .OrderBy(x => Math.Abs(x.Strike - x.UnderlyingLastPrice))
                .First();

            // Use abstraction method to order a covered call to avoid manual error
            var optionStrategy = OptionStrategies.CoveredCall(symbol, atmCall.Strike, expiry);
            Buy(optionStrategy, 1);
        }
    }

    public override void OnSecuritiesChanged(SecurityChanges changes)
    {
        foreach (var security in changes.AddedSecurities)
        {
            if (security.Type == SecurityType.FutureOption)
            {
                // Historical data
                var history = History(security.Symbol, 10, Resolution.Minute);
                Debug($"We got {history.Count()} from our history request for {security.Symbol}");
            }
        }
    }
}

from AlgorithmImports import *

class USFuturesDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:

        self.set_start_date(2013, 12, 20) 
        self.set_end_date(2014, 2, 20)
        self.set_cash(100000)
        # Asynchronous to save computation resources
        self.universe_settings.asynchronous = True
        # Override an option universe selection model to select the FOPs
        self.set_universe_selection(GoldFOPUniverseSelectionModel())
        # Handle the FOP trading logic in an alpha model
        self.add_alpha(ConstantFutureOptionsAlphaModel())
        # To order a single contract per insight, use a custom portfolio construction model
        self.set_portfolio_construction(SingleSharePortfolioConstructionModel())
        

class GoldFOPUniverseSelectionModel(OptionUniverseSelectionModel):

    # Daily renewed universe since option contract list is updated on a daily basis
    def __init__(self,) -> None:
        super().__init__(timedelta(1), self.select_fop_symbols)

    def select_fop_symbols(self, algorithm: QCAlgorithm, utcTime: datetime) -> List[Symbol]:
        #  Create the underlying symbol to get the FOP contracts later
        future_symbol = Symbol.create(Futures.Metals.GOLD, SecurityType.FUTURE, Market.COMEX)
        # Get all gold FOP contracts of the front month gold contract expiring within 3 months, since their liquidity is the highest
        future_contract_list = algorithm.future_chain_provider.get_future_contract_list(future_symbol, algorithm.time)
        return [Symbol.create_canonical_option(x) for x in future_contract_list 
                    if x.id.date <= algorithm.time + timedelta(90)]

    def filter(self, option_filter_universe: OptionFilterUniverse) -> OptionFilterUniverse:
        # Filter for the ATM calls that expires latest (same expiry as the underlying)
        # +/-5 strike range buffer for price movement
        return option_filter_universe.back_month().strikes(-5, +5).calls_only();


class ConstantFutureOptionsAlphaModel(AlphaModel):

    # A dictionary to cache the mapped FOP of the underlying Future for filtering wanted option chain data and check if invested
    option_contract_by_future_underlying_contract = {}

    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        insights = []

        for kvp in slice.option_chains:
            # Liquidate underlying Future contract after Option assignment
            underlying_future_contract = kvp.key.underlying
            if algorithm.portfolio[underlying_future_contract].invested:
                algorithm.insights.cancel([underlying_future_contract])
                del self.option_contract_by_future_underlying_contract[underlying_future_contract]

            # Do not repeatly invest in the same underlying's FOP
            chain = [contract for contract in kvp.Value if algorithm.securities[contract.symbol].is_tradable)]
            if not chain or underlying_future_contract in self.option_contract_by_future_underlying_contract:
                continue
            
            # Select the Option contract with the lowest strike price to speculate trade the underlying with lowest cost and highest delta
            contract = sorted(chain, key=lambda x: x.strike)[0]
            insights.append(Insight.price(contract.symbol, contract.expiry + timedelta(1), InsightDirection.UP))
            self.option_contract_by_future_underlying_contract[underlying_future_contract] = contract
        
        return insights


class SingleSharePortfolioConstructionModel(PortfolioConstructionModel):

    def create_targets(self, algorithm: QCAlgorithm, insights: List[Insight]) -> List[PortfolioTarget]:
        targets = []
        for insight in insights:
            if algorithm.securities[insight.symbol].is_tradable:
                # Use integer target to create a portfolio target to trade a single contract
                targets.append(PortfolioTarget(insight.symbol, insight.direction))
        return targets

public class FutureOptionDataAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2020, 1, 28);
        SetEndDate(2020, 6, 1);
        SetCash(100000);
        // Asynchronous to save computation resources
        UniverseSettings.Asynchronous = True;
        // Override an option universe selection model to select the FOPs
        AddUniverseSelection(new GoldFOPUniverseSelectionModel(this));
        // Handle the FOP trading logic in an alpha model
        SetAlpha(new ConstantFutureOptionsAlphaModel());
        // To order a single contract per insight, use a custom portfolio construction model
        SetPortfolioConstruction(new SingleSharePortfolioConstructionModel());
    }
}

public class GoldFOPUniverseSelectionModel : OptionUniverseSelectionModel
{
    // Daily renewed universe since option contract list is updated on a daily basis
    public GoldFOPUniverseSelectionModel(QCAlgorithm algorithm)
        : base(TimeSpan.FromDays(1), _ => OptionChainSymbolSelector(algorithm, _))
    {
    }

    private static IEnumerable<Symbol> OptionChainSymbolSelector(QCAlgorithm algorithm, DateTime utcTime)
    {
        // Create the underlying symbol to get the FOP contracts later
        var futureSymbol = QuantConnect.Symbol.Create(Futures.Metals.Gold, SecurityType.Future, Market.COMEX);
        // Get all gold FOP contracts of the front month gold contract expiring within 3 months, since their liquidity is the highest
        return algorithm.FutureChainProvider.GetFutureContractList(futureSymbol, algorithm.Time)
            .Where(futureContractSymbol => futureContractSymbol.ID.Date <= algorithm.Time + TimeSpan.FromDays(90))
            .Select(futureContractSymbol => QuantConnect.Symbol.CreateCanonicalOption(futureContractSymbol));
    }

    protected override OptionFilterUniverse Filter(OptionFilterUniverse optionFilterUniverse)
    {
        // Filter for the ATM calls that expires latest (same expiry as the underlying)
        // +/-5 strike range buffer for price movement
        return optionFilterUniverse.BackMonth().Strikes(-5, +5).CallsOnly();
    }
}


class ConstantFutureOptionsAlphaModel : AlphaModel
{
    // A dictionary to cache the mapped FOP of the underlying Future for filtering wanted option chain data and check if invested
    private Dictionary<Symbol, OptionContract> optionContractByUnderlyingFutureContract = new Dictionary<Symbol, OptionContract>();
    
    public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
    {
        var insights = new List<Insight>();
        
        foreach (var kvp in slice.OptionChains)
        {
            // Liquidate underlying Future contract after Option assignment
            var underlyingFutureContract = kvp.Key.Underlying;
            if (algorithm.Portfolio[underlyingFutureContract].Invested)
            {
                algorithm.Insights.Cancel(new[] { underlyingFutureContract });
                optionContractByUnderlyingFutureContract.Remove(underlyingFutureContract);
            }
            
            // Do not repeatly invest in the same underlying's FOP
            var chain = kvp.Value.Where(contract => algorithm.Securities[contract.Symbol].IsTradable);
            if (chain.Count() == 0 || optionContractByUnderlyingFutureContract.ContainsKey(underlyingFutureContract))
            {
                continue;
            }

            // Select the Option contract with the lowest strike price to speculate trade the underlying with lowest cost and highest delta
            var contract = chain.MinBy(contract => contract.Strike);
            insights.Add(Insight.Price(contract.Symbol, contract.Expiry.AddDays(1), InsightDirection.Up));
            optionContractByUnderlyingFutureContract.Add(kvp.Key.Underlying, contract);
        }            
        return insights;
    }
}


class SingleSharePortfolioConstructionModel : PortfolioConstructionModel
{
    public override IEnumerable<PortfolioTarget> CreateTargets(QCAlgorithm algorithm, Insight[] insights)
    {
        var targets = new List<PortfolioTarget>();
        foreach (var insight in insights)
        {
            if (algorithm.Securities[insight.Symbol].IsTradable)
            {
                // Use integer target to create a portfolio target to trade a single contract
                targets.Add(new PortfolioTarget(insight.Symbol, (int) insight.Direction));
            }
        }
        return targets;
    }
}