I am trying to figure out why I am getting the following error: 

Runtime Error: AttributeError : 'UniverseRollingAlgorithm' object has no attribute 'universe'at OnDatafor symbol at self.universe:===at Python.Runtime.PyObject.Invoke(PyTuple args in main.py:line 97 AttributeError : 'UniverseRollingAlgorithm' object has no attribute 'universe' (Open Stacktrace) 

Ideally, this should be looking through the top 2 sectors and sort the data by P/E ratio and take the top 5 stocks within those sectors.   I then want to run TA conditions to time when to buy the stock list that is populated from the corse/fine selectors.  Can anyone please point me in the right direction here?

 

  1. from itertools import groupby
  3. class UniverseRollingAlgorithm(QCAlgorithm):
  4.    
  5.    def Initialize(self):       #Initialize Dates, Cash, Equities, Fees, Allocation, Parameters, Indicators, Charts
  6.        
  7.        # Set Start Date, End Date, and Cash
  8.        #-------------------------------------------------------
  9.        self.SetTimeZone(TimeZones.NewYork)     #EDIT: Added Timezon
  10.        self.SetStartDate(2021, 1, 1)   # Set Start Date
  11.       # self.SetEndDate(2020, 4, 15)      # Set End Date
  12.        self.SetCash(100000)            # Set Strategy Cash
  13.        #-------------------------------------------------------
  14.        
  15.        # Set Custom Universe
  16.        #-------------------------------------------------------
  17.        self.AddUniverse(self.CoarseSelectionFilter, self.FineSelectionFilter)
  18.        self.UniverseSettings.Resolution = Resolution.Minute    #Needs to change to Resolution.Minute once code works, leaving Daily for now to minimize data
  19.        self.UniverseSettings.SetDataNormalizationMode = DataNormalizationMode.SplitAdjusted
  20.        self.UniverseSettings.FeeModel = ConstantFeeModel(0.0)
  21.        self.UniverseSettings.Leverage = 1
  22.        #-------------------------------------------------------
  23.        
  24.      # self.SetBrokerageModel(BrokerageName.Alpaca, AccountType.Cash)      #EDIT: Added Brokerage, appears to have set fees to zero
  25.        
  26.        self.EMA_Period_Fast = 20
  27.        self.EMA_Period_Slow = 50
  28.        self.__numberOfSymbols     = 100
  29.        self.__numberOfSymbolsFine = 10
  30.        
  31.        self.indicators = {}
  32.        
  33.        # Define Percentage Allocation
  34.        #-------------------------------------------------------
  35.        self.percentagebuy = 0.1
  36.        #-------------------------------------------------------
  37.        
  38.        
  39.        # Sector Selectior
  40.        self.numberOfSymbolsCoarse = 500
  41.        self.exposureToSector = 2
  42.        self.lastMonth = -1
  43.        self.SetSecurityInitializer(lambda x: x.SetMarketPrice(self.GetLastKnownPrice(x)))
  44.        
  45.            
  46.    def CoarseSelectionFilter(self, coarse):
  47.        
  48.        if self.Time.month == self.lastMonth:
  49.            return Universe.Unchanged
  50.        self.lastMonth = self.Time.month
  51.        
  52.        allCoarse = [x for x in coarse if x.HasFundamentalData and x.Price > 1 and x.Volume > 1]
  53.        finalCoarse = sorted(allCoarse, key = lambda x: x.DollarVolume, reverse = True)
  54.        
  55.        return [x.Symbol for x in finalCoarse][:self.numberOfSymbolsCoarse]
  56.        
  57.        #Old
  58.        #sortedByDollarVolume = sorted(coarse, key=lambda x: x.DollarVolume, reverse=True)   # sort descending by daily dollar volume
  59.        #return [ x.Symbol for x in sortedByDollarVolume[:self.__numberOfSymbols] ]  # return the symbol objects of the top entries from our sorted collection
  60.    
  61.    def FineSelectionFilter(self, fine):  # sort the data by P/E ratio and take the top 'NumberOfSymbolsFine'
  62.        filteredSymbols = []
  63.        sortedBySector = [x for x in fine]
  64.       # self.Log("ORDER NOTIFICATION >> {}".format(str(AssetClassification.MorningstarSectorCode)))
  65.        for code, g in groupby(sortedBySector, lambda x: x.AssetClassification.MorningstarSectorCode):
  66.            for x in sorted(g, key = lambda x: x.ValuationRatios.PERatio, reverse = True)[:self.exposureToSector]:
  67.                filteredSymbols.append(x.Symbol)
  68.            
  69.        return filteredSymbols[:5]
  70.        
  71.        
  72.        #Old
  73.        #sortedByPeRatio = sorted(fine, key=lambda x: x.OperationRatios.OperationMargin.Value, reverse=False)    # sort descending by P/E ratio
  74.        #self.universe = [ x.Symbol for x in sortedByPeRatio[:self.__numberOfSymbolsFine] ]  # take the top entries from our sorted collection
  75.        #return self.universe
  76.    
  77.        
  78.    
  79.    
  80.    def OnSecuritiesChanged(self, changes):
  81.        # Create indicator for each new security
  82.        for security in changes.AddedSecurities:
  83.            self.indicators[security.Symbol] = SymbolData(security.Symbol, self, self.EMA_Period_Fast, self.EMA_Period_Slow)
  84.        
  85.        for security in changes.RemovedSecurities:
  86.            if security.Invested:
  87.                self.Liquidate(security.Symbol, "Universe Removed Security")
  88.            
  89.            if security in self.indicators:
  90.                self.indicators.pop(security.Symbol, None)
  91.    
  92.    
  93.    def OnData(self, data):         #Entry Point for Data and algorithm - Check Data, Define Buy Quantity, Process Volume, Check Portfolio, Check RSI, Execute Buy/Sell orders, Chart Plots
  94.        for symbol in self.universe:
  95.            
  96.            if not data.ContainsKey(symbol):    #Tested and Valid/Necessary
  97.                continue
  98.            
  99.            if data[symbol] is None:            #Tested and Valid/Necessary
  100.                continue
  101.            
  102.            if not symbol in self.indicators:    #Tested and Valid/Necessary
  103.                continue
  104.            
  105.            # Ensure indicators are ready to update rolling windows
  106.            if not self.indicators[symbol].slow_ema.IsReady:
  107.                continue
  108.            
  109.            # Update EMA rolling windows
  110.            self.indicators[symbol].fast_ema_window.Add(self.indicators[symbol].get_fast_EMA())
  111.            self.indicators[symbol].slow_ema_window.Add(self.indicators[symbol].get_slow_EMA())
  112.            
  113.            # Check for Indicator Readiness within Rolling Window
  114.            #-------------------------------------------------------
  115.            if not (self.indicators[symbol].fast_ema_window.IsReady and self.indicators[symbol].slow_ema_window.IsReady): 
  116.                continue    #return     #EDIT 
  117.            
  118.            #EXECUTE TRADING LOGIC HERE - 
  119.            if self.Portfolio[symbol].Invested:
  120.                # Sell condition
  121.                if (self.indicators[symbol].fast_ema_window[1] >= self.indicators[symbol].slow_ema_window[1]) and (self.indicators[symbol].fast_ema_window[4] < self.indicators[symbol].slow_ema_window[4]):
  122.                    self.Liquidate(symbol)
  123.                    
  124.                # Buy conditions
  125.            elif self.Portfolio.MarginRemaining > 0.9 * self.percentagebuy * self.Portfolio.TotalPortfolioValue:
  126.                if self.indicators[symbol].fast_ema_window[1] <= self.indicators[symbol].slow_ema_window[1] and \
  127.                    (self.indicators[symbol].fast_ema_window[4] > self.indicators[symbol].slow_ema_window[4]):
  128.                        
  129.                    self.buyquantity = round((self.percentagebuy*self.Portfolio.TotalPortfolioValue)/data[symbol].Close)
  130.                    self.MarketOrder(symbol, self.buyquantity)
  131.            
  132. class SymbolData(object):
  133.    
  134.    rolling_window_length = 5
  135.    
  136.    def __init__(self, symbol, context, fast_ema_period, slow_ema_period):
  137.        
  138.        self.symbol = symbol
  139.        self.fast_ema_period = fast_ema_period
  140.        self.slow_ema_period = slow_ema_period
  141.        self.fast_ema = context.EMA(symbol, self.fast_ema_period, Resolution.Minute)    #, fillDataForward = True, leverage = 1, extendedMarketHours = False)
  142.        self.slow_ema = context.EMA(symbol, self.slow_ema_period, Resolution.Minute)    #, fillDataForward = True, leverage = 1, extendedMarketHours = False)
  143.        self.fast_ema_window = RollingWindow[float](self.rolling_window_length)
  144.        self.slow_ema_window = RollingWindow[float](self.rolling_window_length)
  145.        
  146.        # Warm up EMA indicators
  147.        history = context.History([symbol], slow_ema_period + self.rolling_window_length, Resolution.Minute)
  148.        for time, row in history.loc[symbol].iterrows():
  149.            self.fast_ema.Update(time, row["close"])
  150.            self.slow_ema.Update(time, row["close"])
  151.            
  152.            # Warm up rolling windows
  153.            if self.fast_ema.IsReady:
  154.                self.fast_ema_window.Add(self.fast_ema.Current.Value)
  155.            if self.slow_ema.IsReady:
  156.                self.slow_ema_window.Add(self.slow_ema.Current.Value)
  157.    
  158.    def get_fast_EMA(self):
  159.        return self.fast_ema.Current.Value
  160.        
  161.    def get_slow_EMA(self):
  162.        return self.slow_ema.Current.Value
+ Expand

Author

Axist

July 2021