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