class USEquityOptionsDataAlgorithm(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2020, 6, 1)
        self.set_end_date(2021, 6, 1)
        self.set_cash(100000)
        self.universe_settings.asynchronous = True
        # Request GOOG option data
        option = self.add_option("GOOG")
        self.option_symbol = option.symbol
        # Set our strike/expiry filter for this option chain
        option.set_filter(-2, +2, 0, 180)

namespace QuantConnect
{
    public class USEquityOptionsDataAlgorithm : QCAlgorithm
    {
        private Symbol _optionSymbol;
        
        public override void Initialize()
        {
            SetStartDate(2020, 6, 1);
            SetEndDate(2021, 6, 1);
            SetCash(100000);
            UniverseSettings.Asynchronous = true;
            // Request GOOG option data
            var option = AddOption("GOOG");
            _optionSymbol = option.Symbol;
            // Set our strike/expiry filter for this option chain
            option.SetFilter(-2, +2, 0, 180);
        }
    }
}

def on_data(self, slice: Slice) -> None:
    # Get the wanted option chain with the canonical symbol
    chain = slice.option_chains.get(self.option_symbol)
    if chain:
        # Iterate the option contracts in chain
        for contract in chain:
            self.log(f"{contract.symbol} price at {slice.time}: {contract.last_price}")

public override void OnData(Slice slice)
{
    // Get the wanted option chain with the canonical symbol
    if (slice.OptionChains.TryGetValue(_optionSymbol, out var chain))
    {
        // Iterate the option contracts in chain
        foreach (var contract in chain)
        {
            Log($"{contract.Symbol} price at {slice.Time}: {contract.LastPrice}");
        }
    }
}

def on_data(self, slice: Slice) -> None:
    # Iterate all option chains of all symbols
    for canonical_symbol, chain in slice.option_chains.items():
        # Iterate the option contracts in chain
        for contract in chain:
            self.log(f"{contract.symbol} price at {slice.time}: {contract.last_price}")

public override void OnData(Slice slice)
{
    // Iterate all option chains of all symbols
    foreach (var kvp in slice.OptionChains)
    {
        var canonicalSymbol = kvp.Key;
        var chain = kvp.Value;
        // Iterate the option contracts in chain
        foreach (var contract in chain)
        {
            Log($"{contract.Symbol} price at {slice.Time}: {contract.LastPrice}");
        }
    }
}

# DataFrame of trade and quote data
history_df = self.history(contract.symbol, 100, Resolution.MINUTE)

# DataFrame of open interest data
history_oi_df = self.history(OpenInterest, contract.symbol, 100, Resolution.MINUTE)

# TradeBar objects
history_trade_bars = self.history[TradeBar](contract.symbol, 100, Resolution.MINUTE)

# QuoteBar objects
history_quote_bars = self.history[QuoteBar](contract.symbol, 100, Resolution.MINUTE)

# OpenInterest objects
history_oi = self.history[OpenInterest](contract.symbol, 100, Resolution.MINUTE)

// TradeBar objects 
var historyTradeBars = History(contract.Symbol, 100, Resolution.Minute);

// QuoteBar objects 
var historyQuoteBars = History<QuoteBar>(contract.Symbol, 100, Resolution.Minute);

// OpenInterest objects
var historyOpenInterest = History<OpenInterest>(contract.Symbol, 100, Resolution.Minute);

qb = QuantBook()
option = qb.add_option("GOOG") 
option.set_filter(-2, 2, 0, 90)
history = qb.option_history(option.symbol.underlying, datetime(2020, 6, 1), datetime(2020, 6, 5))
history_df = history.data_frame
expiries = history.get_expiry_dates() 
strikes = history.get_strikes()

var qb = new QuantBook();
var option = qb.AddOption("GOOG");
option.SetFilter(-2, 2, 0, 90);
var history = qb.OptionHistory(option.Symbol, new DateTime(2020, 6, 1), new DateTime(2020, 6, 5));

var contracts = history
    .SelectMany(x => x.OptionChains.SelectMany(y => y.Value.Contracts.Keys))
    .Distinct().ToList();
var expiries = contracts.Select(x => x.ID.Date).Distinct().ToList();
var strikes = contracts.Select(x => x.ID.StrikePrice).Distinct().ToList();

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}")

using QuantConnect.DataSource;

namespace QuantConnect
{
    public class USEquityOptionsDataAlgorithm : QCAlgorithm
    {
        private Symbol _underlying;
        private Symbol _optionSymbol;
        private OptionContract? _contract = null;
        
        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 != null && !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

using QuantConnect.DataSource;

namespace QuantConnect.Algorithm.CSharp
{
    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 = null;
        private OptionContract? _contract = null;
        
        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 != null && 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;
        }
    }
}