Delay for ``dl`` seconds.
511525
def delay(self, dl=0):
        
        if dl is None:
            time.sleep(self.dl)
        elif dl < 0:
            sys.stderr.write(
                "delay cannot less than zero, this takes no effects.\n")
        else:
            time.sleep(dl)
642512
def wait(self):
        """"""
        now = _monotonic()
        if now < self._ref:
            delay = max(0, self._ref - now)
            self.sleep_func(delay)
        self._update_ref()
437463
def shift_fn(self, i, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.k.press_key(self.k.shift_key)
        self.k.tap_key(self.k.function_keys[i])
        self.k.release_key(self.k.shift_key)
        self.delay(post_dl)
409782
function delay(timeout, value) {
        if (timeout < 0) {
            return value;
        }

        var future = new Future();
        setTimeout(function () {
            future.resolve(value);
        }, timeout);
        return future;
    }
1034683
def delay_on(self):
        

        # Workaround for ev3dev/ev3dev#225.
        # 'delay_on' and 'delay_off' attributes are created when trigger is set
        # to 'timer', and destroyed when it is set to anything else.
        # This means the file cache may become outdated, and we may have to
        # reopen the file.
        for retry in (True, False):
            try:
                self._delay_on, value = self.get_attr_int(self._delay_on, 'delay_on')
                return value
            except OSError:
                if retry:
                    self._delay_on = None
                else:
                    raise
545285
def _busy_wait_ms(self, ms):
        """"""
        start = time.time()
        delta = ms/1000.0
        while (time.time() - start) <= delta:
            pass
796007
function  (fn, context, rate, warningThreshold) {

        var queue = [],
            timeout;

        function next () {

            if (queue.length === 0) {
                timeout = null;
                return;
            }

            fn.apply(context, queue.shift());

            timeout = setTimeout(next, rate);
        }

        return function () {

            if (!timeout) {
                timeout = setTimeout(next, rate);
                fn.apply(context, arguments);
                return;
            }

            queue.push(arguments);

            if (queue.length * rate > warningThreshold) {
                console.warn("[WARNING] Rate limited function call will be delayed by", ((queue.length * rate) / 1000).toFixed(3), "secs");
            }
        };
    }
130551
def enter(self, n=1, interval=0, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.k.tap_key(self.k.enter_key, n, interval)
        self.delay(post_dl)
1289317
def delay!(uri)
      delay = delay(uri)
      sleep delay - (Time.now - @last_accessed) if delay
      @last_accessed = Time.now
    end
189369
def event_later(self, delay, data_tuple):
        
        return self._base.event_later(delay, self.make_event_data(*data_tuple))
1369240
def Alt_Fn(self, n, dl = 0):
        
        self.Delay(dl)
        self.keyboard.press_key(self.keyboard.alt_key)
        self.keyboard.tap_key(self.keyboard.function_keys[n])
        self.keyboard.release_key(self.keyboard.alt_key)
756461
public static Delay linear(TimeUnit unit, long upper, long lower) {
        return linear(unit, upper, lower, 1);
    }
540855
void delay(long alreadyElapsed) {
    recorder.recordValue(alreadyElapsed);
    if (distribution != null) {
      long nextPermitted = Math.round(distribution.sample() * 1000000000.0);
      if (nextPermitted > alreadyElapsed) {
        LockSupport.parkNanos(nextPermitted - alreadyElapsed);
      }
    }
  }
326141
def move_to(self, x, y, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.m.move(x, y)
        self.delay(post_dl)
245080
def delay(self, seconds=0, minutes=0):
        

        minutes += int(seconds / 60)
        seconds = seconds % 60
        seconds += float(minutes * 60)

        self.robot.pause()
        if not self.robot.is_simulating():
            _sleep(seconds)
        self.robot.resume()

        return self
18355
def down(self, n=1, interval=0, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.k.tap_key(self.k.down_key, n, interval)
        self.delay(post_dl)
1254766
def blink(self, delay=1):
        
        self.toggle()
        gevent.spawn_later(delay, self.toggle)