Hi, i'm faced with an error: value error

ValueError : min() arg is an empty sequenceat OnDatanextResistanceLevel = greater_than_price[min(range(len(greater_than_price)) in main.py: line 69

every time i try executing this algorithm, yet when i look through the backtest logs, i see there seem to be not an empty sequence as there exist support values as well as resistance values. need some help and advice. 

Here's code of the algorithm for further review. 

  1. from datetime import datetime,timedelta
  2. import numpy as np
  5. Macdlong = None
  6. AboveSupport = None
  7. BelowResistance = None
  9. class CreativeYellowTapir(QCAlgorithm):
  11.     def Initialize(self):
  12.         self.SetStartDate(2019, 1, 30)  # Set Start Date
  13.         self.SetEndDate(2020, 12, 30)
  14.         self.SetCash(100000)  # Set Strategy Cash
  15.         
  16.         self.ticker = "USDCAD"
  17.         # Rolling Windows to hold bar close data keyed by symbol
  18.         self.Data = {}
  20.         #for ticker in tickers:
  21.         symbol = self.AddForex(self.ticker, Resolution.Hour, Market.Oanda).Symbol
  22.         self.Data[symbol] = SymbolData(self, symbol)
  23.          
  24.       
  25.         self.tolerance = 0.0025
  26.         self.toleranceR = 0.986761994
  27.         self.toleranceS = 1.004000555
  28.         self.stopLossLevel = -0.05 # stop loss percentage 
  29.         self.stopProfitLevel = 0.01# stop profit percentage
  30.         
  31.             
  32.         self.SetWarmUp(400, Resolution.Hour)
  33.         
  34.         
  35.     #def MarketClose(self):
  36.         #self.SupportResistance.Reset()
  37.     
  38.     
  40.     def OnData(self, data):
  41.         
  42.         #if self.IsWarmingUp: #Data to warm up the algo is being collected.
  43.            # return
  44.         
  45.         for symbol, symbolData in self.Data.items(): #Return the dictionary's key-value pairs:
  46.             if not (data.ContainsKey(symbol) and data[symbol] is not None and symbolData.IsReady):
  47.                 continue
  48.             
  49.             if self.IsWarmingUp or not all([symbolData.IsReady for symbolData in self.Data.values()]):
  50.                 return
  51.             
  52.             MACD = symbolData.macd.Current.Value
  53.             MACDfast = symbolData.macd.Fast.Current.Value
  54.             RSI = symbolData.rsi.Current.Value
  55.             current_price = data[symbol].Close
  56.             
  57.             signalDeltaPercent = (MACD - MACD)/MACDfast
  58.             
  59.             supports, resistances = self.NextSupportResistance(symbolData.closeWindow)
  60.             self.Log(f"Symbol: {symbol.Value} , Supports: {supports} , Resistances: {resistances}")
  61.             
  62.             #Getting the next support level
  63.             if not len(supports) > 1 and not len(resistances) > 1:
  64.                 return
  65.             
  66.             
  67.             #Getting the next resistance level  *****
  68.             greater_than_price = [y for y in resistances if y > current_price ]
  69.             nextResistanceLevel = greater_than_price[min(range(len(greater_than_price)), key=lambda i: abs(greater_than_price[i] - current_price))]
  70.         
  71.             #Getting the next support level    *****
  72.             less_than_price = [x for x in supports if x < current_price ]
  73.             nextSupportLevel = less_than_price[min(range(len(less_than_price)), key=lambda i: abs(less_than_price[i] - current_price))]
  74.             
  75.             
  76.             if self.Portfolio[symbol].Invested:
  77.                 
  78.                 if self.isLong:
  79.                     condStopProfit = (current_price - self.buyInPrice)/self.buyInPrice > self.stopProfitLevel
  80.                     condStopLoss = (current_price - self.buyInPrice)/self.buyInPrice < self.stopLossLevel
  81.                     if condStopProfit:
  82.                         self.Liquidate(symbol)
  83.                         self.Log(f"{self.Time} Long Position Stop Profit at {current_price}")
  84.                         
  85.                     if condStopLoss:
  86.                         self.Liquidate(symbol)
  87.                         self.Log(f"{self.Time} Long Position Stop Loss at {current_price}")
  88.                 else:
  89.                     condStopProfit = (self.sellInPrice - current_price)/self.sellInPrice > self.stopProfitLevel
  90.                     condStopLoss = (self.sellInPrice - current_price)/self.sellInPrice < self.stopLossLevel
  91.                     if condStopProfit:
  92.                         self.Liquidate(symbol)
  93.                         self.Log(f"{self.Time} Short Position Stop Profit at {current_price}")
  94.                         
  95.                     if condStopLoss:
  96.                         self.Liquidate(symbol)
  97.                         self.Log(f"{self.Time} Short Position Stop Loss at {current_price}")
  98.             
  99.             
  100.             
  101.             if not self.Portfolio[symbol].Invested:
  102.                 
  103.                 closestResistanceZone = nextResistanceLevel
  104.                 closestSupportZone = nextSupportLevel
  105.                 
  106.                 MacdLong = signalDeltaPercent > self.tolerance
  107.                 AboveSupport = current_price > closestSupportZone * self.toleranceS
  108.                 BelowResistance = current_price < closestResistanceZone * self.toleranceR
  109.                 # tolerance = will be dependent on the minimum number of pips before a r/s level
  110.                 
  111.                 if RSI > 50 and Macdlong and BelowResistance:
  112.                     self.SetHoldings(symbol, 1)
  113.                     # get buy-in price for trailing stop loss/profit
  114.                     self.buyInPrice = current_price
  115.                     # entered long position
  116.                     self.isLong = True
  117.                     self.Log(f"{self.Time} Entered Long Position at {current_price}")
  118.                         
  119.                 if RSI < 50  and not Macdlong and AboveSupport: 
  120.                     self.SetHoldings(symbol, -1)
  121.                     # get sell-in price for trailing stop loss/profit
  122.                     self.sellInPrice = current_price
  123.                     # entered short position
  124.                     self.isLong = False
  125.                     self.Log(f"{self.Time} Entered Short Position at {current_price}")
  126.                     
  127.                     
  128.     def NextSupportResistance(self, window, variation = 0.005, h = 3):
  129.         
  130.         #price = self.Securities[self.ticker].Close 
  131.         series = window
  132.         supports = []
  133.         resistances = []
  134.         
  135.         maxima = []
  136.         minima = []
  137.         
  138.         # finding maxima and minima by looking for hills/troughs locally
  139.         for i in range(h, series.Size-h):
  140.             if series[i] > series[i-h] and series[i] > series[i+h]:
  141.                 maxima.append(series[i])
  142.             elif series[i] < series[i-h] and series[i] < series[i+h]:
  143.                 minima.append(series[i])
  144.        
  145.         # identifying maximas which are resistances
  146.         for m in maxima:
  147.             r = m * variation
  148.             # maxima which are near each other
  149.             commonLevel = [x for x in maxima if x > m - r and x < m + r]
  150.             # if 2 or more maxima are clustered near an area, it is a resistance
  151.             if len(commonLevel) > 1:
  152.                 # we pick the highest maxima if the cluster as our resistance
  153.                 level = max(commonLevel)
  154.                 if level not in resistances:
  155.                     resistances.append(level)
  156.                     
  157.         
  158.         # identify minima which are supports
  159.         for l in minima:
  160.             r = l * variation
  161.             # minima which are near each other
  162.             commonLevel = [x for x in minima if x > l - r and x < l + r]
  163.             # if 2 or more minima are clustered near an area, it is a support
  164.             if len(commonLevel) > 1:
  165.                 # We pick the lowest minima of the cluster as our support
  166.                 level = min(commonLevel)
  167.                 if level not in supports:
  168.                     supports.append(level)
  169.                     
  170.         
  171.         return supports, resistances #nextSupportLevel, nextResistanceLevel
  172.                         
  173.                     
  174. class SymbolData:
  175.     def __init__(self, algorithm, symbol):
  176.         self.macd = MovingAverageConvergenceDivergence(12,26,9)
  177.         self.rsi = RelativeStrengthIndex(14)
  178.         
  179.         self.macdWindow = RollingWindow[IndicatorDataPoint](2)   #setting the Rolling Window for the fast MACD indicator, takes two values
  180.         algorithm.RegisterIndicator(symbol, self.macd, timedelta(hours=4))
  181.         self.macd.Updated += self.MacdUpdated                    #Updating those two values
  182.         
  183.         self.rsiWindow = RollingWindow[IndicatorDataPoint](2)   #setting the Rolling Window for the slow SMA indicator, takes two values
  184.         algorithm.RegisterIndicator(symbol, self.rsi, timedelta(hours=4))
  185.         self.rsi.Updated += self.RsiUpdated                    #Updating those two values
  186.         
  187.         self.closeWindow = RollingWindow[float](200)
  188.         
  189.         # Add consolidator to track rolling close prices
  190.         self.consolidator = QuoteBarConsolidator(4)
  191.         self.consolidator.DataConsolidated += self.CloseUpdated
  192.         algorithm.SubscriptionManager.AddConsolidator(symbol, self.consolidator)
  193.         
  195.     def MacdUpdated(self, sender, updated):
  196.         '''Event holder to update the MACD Rolling Window values'''
  197.         if self.macd.IsReady:
  198.             self.macdWindow.Add(updated)
  200.     def RsiUpdated(self, sender, updated):
  201.         '''Event holder to update the RSI Rolling Window values'''
  202.         if self.rsi.IsReady:
  203.             self.rsiWindow.Add(updated)
  204.             
  205.             
  206.     def CloseUpdated(self, sender, bar):
  207.         '''Event holder to update the close Rolling Window values'''
  208.         self.closeWindow.Add(bar.Close)
  209.        
  210.     @property 
  211.     def IsReady(self):
  212.         return self.macd.IsReady and self.rsi.IsReady and self.closeWindow.IsReady     
  213.        
  214.   
+ Expand

and here are the logs of that backtest.

137906_1631792145.jpg

I would appreciate any and all the help that i can get.

Author

Samwel Kibet

September 2021