Return the wait time between requests.

        Args:
            seconds: The original time in seconds.
            item_session:
            error:

        Returns:
            The time in seconds.
169467
def plugin_wait_time(seconds: float, item_session: ItemSession, error: Optional[Exception]=None) -> float:
        '''
        '''
        return seconds
621163
def SecondsToZuluTS(secs=None):
	

	if not secs:  secs = int(time.time())

	return(datetime.utcfromtimestamp(secs).strftime("%Y-%m-%dT%H:%M:%SZ"))
1311868
def time_wait(
    predicate,
    timeout_seconds=120,
    sleep_seconds=1,
    ignore_exceptions=True,
    inverse_predicate=False,
    noisy=True,
    required_consecutive_success_count=1):
    
    start = time_module.time()
    wait_for(predicate, timeout_seconds, sleep_seconds, ignore_exceptions, inverse_predicate, noisy, required_consecutive_success_count)
    return elapse_time(start)
1331689
def seconds(self):
        
        seconds = self.elapsed().seconds
        if self.limit() and self.countdown():
            seconds = (self.limit() - self.elapsed().seconds)
        return (seconds % 3600) % 60
241362
def delay(self, seconds=0, minutes=0, msg=None):
        
        delay_time = seconds + minutes * 60
        self._hw_manager.hardware.delay(delay_time)
1316603
def time(ctx, hours, minutes, seconds):
    
    return _time(conversions.to_integer(hours, ctx), conversions.to_integer(minutes, ctx), conversions.to_integer(seconds, ctx))
420040
def next(self):
        
        if self.blocking >= 0:
            # returns queue name and item, we just need item
            res = self.redis.blpop([self.name], timeout=self.blocking)
            if res:
                res = res[1]
        else:
            res = self.redis.lpop(self.name)
        value = self.deserialize(res)
        logger.debug('Popped from "%s": %s', self.name, repr(value))
        return value
897697
def sleep(self, seconds):
        
        until = time.time() + seconds
        try:
            while True:
                self._service_futures([], until)
        except TimeoutError:
            return
699713
def second_params_two(test, two):
    
    if request.method == 'POST':
        return [test, two, request.data]
    return {'result': [test, two]}
93590
def lock(self, seconds=5):
        
        self._current_application().lock(robot.utils.timestr_to_secs(seconds))
244906
def duration(self):
        
        duration = 0.0
        if len(self.events) > 0:
            first = datetime.fromtimestamp(self.events[0]['timestamp'])
            last = datetime.fromtimestamp(self.events[-1]['timestamp'])
            duration = (last - first).total_seconds()
        return duration
377001
def get_formatted_time(seconds: float) -> str:
    
    seconds = round(seconds)
    m, s = divmod(seconds, 60)
    h, m = divmod(m, 60)
    return '{:d}:{:02d}:{:02d}'.format(h, m, s)
314036
def requestTimingInfo(self):
        
        try:
            return tuple(item.split('=')[1] for item in self.http_response.header.get('CMS-Server-Time').split())
        except AttributeError:
            return None, None
1306179
def get_seconds(value, scale):
  
  scales = {
    'seconds': lambda x: x,
    'minutes': lambda x: x * 60,
    'hours': lambda x: x * 60 * 60,
    'days': lambda x: x * 60 * 60 * 24,
    'weeks': lambda x: x * 60 * 60 * 24 * 7,
    'months': lambda x: x * 60 * 60 * 24 * 30,
    'years': lambda x: x * 60 * 60 * 24 * 365,
  }
  return scales[scale](value)
239826
def get_time_to_merge_request_response(self, item):
        
        review_dates = [str_to_datetime(review['created_at']) for review in item['review_comments_data']
                        if item['user']['login'] != review['user']['login']]
        if review_dates:
            return min(review_dates)
        return None
223394
def duration(self):
        
        if self.end_datetime is None or self.start_datetime is None:
            return 0
        return (self.end_datetime - self.start_datetime).total_seconds()
643008
def get(self, timeout=None):
        
        if not self.wait(timeout):
            raise TimeoutError("Result not available within %fs" % timeout)
        if self._success:
            return self._data
        raise self._data[0]