Loop Timeout (Spent more than 10 mins in one loop)

Hey Micah, you'll need to share some code if you want help.  Do you expect this loop to take more than 10 minutes or are you in an infinite loop?  The only time I've hit the 10 minute mark is training models or a mistaken infinite loop.  I can't really imagine math operations taking 10 minutes unless you are running it on a massive universe.

-Cole

class MeasuredFluorescentOrangeDinosaur(QCAlgorithm):
    
    stopMarketTicketFirst = None
    stopMarketOrderFillTimeFirst = datetime.min
    highestPriceFirst = -1
    
    stopMarketTicketSecond = None
    stopMarketOrderFillTimeSecond = datetime.min
    highestPriceSecond = -1

    def Initialize(self):
        self.SetStartDate(2022, 2, 1)  # Set Start Date
        self.SetCash(170)  # Set Strategy Cash
        
        # Add all symbols here from our watch list
        self.symbols = ["ABCL", "ADGI", "AEG", "ALHC", "BPT", "CANO", "CORZ", \
                    "COTY", "DBRG", "EGO", "FRBK", "FRONU", "GOL", "KPTI", \
                    "KSCP", "PL", "RDW", "REAL", "RELI", "SID", "SIRI", \
                    "SXC", "ZEV"]
                    
        # Add past 50 data points directly into the algo
        self.SetWarmUp(50)
        
        for symbol in self.symbols:
            self.symbolsAdded = [self.AddEquity(symbol, Resolution.Minute)]
            self.Log(symbol)
        
        for self.symbolAdded in self.symbolsAdded:
            self.symbolAdded.SetDataNormalizationMode(DataNormalizationMode.Raw)

        # Prepare list of symbols for consolidating
        self.consolidateSymbol = []
        for symbol in self.symbols:
            symbolMOMP = self.MOMP(symbol, 10, Resolution.Daily)
            if symbolMOMP.Current.Value >= 0:
                self.consolidateSymbol.append(symbol)
            else:
                pass
        
        # Symbols with higher opening-close than previous close
        self.highOpen = []
        
        # Set up RollingWindow with slots for all symbols
        self.rollingWindow = RollingWindow[TradeBar](len(self.consolidateSymbol))
        
        # Initialize the consolidator function here
        for symbol in self.consolidateSymbol:
            self.Consolidate(symbol, Resolution.Daily, self.OnDataConsolidated)
                
    def OnData(self, data):
        if self.IsWarmingUp:
            return
        
        if not self.rollingWindow.IsReady:
            return
        
        if not (self.Time.hour == 9 and self.Time.minute == 31):
            return
        
        rollingCounter = (len(self.consolidateSymbol)-1)
        maxCounter = 0
        priceChange = []
        highestScore = []
        for symbol in self.consolidateSymbol:
            if data[symbol] is None:
                self.consolidateSymbol.remove(symbol)
                rollingCounter = rollingCounter - 1
                self.Log("Symbol removed: "+str (symbol))
            else:
                priceChange.append(int(data[symbol].Close - self.rollingWindow[rollingCounter].Close))
                rollingCounter = rollingCounter - 1
                self.Log("Symbol added: "+str (symbol))
                
        while maxCounter < 2:
            highestScore.append(max(priceChange))
            self.Log("Symbol added to highestScore: " +str(highestScore[:]))
            priceChange.remove(max(priceChange))
            self.Log("Symbol removed from priceChange (max): " +str(max(priceChange)))
            maxCounter = maxCounter + 1
            self.Log("Total symbols added to highestScore[:]: " +str(highestScore[:]))
            self.Log("Total symbols removed from priceChange (max): " +str(max(priceChange)))
        
        rollingCounter = (len(self.consolidateSymbol)-1)
        appendSymbol = 0
        while appendSymbol < 2 and len(self.highOpen) <= 2:
            if len(self.highOpen) < 2:
                for symbol in self.consolidateSymbol:
                    if (int(data[symbol].Close - self.rollingWindow[rollingCounter].Close)) > highestScore[0]:
                        self.highOpen.append(symbol)
                        self.consolidateSymbol.remove(symbol)
                        appendSymbol = appendSymbol + 1
                        rollingCounter = rollingCounter - 1
                        self.Log("Symbol added to highOpen: " +str (symbol))
                        self.Log("Symbol removed from self.consolidateSymbol: " +str(symbol))
                        self.Log(self.highOpen)
                        if len(self.highOpen) >= 2:
                            break
        
        trading_symbol1 = []
        trading_symbol2 = []
        for symbol in self.highOpen:
            if len(self.highOpen) >= 2:
                trading_symbol1 = self.highOpen[0]
                trading_symbol2 = self.highOpen[1]
        
        # TRADE FOR THE HIGHEST MOMP SYMBOL
        # Check if 2 days have passed since last stopMarketOrder to account for the T+2 rule
        if (self.Time - self.stopMarketOrderFillTimeFirst).days < 2:
                return
        if self.Portfolio.Cash < 80:
            return
        
        if not self.Portfolio.Invested or self.Portfolio.Invested:
                if not self.Securities[trading_symbol1].Invested:
                    quantityFirst = self.CalculateOrderQuantity(trading_symbol1, 0.45)
                    self.MarketOrder(trading_symbol1, quantityFirst)
                    self.stopMarketTicketFirst = self.StopMarketOrder(trading_symbol1, -quantityFirst, 0.9 * self.Securities[trading_symbol1].Close)
        
                elif (self.Securities[trading_symbol1].Close > self.stopMarketTicketFirst.AverageFillPrice * 1.02) and (self.Securities[trading_symbol1].Close > self.highestPriceFirst):
                    #2. Plot the moving stop price on "Data Chart" with "ADGI Stop Price" series name
                    self.Plot("Data Chart", "First Symbol Stop Price", self.highestPriceFirst * 0.9)
                            
                    self.highestPriceFirst = self.Securities[trading_symbol1].Close
                    updateFields = UpdateOrderFields()
                    updateFields.StopPrice = self.highestPriceFirst * 0.9
                    self.stopMarketTicketFirst.Update(updateFields)
                    self.Debug("Highest Close Price for First Security: " +str(self.highestPriceFirst))
                    quantityFirst = self.CalculateOrderQuantity(trading_symbol1, 0.45)
                    self.MarketOrder(trading_symbol1, -((quantityFirst)/3))
                    
                elif (self.Securities[trading_symbol1].Close > self.stopMarketTicketFirst.AverageFillPrice * 1.01) and (self.Securities[trading_symbol1].Close > self.highestPriceFirst):
                    #2. Plot the moving stop price on "Data Chart" with "ADGI Stop Price" series name
                    self.Plot("Data Chart", "First Symbol Stop Price", self.highestPriceFirst * 0.9) 
                                
                    self.highestPriceFirst = self.Securities[trading_symbol1].Close
                    updateFields = UpdateOrderFields()
                    updateFields.StopPrice = self.highestPriceFirst * 0.9
                    self.stopMarketTicketFirst.Update(updateFields)
                    self.Debug("Highest Close Price for First Security: " +str(self.highestPriceFirst))
                    quantityFirst = self.CalculateOrderQuantity(trading_symbol1, 0.45)
                    self.MarketOrder(trading_symbol1, -((quantityFirst)/2))
                else:
                    if self.Securities[trading_symbol1].Close > self.highestPriceFirst:
                        self.highestPriceFirst = self.Securities[trading_symbol1].Close
                        updateFields = UpdateOrderFields()
                        updateFields.StopPrice = self.highestPriceFirst * 0.9
                        self.stopMarketTicketFirst.Update(updateFields)
                        self.Debug("Highest Close Price for First Security: " +str(self.highestPriceFirst))
                        
        # TRADE FOR THE SECOND HIGHEST MOMP SYMBOL
        # Check if 2 days have passed since last stopMarketOrder to account for the T+2 rule
        if (self.Time - self.stopMarketOrderFillTimeSecond).days < 2:
                return
        if self.Portfolio.Cash < 80:
            return
        
        if not self.Portfolio.Invested or self.Portfolio.Invested:
                if not self.Securities[trading_symbol2].Invested:
                    quantitySecond = self.CalculateOrderQuantity(trading_symbol2, 0.45)
                    self.MarketOrder(trading_symbol2, quantitySecond)
                    self.stopMarketTicketSecond = self.StopMarketOrder(trading_symbol2, -quantitySecond, 0.9 * self.Securities[trading_symbol2].Close)
        
                elif (self.Securities[trading_symbol2].Close > self.stopMarketTicketSecond.AverageFillPrice * 1.02) and (self.Securities[trading_symbol2].Close > self.highestPriceSecond):
                    #2. Plot the moving stop price on "Data Chart" with "ADGI Stop Price" series name
                    self.Plot("Data Chart", "Second Symbol Stop Price", self.highestPriceSecond * 0.9)
                            
                    self.highestPriceSecond = self.Securities[trading_symbol2].Close
                    updateFields = UpdateOrderFields()
                    updateFields.StopPrice = self.highestPriceSecond * 0.9
                    self.stopMarketTicketSecond.Update(updateFields)
                    self.Debug("Highest Close Price for Second Security: " +str(self.highestPriceSecond))
                    quantitySecond = self.CalculateOrderQuantity(trading_symbol2, 0.45)
                    self.MarketOrder(trading_symbol2, -((quantitySecond)/3))
                    
                elif (self.Securities[trading_symbol2].Close > self.stopMarketTicketSecond.AverageFillPrice * 1.01) and (self.Securities[trading_symbol2].Close > self.highestPriceSecond):
                    #2. Plot the moving stop price on "Data Chart" with "ADGI Stop Price" series name
                    self.Plot("Data Chart", "Second Symbol Stop Price", self.highestPriceSecond * 0.9) 
                                
                    self.highestPriceSecond = self.Securities[trading_symbol2].Close
                    updateFields = UpdateOrderFields()
                    updateFields.StopPrice = self.highestPriceSecond * 0.9
                    self.stopMarketTicketSecond.Update(updateFields)
                    self.Debug("Highest Close Price for Second Security: " +str(self.highestPriceSecond))
                    quantitySecond = self.CalculateOrderQuantity(trading_symbol2, 0.45)
                    self.MarketOrder(trading_symbol2, -((quantitySecond)/2))
                else:
                    if self.Securities[trading_symbol2].Close > self.highestPriceSecond:
                        self.highestPriceSecond = self.Securities[trading_symbol2].Close
                        updateFields = UpdateOrderFields()
                        updateFields.StopPrice = self.highestPriceSecond * 0.9
                        self.stopMarketTicketSecond.Update(updateFields)
                        self.Debug("Highest Close Price for Second Security: " +str(self.highestPriceSecond))   
                        
    def OnDataConsolidated(self, bar):
        self.rollingWindow.Add(bar)
            
    def OnOrderEvent(self, orderEvent):
        
        if orderEvent.Status != OrderStatus.Filled:
            return
        
        if self.stopMarketTicketFirst is not None and self.stopMarketTicketFirst.OrderId == orderEvent.OrderId: 
            self.stopMarketOrderFillTimeFirst = self.Time
        else:
            if self.stopMarketTicketSecond is not None and self.stopMarketTicketSecond.OrderId == orderEvent.OrderId: 
                self.stopMarketOrderFillTimeSecond = self.Time

Hey Cole, here's the code. And I believe it's not an infinite loop unless I must have missed something that didn't account for my counters and increment statements. 

Hey Micah,

The problem is here.  If len(self.highOpen) == 2 the loop will execute,but the if statement won't fire if len(self.highOpen) == 2 and if the if block does not execute, you will never move either appendSymbol or self.highOpen forward and you have an infinite loop.

I would not use a while here.  I would use the for loop and if check for my conditions and then if my conditions are met, I would break. 
 

while appendSymbol < 2 and len(self.highOpen) <= 2:
           if len(self.highOpen) < 2:
               for symbol in self.consolidateSymbol:
                   if (int(data[symbol].Close - self.rollingWindow[rollingCounter].Close)) > highestScore[0]:
                       self.highOpen.append(symbol)
                       self.consolidateSymbol.remove(symbol)
                       appendSymbol = appendSymbol + 1
                       rollingCounter = rollingCounter - 1
                       self.Log("Symbol added to highOpen: " +str (symbol))
                       self.Log("Symbol removed from self.consolidateSymbol: " +str(symbol))
                       self.Log(self.highOpen)
                       if len(self.highOpen) >= 2:
                           break

I noticed you are using de-spac symbols.  I'm big into spacs and PL and CANO are two of my big holdings, would love to know what you are wanting to do with them.  I've got some algo ideas for de-spacs around warrants but have not implemented them.

Is the problem If len(self.highOpen) == 2 or If len(self.highOpen) <= 2? Because from the code the check is wether the len(self.highOpen) is less than or equal to 2? Could you help decode this more. I’m sort of getting lost here. Also, about the spacs, I sort of hadn’t realized I was dealing with them primarily, to be honest, my goal is make some profits every time I trade in order to raise more money. Then I can start thinking of buying and holding stocks for investment purposes. 

Hey Micah,

It's a problem both ways.  I think using the while loop is not a good idea here, it makes the code more confusing and harder to understand.  I would get rid of the outer while loop rewrite it with for loops only and check conditions in the loops.

Just removed the while loop and added the appendSymbol counter to the if statement and it’s working now, but it’s adding more than 2 items in the list. Trying to check on that now….

Could you enlighten me more about the de-spacs Algo ideas?

Well, it's just an idea based on my trading of them, I'm not sure if there is Alpha there or not.  But the idea is to arbitrage the warrant and the common.  I think there is enough movement and deviation in them that you could vary the position in each of them up and down as they move closer and further apart.  The warrant usually holds a certain ratio to the common but this varies over time.  My idea was to exploit that variance.

I haven’t had enough experience with trading so far to start working on warrants, I’m still building my analysis and findings with common stocks. You’ve got any tips you can help out with maybe?