Runtime Error: KeyNotFoundException : 'SPY'

Would this error be due to a data problem or a code problem?

I cant seem to attatch a backtest here is the code snippet

class SupportAndResistance(QCAlgorithm):
    UnderlyingTicker = 'SPY'
    openingBar = None;
    def Initialize(self):
            self.SetStartDate(2020, 1, 1)
            self.SetEndDate(2020,1,31)
            self.SetCash(100000)
            self.SetWarmUp(timedelta(7)) # Warm up 7 days of data.
            equity = self.AddEquity(self.UnderlyingTicker, Resolution.Minute)
            equity.SetDataNormalizationMode(DataNormalizationMode.Raw)

            option = self.AddOption(self.UnderlyingTicker)
            self.Consolidate(self.UnderlyingTicker, timedelta(1), self.OnDataConsolidated)

            self.option_symbol = option.Symbol
    
            # set our strike/expiry filter for this option chain
            option.SetFilter(lambda u: u.IncludeWeeklys().Strikes(0, 10).Expiration(timedelta(0), timedelta(7)))
            # option.SetFilter(lambda u: (u.Strikes(-2, +2)
            #                              # Expiration method accepts TimeSpan objects or integer for days.
            #                              # The following statements yield the same filtering criteria
            #                              .Expiration(0, 180)))
            #                              #.Expiration(TimeSpan.Zero, TimeSpan.FromDays(180))))
            # self.Schedule.On(self.DateRules.EveryDay(self.UnderlyingTicker), self.TimeRules.At(13, 30), self.ClosePositions)

            # use the underlying equity as the benchmark
            self.SetBenchmark(equity.Symbol)
            
    def OnData(self,slice):
        if self.openingBar == None: return
        if not self.Portfolio.Invested:
            chain = slice.OptionChains.GetValue(self.option_symbol)
            if chain is None:
                return
            
            contracts_put = sorted(sorted(sorted(chain, \
                key = lambda x: abs(chain.Underlying.Price - x.Strike)), \
                key = lambda x: x.Expiry, reverse=False), \
                key = lambda x: x.Right, reverse=True)
                
            contracts_call = sorted(sorted(sorted(chain, \
                key = lambda x: abs(chain.Underlying.Price - x.Strike)), \
                key = lambda x: x.Expiry, reverse=False), \
                key = lambda x: x.Right, reverse=False)
                
            if len(contracts_put) == 0: return
            self.symbol_put = contracts_put[0].Symbol
            
            if len(contracts_call) == 0: return
            self.symbol_call = contracts_call[0].Symbol
            
            if slice[self.UnderlyingTicker].Close >= (self.openingBar.High - .10):
                self.MarketOrder(self.symbol_put, 10)
            
        if self.Portfolio.Invested:
            option_invested = [x.Key.Value for x in self.Portfolio if x.Value.Invested and x.Value.Type==SecurityType.Option]
            # Print to log
            for contract in option_invested:
                self.c = contract
                quantity = self.Portfolio[contract].Quantity
                lastPrice = self.Securities[contract].Price
                if self.Securities[contract].BidPrice > (self.Securities[contract].Holdings.AveragePrice + .10):
                    self.Debug('Here')
                    self.Liquidate(contract)
                    self.openingBar = None
                if self.Securities[contract].Holdings.AveragePrice < self.Securities[contract].BidPrice - .20:
                    self.Debug('Here')
                    self.Liquidate(contract)
                    self.openingBar = None
                
                
        
        
    def OnOrderEvent(self, orderEvent):
        self.Log(str(orderEvent))
        
    def OnDataConsolidated(self, bar):
        self.openingBar = bar

Hi Nicholas,

If I've read your code correctly, I think this is roughly what it will do on any given day once the market order condition is hit:

Market order submitted (I'm assuming here that the 100 shares order is submitted and not the 101 shares order. Did you really mean to have two different quantities?)
OnOrderEvent runs for submission of market order (this will return early as fill quantity == 0)
Market order filled
OnOrderEvent runs for fill of market order, submitting 1 stop market order and 1 limit order
OnOrderEvent runs for the submission of the 1 stop market order (this will return early as fill quantity == 0)
OnOrderEvent runs for the submission of the 1 limit order (this will return early as fill quantity == 0)
[...] Time passes, assume now we hit the Take Profit price
Limit order filled for 50 shares
OnOrderEvent runs for the fill of the limit order. As fill quantity != 0, the function does not return early and instead creates 1 new stop market order and 1 new limit order. The reference price used for these two is the fill price of the limit order.
OnOrderEvent is run once for each of the submissions of the order, returns each time as fill quantity == 0
[...] Time passes, and the cycle repeats

At point #9, you have a really weird situation:

Long 50 shares at the initial price from #3. Let's assume it's $100.
1 remaining stop order (from #5) for -100 shares at $95.
1 new limit order for -50 shares at $110 * 1.1 = $121.
1 new stop order for -100 shares at $110 * 0.95 = $104.5.

What happens if the price now drops below $104.5? You only have 50 shares and you're trying to sell 100 - that's not going to work. What happens if the price goes up to $121? You will hit your limit order and sell the remaining shares, but you'll still have your 2 stop orders alive. I hope this illustrates why the algorithm is not behaving as you expect it to. There are a myriad of ways to solve these issues but you'll have to think about the best way. General tips:

Be really careful and check what type of order the OnOrderEvent refers to by getting the order by its ID (as you've done already) and then checking its .Type property
Make sure you cancel any outstanding limit or stop orders when they are no longer needed
Think carefully about how a -50 share take profit works and ask yourself if you're better off either selling all 100 shares or submitting two take profits for the same amount, one slightly above the other, so that you have a chance to sell off your entire position at some point
Python doesn't need semicolons, get rid of them
When submitting algorithms to the forums, save people some time by removing the stuff that isn't crucial to how the algorithm operates (such as logs, comments and non-essential functionality)

Now onto your second question. How do you prevent the algorithm from trading more than once per day? This can be achieved in many different ways - one of the easiest ones is to simply store the date of the last trade somewhere in your code and check the current date against that saved date. If they're identical, then you don't trade.

The material on this website is provided for informational purposes only and does not constitute an offer to sell, a solicitation to buy, or a recommendation or endorsement for any security or strategy, nor does it constitute an offer to provide investment advisory services by QuantConnect. In addition, the material offers no opinion with respect to the suitability of any security or specific investment. QuantConnect makes no guarantees as to the accuracy or completeness of the views expressed in the website. The views are subject to change, and may have become unreliable for various reasons, including changes in market conditions or economic circumstances. All investments involve risk, including loss of principal. You should consult with an investment professional before making any investment decisions.

Platform

Radically Open-Source Algorithmic Trading Engine

Join Our Discord Channel

Quarterly Open-Source Trading Competition

Draft Discussions

Bookmarked Discussions

SEARCH DISCUSSIONS

361,600 Quants.

VOTE FOR UPCOMING FEATURES

JOIN OUR Community MAILING LIST

IN THIS RESEARCH

PARTICIPANTS

Actions

Join QuantConnect for Free