I am trying to figure out why this just runs endlessly.  No error is specified and nothing appears in the console when I try running the back test.  

See below: 

class NadionResistanceShield(QCAlgorithm):

#class DataConsolidationAlgorithm(QCAlgorithm):
   def Initialize(self):
       self.SetStartDate(2021, 1, 1)  # Set Start Date
      # self.SetEndDate(2019, 1, 3)
       self.SetCash(25000)  # Set Strategy Cash

       self.tickers = ["ADSK","AMD","AMZN","ASML","ATLC","DXCM","ETSY","EXPI","FB","FND","HALO","JYNT","KNSL","MED","MPWR","NFLX","PYPL","SKY","VEEV"]
      
       self.symbolDataBySymbol = {}
       self.MarketCaps = ["SPY", "TLT", "GLD", "VNQ"]# "QQQ"]#,"MDY","IWM"]
       self.marketDataBySymbol = {}
       
       self.volatilityDataBySymbol = {}
       self.vix = ["VIX"]
       
       self.trade = True
       self.atr=[]
       
       self.spy = "SPY"
       self.iwm = "IWM"
       self.mdy = "MDY"
       self.qqq = "QQQ"
       self.vix = "VIX"
       # Before the open
       
       # Trailing distance in $
       self.trail_dist = 10  
       
       # Declare an attribute that we shall use for storing our
       # stop loss ticket. 
       self.sl_order = None
       # Declare an attribute that we will use to store the last trail level
       # used. We will use this to decide whether to move the stop
       self.last_trail_level = None
  
       
       
       for symbolmark in self.MarketCaps:
           symbol = self.AddEquity(symbolmark, Resolution.Hour).Symbol
           
           sma50 = self.SMA(symbol, 50, Resolution.Daily, Field.Close)
           sma200 = self.SMA(symbol, 200, Resolution.Daily, Field.Close)
           rsi = self.RSI(symbol, 14, Resolution.Daily)
           
           self.marketDataBySymbol[symbol] = symbolMarkData(symbol, sma50, sma200, rsi)
       
       for symbolvol in self.vix:
           symbol = self.AddEquity(symbolmark, Resolution.Hour).Symbol
           rsi = self.RSI(symbol, 14, Resolution.Daily)
           wilr = self.WILR(symbol, 14, Resolution.Daily)
           
           self.volatilityDataBySymbol[symbol] = symbolvolData(symbol, rsi, wilr)
       
       
       for symbol in self.tickers:
           self.AddEquity(symbol, Resolution.Hour)
           
           '''For the below 3 EMA's, you can convert them to 4H bars using the colidator method'''
           
           ema10 = self.EMA(symbol, 10, Resolution.Hour, Field.Close)
           sma200 = self.SMA(symbol, 200, Resolution.Daily, Field.Close)
           sma7 = self.SMA(symbol, 7, Resolution.Hour, Field.Close)
           sma20 = self.SMA(symbol, 20, Resolution.Daily, Field.Close)
           self.sma = self.SMA(symbol, 20, Resolution.Hour, Field.Close)
           sma50 = self.SMA(symbol, 50, Resolution.Daily, Field.Close)
           ema20 = self.EMA(symbol, 20, Resolution.Hour, Field.Close)
           ema50 = self.EMA(symbol, 50, Resolution.Hour, Field.Close)
           rsi = self.RSI(symbol, 14, Resolution.Daily)
           wilr = self.WILR(symbol, 14, Resolution.Daily)
           wilr_fast = self.WILR(symbol, 10, Resolution.Daily)
           
           
           
           atr = self.ATR(symbol, 20, Resolution.Daily)
           self.atr.append(self.ATR(symbol, 7, Resolution.Daily))
       
           self.high = self.MAX(symbol, 5, Resolution.Daily, Field.High)
           self.longtermfast = self.MAX(symbol, 40, Resolution.Daily, Field.Low)
           self.longtermslow = self.MAX(symbol, 50, Resolution.Daily, Field.Low)
           self.low = self.MIN(symbol, 5, Resolution.Daily, Field.Low)
           self.stoplow = self.MIN(symbol, 20, Resolution.Daily, Field.Low)
           
           self.sma.Updated += self.OnSMA
           
           '''Consolidator method'''
           smaConsolidate = ExponentialMovingAverage(20, MovingAverageType.Simple)
           # create the 4 hour data consolidator
           fourHourConsolidator = TradeBarConsolidator(timedelta(hours=4))
           self.SubscriptionManager.AddConsolidator(symbol, fourHourConsolidator)
           # register the 4 hour consolidated bar data to automatically update the indicator
           self.RegisterIndicator(symbol, smaConsolidate, fourHourConsolidator)
           
           symbolData = SymbolData(symbol, ema10, sma20, sma200, sma7, sma50, ema20, ema50, rsi, wilr, wilr_fast, atr, smaConsolidate)
           self.symbolDataBySymbol[symbol] = symbolData
       
       
       
       self.spy = self.AddEquity("SPY", Resolution.Daily)
       
       # Before the open
       self.Schedule.On(self.DateRules.EveryDay("SPY"), 
               self.TimeRules.AfterMarketOpen("SPY", -5), 
               Action(self.beforeTheOpen))
       
       

       
       self.Schedule.On(self.DateRules.EveryDay("SPY"),
               self.TimeRules.AfterMarketOpen("SPY", 30), self.buySignals)         
       
       self.Schedule.On(self.DateRules.EveryDay("SPY"),
               self.TimeRules.AfterMarketOpen("SPY", 30), self.sellSignals)
       
       
                
       self.Schedule.On(self.DateRules.EveryDay("SPY"),
               self.TimeRules.BeforeMarketClose("SPY", 10), self.buySignals)
               
       self.Schedule.On(self.DateRules.EveryDay("SPY"),        
               self.TimeRules.BeforeMarketClose("SPY", 10), self.sellSignals)
               
               
       self.Schedule.On(self.DateRules.EveryDay("SPY"),        
               self.TimeRules.BeforeMarketClose("SPY", 10), self.stopLoss)
               
       self.Schedule.On(self.DateRules.EveryDay("SPY"),        
               self.TimeRules.AfterMarketOpen("SPY", 10), self.stopLoss)
                
   
       #self.AddRiskManagement(TrailingStopRiskManagementModel(0.04))
       self.SetWarmUp(timedelta(days=180))
   
   def beforeTheOpen(self):
       self.Log("SPY: {0}".format(self.spy.Close))
       #for i in range(len(self.tickers)):
       #    self.Log("ATR: {0}".format(self.atr[i].Current.Value))
           
   
           
   
   def OnData(self, data):
       return
        # We need to check that the symbol has data before trying to access
       # OHLC. Otherwise an exception is raised if the data is missing. 
       
       
       
   def tradeStart(self):
       self.trade = True
   def tradeEnd(self):
       self.trade = False
   
   def OnOrderEvent(self, OrderEvent):
       '''Event when the order is filled. Debug log the order fill. :OrderEvent:'''
       if OrderEvent.FillQuantity == 0:
           return
       # Get the filled order
       Order = self.Transactions.GetOrderById(OrderEvent.OrderId)
       
       # Log the filled order details
       self.Log("ORDER NOTIFICATION >> {} >> Status: {} Symbol: {}. Quantity: "
                   "{}. Direction: {}. Fill Price {}".format(str(Order.Tag),
                                                  str(OrderEvent.Status),
                                                  str(OrderEvent.Symbol),
                                                  str(OrderEvent.FillQuantity),
                                                  str(OrderEvent.Direction),
                                                  str(OrderEvent.FillPrice)))
       #self.Log(OrderEvent.FillPrice - symbolData.atr.Current.Value))
   def buySignals(self):
       if self.trade == False:
           return
       
        # Return if benchmark is below SMA
       for symbolmark, symbolMarkData in self.marketDataBySymbol.items():
           if (self.Securities[symbolmark].Close >  symbolMarkData.rsi.Current.Value > 50):
               return
       
       for symbolvol, symbolvolData in self.volatilityDataBySymbol.items():
           if (self.Securities[symbolvol].Close >  symbolvolData.wilr.Current.Value < -20):
               return
           
       for symbol, symbolData in self.symbolDataBySymbol.items():
          if not self.Portfolio[symbol].Invested  and (self.Securities[symbol].Close < self.low.Current.Value) and (self.longtermfast.Current.Value > self.longtermslow.Current.Value):
               self.SetHoldings(symbol, .1, False, "Buy Signal")
                   
           
   def sellSignals(self):
       if self.trade == False:
           return
           
       for symbol, symbolData in self.symbolDataBySymbol.items():
           
           if self.Portfolio[symbol].Invested and (self.Securities[symbol].Close > self.high.Current.Value):
               self.Liquidate(symbol, "Sell Signal")
               
         
               # Update our trailing stop loss as necessary
   def stopLoss(self):
       if  self.trade == False:
           return
       for symbolvol, symbolvolData in self.volatilityDataBySymbol.items():
           if (self.Securities[symbolvol].Close >  symbolvolData.wilr.Current.Value > -25):
               self.Liquidate("Sell Signal")
               
   
       
   def OnSMA(self, sender, updated):
       if self.sma.IsReady:
           #self.Debug(f"SMA Updated on {self.Time} with value: {self.sma.Current.Value}")
           return

class symbolMarkData:
   def __init__(self, symbol, sma50, sma200, rsi):
       self.Symbol = symbol
       self.sma50 = sma50
       self.sma200 = sma200
       self.rsi = rsi
class symbolvolData:
   def __init__(self, symbol, rsi, wilr):
       self.Symbol = symbol
       self.rsi = rsi
       self.wilr = wilr

class SymbolData:
   def __init__(self, symbol, ema10, sma20, sma50, sma200, sma7, ema20, ema50, rsi, wilr, wilr_fast, atr, smaConsolidate):
       self.Symbol = symbol
       self.ema10 = ema10
       self.sma20 = sma20
       self.sma50 = sma50
       self.sma200 = sma200
       self.sma7 = sma7
       self.ema20 = ema20
       self.ema50 = ema50
       self.rsi = rsi
       self.wilr = wilr
       self.wilr_fast = wilr_fast
       self.atr = atr
       #self.emaConsolidate = emaConsolidate
       self.smaConsolidate = smaConsolidate