Unique variables for each ticker

I figured out how to store the unique variables but now I am stuck trying to implement a buy call option into my algo. see attached file. I have tried over 20 different ways to buy options with it but nothing works. please help

from datetime import timedelta
from AlgorithmImports import *


### <summary>
### Example structure for structuring an algorithm with indicator and consolidator data for many tickers.
### </summary>
### <meta name="tag" content="consolidating data" />
### <meta name="tag" content="indicators" />
### <meta name="tag" content="using data" />
### <meta name="tag" content="strategy example" />
class MultipleSymbolConsolidationAlgorithm(QCAlgorithm):
    
    # Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
    def Initialize(self):
        
        # This is the period of bars we'll be creating
        BarPeriod = TimeSpan.FromMinutes(10)
        # This is the period of our sma indicators
        SimpleMovingAveragePeriod = 10
        # This is the number of consolidated bars we'll hold in symbol data for reference
        RollingWindowSize = 10
        # Holds all of our data keyed by each symbol
        self.Data = {}
        # Contains all of our equity symbols
        EquitySymbols = ["AAPL", "TSLA"]
        # Set entry time
        self.entryTime = self.UtcTime
        # initialize the option contract with empty string
        self.contract = str()
        self.contractsAdded = set()
        
        # parameters ------------------------------------------------------------
        self.DaysBeforeExp = 2 # number of days before expiry to exit
        self.DTE = 25 # target days till expiration
        self.OTM = 0.01 # target percentage OTM of put
        self.lookbackIV = 150 # lookback length of IV indicator
        self.IVlvl = 0.5 # enter position at this lvl of IV indicator
        self.percentage = 0.9 # percentage of portfolio for underlying asset
        self.options_alloc = 90 # 1 option for X num of shares (balanced would be 100)
        # ------------------------------------------------------------------------
        # Contains all of our forex symbols
        ##ForexSymbols =["EURUSD", "USDJPY", "EURGBP", "EURCHF", "USDCAD", "USDCHF", "AUDUSD","NZDUSD"]
        
        self.SetStartDate(2017, 7, 1)
        self.SetEndDate(2017, 8, 1)
        
        # initialize our equity data
        for symbol in EquitySymbols:
            equity = self.AddEquity(symbol)
            self.Data[symbol] = SymbolData(equity.Symbol, BarPeriod, RollingWindowSize)
            symbol = self.AddEquity(symbol, Resolution.Minute).Symbol
            option = self.AddOption(symbol)
            option.SetFilter(lambda universe: universe.IncludeWeeklys().Strikes(1, 8).Expiration(timedelta(1), timedelta(13)))

        
        # initialize our forex data 
        ##for symbol in ForexSymbols:
            ##forex = self.AddForex(symbol)
            ##self.Data[symbol] = SymbolData(forex.Symbol, BarPeriod, RollingWindowSize)

        # loop through all our symbols and request data subscriptions and initialize indicator
        
        for symbol, symbolData in self.Data.items():
            
            # define the indicator
            symbolData.SMA = SimpleMovingAverage(self.CreateIndicatorName(symbol, "SMA" + str(SimpleMovingAveragePeriod), Resolution.Minute), SimpleMovingAveragePeriod)
            # define a consolidator to consolidate data for this symbol on the requested period
            symbolData.Change = self.ROCP(symbol, 1440, Resolution.Minute)
            consolidator = TradeBarConsolidator(BarPeriod) if symbolData.Symbol.SecurityType == SecurityType.Equity else QuoteBarConsolidator(BarPeriod)
            # write up our consolidator to update the indicator
            consolidator.DataConsolidated += self.OnDataConsolidated
            # we need to add this consolidator so it gets auto updates
            self.SubscriptionManager.AddConsolidator(symbolData.Symbol, consolidator)

    def OnDataConsolidated(self, sender, bar):
        
        self.Data[bar.Symbol.Value].SMA.Update(bar.Time, bar.Close)
        self.Data[bar.Symbol.Value].Bars.Add(bar)

    # OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
    # Argument "data": Slice object, dictionary object with your stock data 
    def OnData(self, data):
        #option_invested = [x.Key for x in self.Portfolio if x.Value.Invested and x.Value.Type==SecurityType.Option] # check if we already have open options postiions
        if self.Portfolio.Invested:
            if (self.UtcTime - self.entryTime) >= timedelta(hours = 23.8): #Sell after set hours
                self.Liquidate() #will need to do something else later on
        if self.Time.minute == 30 and self.Time.hour == 13:
            self.BuyCall(data)
        # loop through each symbol in our structure
            for symbol in self.Data.keys():
                symbolData = self.Data[symbol]
            # this check proves that this symbol was JUST updated prior to this OnData function being called
                ##if symbolData.IsReady() and symbolData.WasJustUpdated(self.Time):
                if symbolData.WasJustUpdated(self.Time):
                    
                    #self.BuyCall(data)

                    
                    
                    
                    #self.MarketOrder(symbol, 1)
                    #self.SetHoldings(symbol, 0.02, True)
                    self.Log(str(symbolData.Change) + " " + str(symbol) + " first")
                    self.entryTime = self.UtcTime

    # End of a trading day event handler. This method is called at the end of the algorithm day (or multiple times if trading multiple assets).
    # Method is called 10 minutes before closing to allow user to close out position.
    
    
    # Buy Call ------------------------------------------------------------
    def BuyCall(self, data):
        # get option data
        if self.contract == str():
            self.contract = self.OptionsFilter(data)    

    def OptionsFilter(self, data):
        ''' OptionChainProvider gets a list of option contracts for an underlying symbol at requested date.
            Then you can manually filter the contract list returned by GetOptionContractList.
            The manual filtering will be limited to the information included in the Symbol
            (strike, expiration, type, style) and/or prices from a History call '''
        for symbol, symbolData in self.Data.items():
            #symbolData = self.Data[symbol]
            contracts = self.OptionChainProvider.GetOptionContractList(self.symbol, data.Time) # try symbol etc without the for loop
            self.underlyingPrice = self.Securities[self.symbol].Price
            # filter the out-of-money put options from the contract list which expire close to self.DTE num of days from now
            otm_calls = [i for i in contracts if i.ID.OptionRight == OptionRight.Call and
                                                self.underlyingPrice - i.ID.StrikePrice > self.OTM * self.underlyingPrice and
                                                self.DTE - 8 < (i.ID.Date - data.Time).days < self.DTE + 8]
            if len(otm_calls) > 0:
                # sort options by closest to self.DTE days from now and desired strike, and pick first
                contract = sorted(sorted(otm_calls, key = lambda x: abs((x.ID.Date - self.Time).days - self.DTE)),
                                                        key = lambda x: self.underlyingPrice - x.ID.StrikePrice)[0]
                if contract not in self.contractsAdded:
                    self.contractsAdded.add(contract)
                    # use AddOptionContract() to subscribe the data for specified contract
                    self.AddOptionContract(contract, Resolution.Minute)
                return contract
            else:
                return str()
    
    # End Buy Call ------------------------------------------------------------
    
    
    def OnEndOfDay(self, symbol):
        
        i = 0
        for symbol in sorted(self.Data.keys()):
            symbolData = self.Data[symbol]
            # we have too many symbols to plot them all, so plot every other
            i += 1
            if symbolData.IsReady() and i%2 == 0:
                self.Plot(symbol, symbol, symbolData.SMA.Current.Value)
    
       
class SymbolData(object):
    
    def __init__(self, symbol, barPeriod, windowSize):
        self.Symbol = symbol
        # The period used when population the Bars rolling window
        self.BarPeriod = barPeriod
        # A rolling window of data, data needs to be pumped into Bars by using Bars.Update( tradeBar ) and can be accessed like:
        # mySymbolData.Bars[0] - most first recent piece of data
        # mySymbolData.Bars[5] - the sixth most recent piece of data (zero based indexing)
        self.Bars = RollingWindow[IBaseDataBar](windowSize)
        # The simple moving average indicator for our symbol
        self.SMA = None
        self.Change = 0
  
    # Returns true if all the data in this instance is ready (indicators, rolling windows, ect...)
    def IsReady(self):
        return self.Bars.IsReady and self.SMA.IsReady

    # Returns true if the most recent trade bar time matches the current time minus the bar's period, this
    # indicates that update was just called on this instance
    def WasJustUpdated(self, current):
        return self.Bars.Count > 0 and self.Bars[0].Time == current - self.BarPeriod      

Hi Garrison

The algorithm is missing the Order method (e.g. self.MarketOrder()), as well as the specific underlying symbol self.symbol in your OptionFilter method. Please refer to this and this example algorithm in our repo for trading options, as well as this thread on AddOptionContract usage.

Best
Louis