code: def until(self, condition, is_true=None, message=""):
          
  
          rv = None
          last_exc = None
          until = is_true or until_pred
          start = self.clock.now
  
          while not until(self.clock, self.end):
              try:
                  rv = condition()
              except (KeyboardInterrupt, SystemExit) as e:
                  raise e
              except self.exceptions as e:
                  last_exc = sys.exc_info()
  
              if isinstance(rv, bool) and not rv:
                  time.sleep(self.interval)
                  continue
  
              if rv is not None:
                  return rv
  
              self.clock.sleep(self.interval)
  
          if message:
              message = " with message: %s" % message
  
          raise TimeoutException(
              "Timed out after %s seconds%s" %
              ((self.clock.now - start), message), cause=last_exc)
docs: Repeatedly runs condition until its return value evalutes to true,
          or its timeout expires or the predicate evaluates to true.
  
          This will poll at the given interval until the given timeout
          is reached, or the predicate or conditions returns true.  A
          condition that returns null or does not evaluate to true will
          fully elapse its timeout before raising a
          ``TimeoutException``.
  
          If an exception is raised in the condition function and it's
          not ignored, this function will raise immediately.  If the
          exception is ignored, it will continue polling for the
          condition until it returns successfully or a
          ``TimeoutException`` is raised.
  
          The return value of the callable `condition` will be returned
          once it completes successfully.
  
          :param condition: A callable function whose return value will
              be returned by this function if it evalutes to true.
  
          :param is_true: An optional predicate that will terminate and
              return when it evalutes to False.  It should be a function
              that will be passed `clock` and an end time.  The default
              predicate will terminate a wait when the clock elapses the
              timeout.
  
          :param message: An optional message to include in the
              exception's message if this function times out.
  
          :returns: Return value of `condition`.