As i was attempting to inherit data from a class in another .py file, i got an error message saying. 

‘’ Algorithm.Initialize() Error: During the algorithm initialization, the following exception has occurred: Loader.TryCreatePythonAlgorithm(): Unable to import python module ./cache/algorithm/main.pyc. AlgorithmPythonWrapper(): NameError : name 'ReversalAlpha' is not defined
at <module>
class SupportResistance(ReversalAlpha):
File "main.py" in dailyhours.py: line 8"

How do i do it successfully, given that this is the class below i'm trying to inherit:

  1. """ Block of code whose output gives us daily support levels as well as resistance
  2. levels """
  4. from datetime import datetime,timedelta
  5. import numpy as np
  7. class ReversalAlpha(QCAlgorithm):
  9.     def Initialize(self):
  10.         
  11.      
  12.         self.ticker = "USDCAD"
  13.         # Rolling Windows to hold bar close data keyed by symbol
  14.         self.closingData = {}
  15.         #for ticker in tickers:
  16.         symbol = self.AddForex(self.ticker, Resolution.Daily, Market.Oanda).Symbol
  17.         self.closingData[symbol] = RollingWindow[float](50)
  18.             # Warm up our rolling windows
  19.         self.SetWarmUp(50)
  20.         
  21.     def OnData(self, data):
  22.         
  23.         for symbol, window in self.closingData.items():
  24.             if data.ContainsKey(symbol) and data[symbol] is not None:
  25.                 window.Add(data[symbol].Close)
  26.         
  27.         if self.IsWarmingUp or not all([window.IsReady for window in self.closingData.values()]):
  28.             return
  29.         
  30.         for symbol, window in self.closingData.items(): #references the key-value pairs in the dictionary
  31.             supports_D, resistances_D = self.GetPriceLevels(window) # Daily Supports and Daily Resistances
  32.             self.Log(f"Symbol: {symbol.Value} , Supports: {supports_D} , Resistances: {resistances_D}")
  33.             
  34.             
  35.     def GetPriceLevels(self, series, variation = 0.005, h = 3):
  36.         
  37.         supports_D = [] # List that will hold daily Supports points
  38.         resistances_D = [] # List that will hold daily Resistances points
  39.         
  40.         maxima = []
  41.         minima = []
  42.         
  43.         # finding maxima and minima by looking for hills/troughs locally
  44.         for i in range(h, series.Size-h):
  45.             if series[i] > series[i-h] and series[i] > series[i+h]:
  46.                 maxima.append(series[i])
  47.             elif series[i] < series[i-h] and series[i] < series[i+h]:
  48.                 minima.append(series[i])
  49.        
  50.         # identifying maximas which are resistances
  51.         for m in maxima:
  52.             r = m * variation
  53.             # maxima which are near each other
  54.             commonLevel = [x for x in maxima if x > m - r and x < m + r]
  55.             # if 2 or more maxima are clustered near an area, it is a resistance
  56.             if len(commonLevel) > 1:
  57.                 # we pick the highest maxima if the cluster as our resistance
  58.                 level = max(commonLevel)
  59.                 if level not in resistances_D:
  60.                     resistances_D.append(level)
  61.         
  62.         # identify minima which are supports
  63.         for l in minima:
  64.             r = l * variation
  65.             # minima which are near each other
  66.             commonLevel = [x for x in minima if x > l - r and x < l + r]
  67.             # if 2 or more minima are clustered near an area, it is a support
  68.             if len(commonLevel) > 1:
  69.                 # We pick the lowest minima of the cluster as our support
  70.                 level = min(commonLevel)
  71.                 if level not in supports_D:
  72.                     supports_D.append(level)
  73.             
  74.         
  75.         return supports_D, resistances_D
  77. # Your New Python File
  79. #if nextSupportZone > current_price:
  80. #return
+ Expand

to this other class:

  1. """ Block of code whose two methods output gives us next support and next resistance  """
  4. from datetime import datetime,timedelta
  5. SupportD = None
  6. ResistanceD = None
  8. class SupportResistance(ReversalAlpha):
  9.     
  10.     def __init__(self, algorithm):
  11.         
  12.         self.ticker = "USDCAD"
  13.         self.Algorithm = algorithm
  14.         self.SupportResistance = GetPriceLevels(self, series, variation = 0.005, h = 3)
  15.         #find out how to consolidate hourly data into 4hr bars
  16.         self.FourHourWindow = RollingWindow[float](21)
  17.         algorithm.Consolidate(self.Ticker, timedelta(hours=4), self.SaveFourHourBars)
  18.         
  19.         
  20.     def NextSupport(self):
  21.         
  22.         price = self.Algorithm.Securities[self.Ticker].Price
  23.         
  24.         SupportD, ResistanceD = self.SupportResistance
  25.         
  26.         less_than_price = [x for x in SupportD if x < price ]
  27.         
  28.         return less_than_price[min4(range(len(less_than_price)), key=lambda i: abs(less_than_price[i] - price))]
  29.         
  30.     
  31.     def NextResistance(self):
  32.         price = self.Algorithm.Securities[self.Ticker].Price
  33.         
  34.         SupportD, ResistanceD = self.SupportResistance
  35.         
  36.         greater_than_price = [y for y in ResistanceD if y > price ]
  37.         
  38.         return greater_than_price[min(range(len(greater_than_price)), key=lambda i: abs(greater_than_price[i] - price))]
  39.         
  40.     def SaveFourHourBars(self, bar):
  41.         self.FourHourWindow.Add(bar)
  42.         
  43.     
  44. # Your New Python File
  45. #How do you conduct an inheritance of methods of a class from another .py file and create a new method using data from
  46. # the inherited class. .
  47. #Here's a rough idea of what i wanted to create:
  51. # Your New Python File
+ Expand

which will be used in this main .py algorithm class

  1.  from datetime import datetime,timedelta
  2. import numpy as np
  3. from dailyhours import *
  4. #from fourhr_support_resistance import *
  5. Macdlong = None
  6. class MeasuredApricot(QCAlgorithm):
  8.     def Initialize(self):
  9.         self.SetStartDate(2019, 1, 30)  # Set Start Date
  10.         self.SetEndDate(2020, 12, 30)
  11.         self.SetCash(100000)  # Set Strategy Cash
  12.         
  13.         self.ticker = "USDCAD"
  14.         # Rolling Windows to hold bar close data keyed by symbol
  15.         self.Data = {}
  17.         #for ticker in tickers:
  18.         symbol = self.AddForex(self.ticker, Resolution.Hour, Market.Oanda).Symbol
  19.         self.Data[symbol] = SymbolData(self, symbol)
  20.             
  21.         self.tolerance = 0.0025
  22.             
  23.         self.stopLossLevel = -0.05 # stop loss percentage 
  24.         self.stopProfitLevel = 0.01# stop profit percentage
  25.         
  26.         #self.SupportResistance = SupportResistance(self, self.ticker)
  27.             
  28.         self.SetWarmUp(50, Resolution.Hour)
  29.         
  30.         
  31.     #def MarketClose(self):
  32.         #self.SupportResistance.Reset()
  35.     def OnData(self, data):
  36.         
  37.         if self.IsWarmingUp: #Data to warm up the algo is being collected.
  38.             return
  39.         
  40.         for symbol, symbolData in self.Data.items(): #Return the dictionary's key-value pairs:
  41.             if not (data.ContainsKey(symbol) and data[symbol] is not None and symbolData.IsReady):
  42.                 continue
  43.             
  44.             MACD = symbolData.macd.Current.Value
  45.             MACDfast = symbolData.macd.Fast.Current.Value
  46.             RSI = symbolData.rsi.Current.Value
  47.             current_price = data[symbol].Close
  48.             
  49.             signalDeltaPercent = (MACD - MACD)/MACDfast
  50.             #nextSupportZone =
  51.             #nextResistanceZone = 
  52.             #support = self.SupportResistance.NextSupport()
  53.             #resistance = self.SupportResistance.NextResistance()
  54.             
  56.             if self.Portfolio[symbol].Invested:
  57.                 
  58.                 if self.isLong:
  59.                     condStopProfit = (current_price - self.buyInPrice)/self.buyInPrice > self.stopProfitLevel
  60.                     condStopLoss = (current_price - self.buyInPrice)/self.buyInPrice < self.stopLossLevel
  61.                     if condStopProfit:
  62.                         self.Liquidate(symbol)
  63.                         self.Log(f"{self.Time} Long Position Stop Profit at {current_price}")
  64.                         
  65.                     if condStopLoss:
  66.                         self.Liquidate(symbol)
  67.                         self.Log(f"{self.Time} Long Position Stop Loss at {current_price}")
  68.                 else:
  69.                     condStopProfit = (self.sellInPrice - current_price)/self.sellInPrice > self.stopProfitLevel
  70.                     condStopLoss = (self.sellInPrice - current_price)/self.sellInPrice < self.stopLossLevel
  71.                     if condStopProfit:
  72.                         self.Liquidate(symbol)
  73.                         self.Log(f"{self.Time} Short Position Stop Profit at {current_price}")
  74.                         
  75.                     if condStopLoss:
  76.                         self.Liquidate(symbol)
  77.                         self.Log(f"{self.Time} Short Position Stop Loss at {current_price}")
  78.             
  79.             
  80.             
  81.             if not self.Portfolio[symbol].Invested:
  82.                 
  83.                 MacdLong = signalDeltaPercent > self.tolerance
  84.                 #Above Support = current_price > closestSupportZone * tolerance1(1.004)
  85.                 #Below Resistance = current_price < closestResistanceZone * tolerance2(0.987)
  86.                 # tolerance = will be dependent on the minimum number of pips before a r/s level
  87.                 
  88.                 if RSI > 50 and Macdlong: #Below Resistance:
  89.                     self.SetHoldings(symbol, 1)
  90.                     # get buy-in price for trailing stop loss/profit
  91.                     self.buyInPrice = current_price
  92.                     # entered long position
  93.                     self.isLong = True
  94.                     self.Log(f"{self.Time} Entered Long Position at {current_price}")
  95.                         
  96.                 if RSI < 50  and not Macdlong: #Above Support: 
  97.                     self.SetHoldings(symbol, -1)
  98.                     # get sell-in price for trailing stop loss/profit
  99.                     self.sellInPrice = current_price
  100.                     # entered short position
  101.                     self.isLong = False
  102.                     self.Log(f"{self.Time} Entered Short Position at {current_price}")
  103.                         
  104.                     
  105. class SymbolData:
  106.     def __init__(self, algorithm, symbol):
  107.         self.macd = MovingAverageConvergenceDivergence(12,26,9)
  108.         self.rsi = RelativeStrengthIndex(14)
  109.         
  110.         self.macdWindow = RollingWindow[IndicatorDataPoint](2)   #setting the Rolling Window for the fast MACD indicator, takes two values
  111.         algorithm.RegisterIndicator(symbol, self.macd, timedelta(hours=4))
  112.         self.macd.Updated += self.MacdUpdated                    #Updating those two values
  113.         
  114.         self.rsiWindow = RollingWindow[IndicatorDataPoint](2)   #setting the Rolling Window for the slow SMA indicator, takes two values
  115.         algorithm.RegisterIndicator(symbol, self.rsi, timedelta(hours=4))
  116.         self.rsi.Updated += self.RsiUpdated                    #Updating those two values
  117.         
  118.         self.closeWindow = RollingWindow[float](21)
  119.         
  120.         # Add consolidator to track rolling close prices
  121.         self.consolidator = QuoteBarConsolidator(4)
  122.         self.consolidator.DataConsolidated += self.CloseUpdated
  123.         algorithm.SubscriptionManager.AddConsolidator(symbol, self.consolidator)
  124.         
  126.     def MacdUpdated(self, sender, updated):
  127.         '''Event holder to update the MACD Rolling Window values'''
  128.         if self.macd.IsReady:
  129.             self.macdWindow.Add(updated)
  131.     def RsiUpdated(self, sender, updated):
  132.         '''Event holder to update the RSI Rolling Window values'''
  133.         if self.rsi.IsReady:
  134.             self.rsiWindow.Add(updated)
  135.             
  136.             
  137.     def CloseUpdated(self, sender, bar):
  138.         '''Event holder to update the close Rolling Window values'''
  139.         self.closeWindow.Add(bar.Close)
  140.        
  141.     @property 
  142.     def IsReady(self):
  143.         return self.macd.IsReady and self.rsi.IsReady and self.closeWindow.IsReady     
  144.        
  145.   
+ Expand

Any help and all the help i can get will be appreciated.

Author

Samwel Kibet

August 2021