Display a message in lbl_feedback, which times out after some
        number of seconds.
15113
def _show_feedback_label(self, message, seconds=None):
        
        if seconds is None:
            seconds = CONFIG['MESSAGE_DURATION']

        logger.debug('Label feedback: "{}"'.format(message))

        self.feedback_label_timer.timeout.connect(self._hide_feedback_label)
        self.lbl_feedback.setText(str(message))
        self.lbl_feedback.show()
        self.feedback_label_timer.start(1000 * seconds)
1348238
def get_feedback(self, block = True, timeout = None):
		
		if self._feedback_greenlet is None:
			self._feedback_greenlet = gevent.spawn(self._feedback_loop)
		return self._feedback_queue.get(block = block, timeout = timeout)
371710
def stop(self, timeout = 10.0):
		
		if (self._send_greenlet is not None) and \
				(self._send_queue.qsize() > 0):
			self.wait_send(timeout = timeout)

		if self._send_greenlet is not None:
			gevent.kill(self._send_greenlet)
			self._send_greenlet = None
		if self._error_greenlet is not None:
			gevent.kill(self._error_greenlet)
			self._error_greenlet = None
		if self._feedback_greenlet is not None:
			gevent.kill(self._feedback_greenlet)
			self._feedback_greenlet = None

		return self._send_queue.qsize() < 1
1269708
def on_message_received(self, msg):
        
        if self.is_stopped:
            raise RuntimeError("reader has already been stopped")
        else:
            self.buffer.put(msg)
244748
def display_message(self, clear, beep, timeout, line1, line2):
        """"""
        self._elk.send(
            dm_encode(self._index, clear, beep, timeout, line1, line2)
        )
76953
def _timeout(self, watcher, events):
        """"""
        self.timedout = True
        self._finish()
        self.deferred.errback(TimeoutError())
197583
def timeout(seconds=10, default_output='default_output'):
    
    def decorator(func):
        def _handle_timeout(signum, frame):
            """ throw the custom TimeoutError if called """
            raise TimeoutError(strerror(ETIME))

        def wrapper(*args, **kwargs):
            """ main wrapper for the error """
            # set up the propper error signal
            signal(SIGALRM, _handle_timeout)
            # set the time the function has to run
            alarm(seconds)
            try:
                result = func(*args, **kwargs)
            except TimeoutError:
                if default_output == 'default_output':
                    raise
                else:
                    result = default_output
            finally:
                # cancel the timer
                alarm(0)
            return result

        return wraps(func)(wrapper)
    return decorator
1260148
def checkTimeout(self, now):
        """"""
        log.debug("checking for timeout on session %s", self)
        if now - self.last_update > self.timeout:
            raise TftpTimeout("Timeout waiting for traffic")
761070
def mark_received(self, visibility_timeout=None):
        
        if visibility_timeout:
            visibility_timeout = int(visibility_timeout)
        else:
            visibility_timeout = 0

        if not self.approximate_first_receive_timestamp:
            self.approximate_first_receive_timestamp = int(unix_time_millis())

        self.approximate_receive_count += 1

        # Make message visible again in the future unless its
        # destroyed.
        if visibility_timeout:
            self.change_visibility(visibility_timeout)

        self.receipt_handle = generate_receipt_handle()
252126
async def _perform_ping_timeout(self, delay: int):
        

        # pause for delay seconds
        await sleep(delay)
        # then continue
        error = TimeoutError(
            'Ping timeout: no data received from server in {timeout} seconds.'.format(
                timeout=self.PING_TIMEOUT))
        await self.on_data_error(error)
985935
function longWait (message, timer, cb) {
	setTimeout(function () {
		console.log(message);
		cb("pang"); //always return "pang"
	}, timer); //wait one second before logging
}
1317141
def _validate_timeout(seconds: float):
    """"""
    val = int(seconds * 1000)
    assert 60000 <= val <= 4294967294, "Bad value: {}".format(val)
    return val
308273
def timer(message):
    ""
    tick = time.time()
    yield
    tock = time.time()
    print("%s: %.3f seconds" % (message, (tock - tick)))
741126
public void showFeedback(String feedbackText) {
        feedbackSpan.setText(feedbackText);
        new MaterialAnimation().transition(Transition.FADEINUP).duration(400).animate(feedbackSpan);
        MaterialLoader.loading(true, getCurrentStep().getDivBody());
        add(divFeedback);
    }
689530
def showStatus(self, msg):
        
        log.debug(msg)
        self.statusBar().showMessage(msg)
141960
def showMessage(self,
                    title,
                    message,
                    icon=QtGui.QSystemTrayIcon.Information,
                    timeout=10000):
        
        tray = self.trayIcon()
        if tray:
            tray.showMessage(title, message, icon, timeout)
1034014
public static String getTimeoutMessage(long timeout, TimeUnit unit) {
        return String.format("Timeout of %d %s reached", timeout, requireNonNull(unit, "unit"));
    }