docs: def send_until(self,
  	               send,
  	               regexps,
  	               not_there=False,
  	               cadence=2,
  	               retries=100,
  	               echo=None,
  	               note=None,
  	               debug_command=None,
  	               pause_point_on_fail=True,
  	               nonewline=False,
  	               loglevel=logging.INFO):
  		"""Send string on a regular cadence until a string is either seen, or the timeout is triggered.
  
  		@param send:                 See send()
  		@param regexps:              List of regexps to wait for.
  		@param not_there:            If True, wait until this a regexp is not seen in the output. If False
  		                             wait until a regexp is seen in the output (default)
  		@param echo:                 See send()
  		@param note:                 See send()
  		@param debug_command:        Command to send if the output was not there.
  		"""
  		shutit = self.shutit
  		shutit.handle_note(note, command=send + ' \nuntil one of these seen:\n' + str(regexps))
  		shutit.log('Sending: "' + send + '" until one of these regexps seen: ' + str(regexps), level=loglevel)
  		if isinstance(regexps, str):
  			regexps = [regexps]
  		if not isinstance(regexps, list):
  			shutit.fail('regexps should be list') # pragma: no cover
  		while retries > 0:
  			retries -= 1
  			echo = shutit.get_echo_override(echo)
  			output = self.send_and_get_output(send,
  			                                  retry=1,
  			                                  strip=True,
  			                                  echo=echo,
  			                                  loglevel=loglevel,
  			                                  nonewline=nonewline,
  			                                  fail_on_empty_before=False)
  			shutit.log('Failed to match regexps -> ' + str(regexps) + ' <- retries left:' + str(retries), level=loglevel)
  			if not not_there:
  				for regexp in regexps:
  					if not shutit_util.check_regexp(regexp):
  						shutit.fail('Illegal regexp found in send_until call: ' + regexp) # pragma: no cover
  					if shutit.match_string(output, regexp):
  						return True
  			else:
  				# Only return if _not_ seen in the output
  				missing = False
  				for regexp in regexps:
  					if not shutit_util.check_regexp(regexp):
  						shutit.fail('Illegal regexp found in send_until call: ' + regexp) # pragma: no cover
  					if not shutit.match_string(output, regexp):
  						missing = True
  						break
  				if missing:
  					shutit.handle_note_after(note=note)
  					return True
  			if debug_command is not None:
  				self.send(ShutItSendSpec(self,
  				                         send=debug_command,
  				                         check_exit=False,
  				                         echo=echo,
  			                             nonewline=nonewline,
  				                         loglevel=loglevel,
  			                             ignore_background=True))
  			time.sleep(cadence)
  		shutit.handle_note_after(note=note)
  		if pause_point_on_fail:
  			shutit.pause_point('send_until failed sending: ' + send + '\r\nand expecting: ' + str(regexps))
  			return True
  		return False