AlgoSeek

from AlgorithmImports import *
from QuantConnect.DataSource import *

class USEquityOptionsDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2020, 6, 1)
        self.set_end_date(2020, 8, 1)
        self.set_cash(100000)
        self.universe_settings.asynchronous = True
        # Requesting data
        self.underlying = self.add_equity("GOOG").symbol
        option = self.add_option("GOOG")
        self.option_symbol = option.symbol
        # To speculate trade the underlying with a low cost, filter for the ATM calls that expiring in the current week
        # -2/+2 strike buffer is given for small price change
        option.set_filter(lambda u: u.include_weeklys().calls_only().strikes(-2, +2).expiration(0, 6))
        
        self.contract = None

    def on_data(self, slice: Slice) -> None:
        # Close the underlying position if the option contract is exercised
        if self.portfolio[self.underlying].invested:
            self.liquidate(self.underlying)

        # Select with the lastest option chain data only
        chain = slice.option_chains.get(self.option_symbol)
        if self.contract and not self.portfolio[self.contract.symbol].invested and chain:
            # Select the call contracts with the furthest expiration (week end)
            furthest_expiry = sorted(calls, key = lambda x: x.expiry, reverse=True)[0].expiry
            furthest_expiry_calls = [contract for contract in calls if contract.expiry == furthest_expiry]
            
            # Get the ATM call for speculate trade with low cost and limited loss
            self.contract = sorted(furthest_expiry_calls, key = lambda x: abs(chain.underlying.price - x.strike))[0]
            self.market_order(self.contract.symbol, 1)
                
                
    def on_securities_changed(self, changes: SecurityChanges) -> None:
        
        for security in changes.added_securities:
            # 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 USEquityOptionsDataAlgorithm : QCAlgorithm
{
    private Symbol _underlying;
    private Symbol _optionSymbol;
    private OptionContract? _contract = None;
    
    public override void Initialize()
    {
        SetStartDate(2020, 6, 1);
        SetEndDate(2020, 8, 1);
        SetCash(100000);
        UniverseSettings.Asynchronous = True;
        // Requesting data
        _underlying = AddEquity("GOOG").Symbol;
        var option = AddOption("GOOG");
        _optionSymbol = option.Symbol;
        // To speculate trade the underlying with a low cost, filter for the ATM calls that expiring in the current week
        // -2/+2 strike buffer is given for small price change
        option.SetFilter((u) => u.IncludeWeeklys().CallsOnly().Strikes(-2, +2).Expiration(0, 7));
    }

    public override void OnData(Slice slice)
    {
        // Close the underlying position if the option contract is exercised
        if (Portfolio[_underlying].Invested)
        {
            Liquidate(_underlying);
        }
        
        // Select with the lastest option chain data only
        if (_contract != None && !Portfolio[_contract.Symbol].Invested && 
            slice.OptionChains.TryGetValue(_optionSymbol, out var chain))
        {
            // Select the call contracts with the furthest expiration (week end)
            var furthestExpiry = calls.OrderByDescending(x => x.Expiry).First().Expiry;
            var furthestExpiryCalls = calls.Where(x => x.Expiry == furthestExpiry).ToList();
            
            // Get the ATM call for speculate trade with low cost and limited loss
            var contract = furthestExpiryCalls.OrderByDescending(x => Math.Abs(chain.Underlying.Price - x.Strike)).Last();
            _contract = contract;
            MarketOrder(contract.Symbol, 1);
        }
    }
    
    public override void OnSecuritiesChanged(SecurityChanges changes)
    {
        foreach (var security in changes.AddedSecurities)
        {
            // Historical data
            var history = History(security.Symbol, 100, Resolution.Minute);
            Debug($"We got {history.Count()} from our history request for {security.Symbol}");
        }
    }
}

from AlgorithmImports import *
from QuantConnect.DataSource import *
from Selection.OptionUniverseSelectionModel import OptionUniverseSelectionModel

class USEquityOptionsDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        
        self.set_start_date(2020, 6, 1)
        self.set_end_date(2020, 8, 1)
        self.set_cash(100000)
        self.universe_settings.asynchronous = True
        # Requesting data
        self.set_universe_selection(EarliestExpiringWeeklyAtTheMoneyCallOptionUniverseSelectionModel())
        
        self.set_alpha(ConstantOptionsAlphaModel())

        self.set_portfolio_construction(SingleSharePortfolioConstructionModel())
        
        
class EarliestExpiringWeeklyAtTheMoneyCallOptionUniverseSelectionModel(OptionUniverseSelectionModel):

    def __init__(self) -> None:
        # Daily update with the select_option_chain_symbols function
        super().__init__(timedelta(1), self.select_option_chain_symbols)

    def select_option_chain_symbols(self, utcTime: datetime) -> List[Symbol]:
        # Always select only GOOG options as our focus
        return [ Symbol.create("GOOG", SecurityType.OPTION, Market.USA) ]

    def filter(self, filter: OptionFilterUniverse) -> OptionFilterUniverse:
        # To speculate trade the underlying with a low cost, filter for the ATM calls that expiring in the current week
        # -1/+1 strike buffer is given for small price change
        return (filter.weeklys_only()
                      .calls_only()
                      .strikes(-1, -1)
                      .expiration(0, 7))  
        

class ConstantOptionsAlphaModel(AlphaModel):

    underlying = None
    contract = None

    def update(self, algorithm: QCAlgorithm, slice: Slice) -> List[Insight]:
        
        insights = []
        
        # Liquidate the underlying if the option is being exercised/assigned
        if algorithm.portfolio[self.underlying].invested:
            insights.append(Insight.price(self.underlying, timedelta(days=7), InsightDirection.FLAT))

        if self.contract is not None and algorithm.portfolio[self.contract.symbol].invested:
            return insights

        # Get the ATM call for speculate trade with low cost and limited loss that expires at week end
        for kvp in slice.option_chains:
            chain = kvp.Value
            expiry = max(x.expiry for x in chain)
            self.contract = sorte([x for x in chain if x.expiry == expiry],
                                               key=lambda x: abs(x.strike - x.underlying_last_price))[0]
            insights.append(Insight.price(self.contract.symbol, self.contract.expiry + timedelta(days=1), InsightDirection.UP))
        
        return insights
        
    def on_securities_changed(self, algorithm: QCAlgorithm, changes: SecurityChanges) -> None:
        for security in changes.added_securities:
            if security.type == SecurityType.EQUITY:
                self.underlying = security.symbol
            else:
                # Historical data
                history = algorithm.history(security.symbol, 10, Resolution.MINUTE)
                algorithm.debug(f"We got {len(history)} from our history request for {security.symbol}")


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:
                targets.append(PortfolioTarget(insight.symbol, insight.direction))
        return targets

public class USEquityOptionsDataAlgorithm : QCAlgorithm
{        
    public override void Initialize()
    {
        SetStartDate(2020, 6, 1);
        SetEndDate(2020, 8, 1);
        SetCash(100000);
        UniverseSettings.Asynchronous = True;
        // Requesting data
        SetUniverseSelection(new EarliestExpiringWeeklyAtTheMoneyCallOptionUniverseSelectionModel());
        
        SetAlpha(new ConstantOptionsAlphaModel());
        
        SetPortfolioConstruction(new SingleSharePortfolioConstructionModel());
    }
}   
    
class EarliestExpiringWeeklyAtTheMoneyCallOptionUniverseSelectionModel : OptionUniverseSelectionModel
{
    // Daily update with the SelectOptionChainSymbols function
    public EarliestExpiringWeeklyAtTheMoneyCallOptionUniverseSelectionModel()
            : base(TimeSpan.FromDays(1), SelectOptionChainSymbols) {}
    
    private static IEnumerable<Symbol> SelectOptionChainSymbols(DateTime utcTime)
    {
        // Select only GOOG options as our focus
        return new[] {QuantConnect.Symbol.Create("GOOG", SecurityType.Option, Market.USA)};
    }

    protected override OptionFilterUniverse Filter(OptionFilterUniverse filter)
    {
        // To speculate trade the underlying with a low cost, filter for the ATM calls that expiring in the current week
        // -2/+2 strike buffer is given for small price change
        return filter
            .Strikes(-1, -1)
            .Expiration(0, 7)
            .WeeklysOnly()
            .CallsOnly();
    }
}
    
class ConstantOptionsAlphaModel : AlphaModel
{ 
    private Symbol? _underlying = None;
    private OptionContract? _contract = None;
    
    public override IEnumerable<Insight> Update(QCAlgorithm algorithm, Slice slice)
    {
        var insights = new List<Insight>();
        
        // Liquidate the underlying if the option is being exercised/assigned
        if (algorithm.Portfolio[_underlying].Invested)
        {
            insights.Add(Insight.Price(_underlying, TimeSpan.FromDays(7), InsightDirection.Flat));
        }
            
        if (_contract != None && algorithm.Portfolio[_contract.Symbol].Invested)
        {
            return insights;
        }
        
        // Get the ATM call for speculate trade with low cost and limited loss that expires at week end
        foreach (var kvp in slice.OptionChains)
        {
            var chain = kvp.Value;
            var expiry = chain.Max(x => x.Expiry);
            _contract = chain.Where(x => x.Expiry == expiry)
                .OrderBy(x => Math.Abs(x.Strike - x.UnderlyingLastPrice))
                .First();
            insights.Add(Insight.Price(_contract.Symbol, _contract.Expiry + TimeSpan.FromDays(1), InsightDirection.Up));
        }    
        return insights;
    }

    public override void OnSecuritiesChanged(QCAlgorithm algorithm, SecurityChanges changes)
    {
        foreach (var security in changes.AddedSecurities)
        {
            if (security.Type == SecurityType.Equity)
            {
                _underlying = security.Symbol;
            }
            else {
                // Historical data
                var history = algorithm.History(security.Symbol, 100, Resolution.Minute);
                algorithm.Debug($"We got {history.Count()} from our history request for {security.Symbol}");    
            }
        }
    }
}
    
    
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)
            {
                targets.Add(new PortfolioTarget(insight.Symbol, (int) insight.Direction));
            }
        }
        return targets;
    }
}