Protective put strategy error cannot instantiate an open generic type

Here's the code

from AlgorithmImports import *
class MorningStarDataAlgorithm(QCAlgorithm):

    def Initialize(self):
        self.SetStartDate(2018, 1, 1) # Cambiar fechas en las que quieres que corra
        self.SetEndDate(2023, 11, 1)
        self.SetCash(100000) 

        self.UniverseSettings.Resolution = Resolution.Daily

        option = self.AddOption("SPY")
        self.symbol = option.Symbol
        option.SetFilter(-30, 30,timedelta(0), timedelta(90))

        self.put = None
        self.SetBenchmark(self.symbol.Underlying)

        # Use the following method for a Framework Algorithm
        self.etf_constituents = []
        self.universe_etf = self.Universe.ETF("SPY", Market.USA,
            self.UniverseSettings, self.ETFConstituentsFilter)
        

        self.num_symbols = 2 # Número de acciones en el portafolio
        self.AddUniverse(self.universe_etf)
        
        self.securities = []
        #self.AddRiskManagement(MaximumDrawdownPercentPerSecurity())
        #self.AddRiskManagement(MaximumDrawdownPercentPortfolio(0.10, True))
        #self.AddRiskManagement(TrailingStopRiskManagementModel(0.40))

        self.Schedule.On(self.DateRules.On(self.EndDate), 
                 self.TimeRules.At(15, 55), 
                 self.Liquidate)
        
        self.Schedule.On(self.DateRules.MonthStart(self.symbol),
                 self.TimeRules.AfterMarketOpen(self.symbol),
                 self.OptionReebalance)

        self.changes = None

    def ETFConstituentsFilter(self, constituents: List[ETFConstituentData]) -> List[Symbol]:
        selected = sorted([c for c in constituents if c.Weight],
            key=lambda c: c.Weight, reverse=True)[:self.num_symbols]
        self.etf_constituents = [c.Symbol for c in selected]  # Store the selected constituents
        return self.etf_constituents

    def OnData(self, data):
        # if we have no changes, do nothing
        if self.changes is None: return

        # liquidate removed securities
        for security in self.changes.RemovedSecurities:
            if security.Invested:
                self.Liquidate(security.Symbol)
                self.Debug("Liquidated Stock: " + str(security.Symbol.Value))

        # we want 50% allocation in each security in our universe
        for security in self.changes.AddedSecurities:
            self.SetHoldings(security.Symbol, 1/self.num_symbols)
            self.Debug("Bought Stock: " + str(security.Symbol.Value))

        self.changes = None
    
    def OptionReebalance(self):
        # If holding a put, sell it
        if self.put and self.Portfolio[self.put].Invested:
            self.Sell(self.put, 1)
        
        # Find OTM Call 
        # We want it to expire in 3 months and to have a strike price 30% below current mkt price
        chain = DataDictionary().OptionChains.get(self.symbol)
        if not chain:
            return
            
        expiry = max([x.Expiry for x in chain])
        put_contracts = sorted([x for x in chain
            if x.Right == OptionRight.Put and x.Expiry == expiry],
            key=lambda x: chain.Underlying.Price - (0.30 * chain.Underlying.Price))

        if not put_contracts:
            print('No put contracts found with the specified characteristics')
            return

        otm_put = put_contracts[0]
        print(str(otm_put))
        protective_put = OptionStrategies.ProtectivePut(self.symbol, otm_put.Strike, expiry)
        print(str(protective_put))
        self.Buy(protective_put, 1)
        self.put = otm_put.Symbol

    def OnSecuritiesChanged(self, changes):
        self.changes = changes

Hi @renata 

The error is in view that OptionsChains can be accessed via slice in the algorithm.

One was to pass slice object to OptionRebalance method is to update it through the OnData method.

# In Initialize method:
self.slice = None

# In Ondata method:
def OnData(self, slice):
	self.slice = slice
	. . . . rest of the code

# In OptionRebalance method:
def OptionReebalance(self):
	if self.put and self.Portfolio[self.put].Invested:
	self.Sell(self.put, 1)
	
	if self.slice is None: return
	chain = self.slice.OptionChains[self.symbol]
	
	if not chain: return
	. . . . rest of the code

As per your problem case to get put with a strike price 30% below the current market price you can use something like this:

expiry = max([x.Expiry for x in chain])
put_contracts = sorted([x for x in chain
if x.Right == OptionRight.Put and x.Expiry == expiry],
key=lambda x: x.Strike - 0.30 * chain.Underlying.Price)