Set the polling interval for the process thread.

        :param interval: How often to poll the Hottop
        :type interval: int or float
        :returns: None
        :raises: InvalidInput
16849
def set_interval(self, interval):
        
        if type(interval) != float or type(interval) != int:
            raise InvalidInput("Interval value must be of float or int")
        self._config['interval']
1310068
public void setPollInterval( long pollInterval ) {

		this.pollInterval = pollInterval;
		this.logger.fine( "Template watcher poll interval set to " + pollInterval );
		synchronized( this.watcherLock ) {
			if( this.templateWatcher != null )
				resetWatcher();
		}
	}
56326
def interval_timed(interval):
    '''
    '''
    def decorator(f):
        @wraps(f)
        def wrapper(*args, **kwargs):
            stopped = Event()

            def loop():  # executed in another thread
                while not stopped.wait(interval):  # until stopped
                    f(*args, **kwargs)

            t = Thread(name='IntervalTimerThread', target=loop)
            t.daemon = True  # stop if the program exits
            t.start()
            return stopped.set
        return wrapper
    return decorator
359824
public S pollInterval(long poll, TemporalUnit pollUnit) {
        Preconditions.checkArgument(0 <= poll);
        this.poll = Duration.of(poll, pollUnit);
        return self();
    }
1268814
public void addTimeInterval(T interval){
		timeIntervals.add(interval);
		minBorders.setStart(Math.max(minBorders.getStart(), interval.getStart()));
		minBorders.setEnd(Math.min(minBorders.getEnd(), interval.getEnd()));
		if(maxBorders == null){
			maxBorders = interval.clone();
		} else {
			maxBorders.setStart(Math.min(maxBorders.getStart(), interval.getStart()));
			maxBorders.setEnd(Math.max(maxBorders.getEnd(), interval.getEnd()));
		}
	}
1274236
function startInterval() {
    if (intervalId !== null) {
        return;
    }
    intervalId = setInterval(function () {
        if (remainedTasks.length && currentCount < limitCount) {
            var task = remainedTasks.shift();
            currentCount++;
            if (monitorCallback) {
                monitorCallback("start", remainedTasks);
            }
            var process = originalSpawn.apply(null, task[0]);
            process.on("close", function (code) {
                if (monitorCallback) {
                    monitorCallback("close", remainedTasks, code);
                }
                currentCount--;
                if (currentCount === 0 && remainedTasks.length === 0) {
                    callWaitAllCallbacks();
                }
            });
            var callback = remainedTaskCallbacks[task[1]];
            delete remainedTaskCallbacks[task[1]];
            if (callback) {
                callback(process);
            }
        }
    }, 20);
}
790496
def timer_tick(self):
        
        # TODO: should exceptions thrown from this be caught and ignored
        self.process_timers()

        delta = datetime.timedelta(milliseconds=self.base_interval_msec)
        self._timeout = IOLoop.current().add_timeout(delta, self.timer_tick)
668380
def wait(self, timeout=3):
        

        start = time.time()
        while not self.exists():
            self.poco.sleep_for_polling_interval()
            if time.time() - start > timeout:
                break
        return self
1028233
def open(lower_value, upper_value):
    
    return Interval(Interval.OPEN, lower_value, upper_value, Interval.OPEN)
178483
def add(self, interval: Interval) -> None:
        
        if interval is None:
            return
        if not isinstance(interval, Interval):
            raise TypeError(
                "Attempt to insert non-Interval into IntervalList")
        self.intervals.append(interval)
        self._tidy()
359261
def stop(self):
        
        if self.interval is not None:
            self._queue.put_nowait(None)
            self._thread.join()
            self.interval = None
1205152
def _poll_update_interval(self):
        
        # Increase by 1 second every 3 polls
        if old_div(self.poll_count, 3) > self.poll_interval_level:
            self.poll_interval_level += 1
            self.poll_interval_s += 1
            self.logger.info(
                "Increased polling interval to %d seconds", self.poll_interval_s
            )
518095
def wait(self, seconds, poll_interval):
        
        # jid is None when all hosts were skipped
        if self.jid is None:
            return self.results

        clock = seconds - poll_interval
        while (clock >= 0 and not self.completed):
            time.sleep(poll_interval)

            poll_results = self.poll()

            for (host, res) in poll_results['polled'].iteritems():
                if res.get('started'):
                    self.runner.callbacks.on_async_poll(host, res, self.jid, clock)

            clock = clock - poll_interval

        return self.results
1244564
def next_interval(self, interval):
        
        index = np.where(self.intervals == interval)
        if index[0][0] + 1 < len(self.intervals):
            return self.intervals[index[0][0] + 1]
        else:
            raise IndexError("Ran out of intervals!")
192548
public void setPollSleep(long time, TimeUnit unit)
    {
        if (unit.toMillis(time) < MIN_POLL_MS)
        {
            LOG.warning(String.format("Poll interval cannot be less than %d seconds. Setting it to %d seconds.", TimeUnit.MILLISECONDS.toSeconds(MIN_POLL_MS), TimeUnit.MILLISECONDS.toSeconds(MIN_POLL_MS)));
            pollMs.set(MIN_POLL_MS);
        }
        else
        {
            pollMs.set(unit.toMillis(time));
        }
    }
1268445
public S interval(Long interval) {
        builder.interval(String.valueOf(interval));
        return self;
    }
1047503
def start(self, interval=None):
        
        # update the interval value
        with QtCore.QReadLocker(self.__lock):
            if interval is None:
                interval = self.__interval
            else:
                self.__interval = interval
        
        # request the timer to start
        self._startRequested.emit(interval)