docs: def holes(self, start=0, end=None, formatter=None, ignore=None, seps=None, predicate=None,
                index=None):  # pylint: disable=too-many-branches,too-many-locals
          """
          Retrieves a set of Match objects that are not defined in given range.
          :param start:
          :type start:
          :param end:
          :type end:
          :param formatter:
          :type formatter:
          :param ignore:
          :type ignore:
          :param seps:
          :type seps:
          :param predicate:
          :type predicate:
          :param index:
          :type index:
          :return:
          :rtype:
          """
          assert self.input_string if seps else True, "input_string must be defined when using seps parameter"
          if end is None:
              end = self.max_end
          else:
              end = min(self.max_end, end)
          ret = _BaseMatches._base()
          hole = False
          rindex = start
  
          loop_start = self._hole_start(start, ignore)
  
          for rindex in range(loop_start, end):
              current = []
              for at_index in self.at_index(rindex):
                  if not ignore or not ignore(at_index):
                      current.append(at_index)
  
              if seps and hole and self.input_string and self.input_string[rindex] in seps:
                  hole = False
                  ret[-1].end = rindex
              else:
                  if not current and not hole:
                      # Open a new hole match
                      hole = True
                      ret.append(Match(max(rindex, start), None, input_string=self.input_string, formatter=formatter))
                  elif current and hole:
                      # Close current hole match
                      hole = False
                      ret[-1].end = rindex
  
          if ret and hole:
              # go the the next starting element ...
              ret[-1].end = min(self._hole_end(rindex, ignore), end)
          return filter_index(ret, predicate, index)