Return the dispatch time
161436
public long getDispatchTime(TaskAttemptID taskid){
    Long l = dispatchTimeMap.get(taskid);
    if (l != null) {
      return l.longValue();
    }
    return 0;
  }
435531
def generation_dispatchable(self):
        
        try:
            return self._generation_dispatchable.loc[[self.timeindex], :]
        except:
            return self._generation_dispatchable.loc[self.timeindex, :]
1246082
def dispatch(location='Central'):
        
        dispatch = XView._dispatch.get(nativestring(location))
        if not dispatch:
            dispatch = XViewDispatch(QApplication.instance())
            XView._dispatch[nativestring(location)] = dispatch
        
        return dispatch
1102874
def dispatch(self):
        """"""
        method_name = 'on_' + self.environ['REQUEST_METHOD'].lower()
        method = getattr(self, method_name, None)
        if method:
            return method()
        else:
            return self.on_bad_method()
895659
def issued_at(self):
        
        issued_at = self._issued_at
        if issued_at is None:
            self._issued_at = int(time.time())
        return self._issued_at
1315362
def get_time_eta(total_done, total, start_time):
    
    time_done = int(time()) - start_time
    speed = total_done / time_done

    if time_done > 0 and speed > 0:
        total_to_go = total - total_done
        time_to_go = total_to_go / speed
        minutes, seconds = divmod(time_to_go, 60)
        hours, minutes = divmod(minutes, 60)
        percentage = total_done * 100.0 / total
    else:
        percentage = 0
        hours = 0
        minutes = 0
        seconds = 0

    return {
        "done": int(total_done),
        "tot": int(total),
        "%": float("{0:.2f}".format(percentage)),
        "h": int(hours),
        "m": int(minutes),
        "s": int(seconds)
    }
1310131
private TimeUnit getPollUnit() {
    String unit = mProperties.getProperty(CONSOLE_KEY_UNIT);
    if (unit == null) {
      unit = CONSOLE_DEFAULT_UNIT;
    }
    return TimeUnit.valueOf(unit.toUpperCase());
  }
880344
def _get_time(header, keys, name):
        
        for key in keys:
            try:
                return _to_timestamp(header.pop(key))
            except KeyError:
                continue
        raise _UnsupportedOperation(name)
133278
def _dispatch(name, *args, **kwargs):
        

        def outer(self, *args, **kwargs):
            def f(x):
                x = self._shallow_copy(x, groupby=self._groupby)
                return getattr(x, name)(*args, **kwargs)
            return self._groupby.apply(f)
        outer.__name__ = name
        return outer
861476
def get_transition_time(self):
        """"""
        self.get_status()
        try:
            self.transition_time = self.data['ramp']
        except TypeError:
            self.transition_time = 0

        return self.transition_time
439216
def get_current_time(self):
        
        current_time = c_double()
        self.library.get_current_time.argtypes = [POINTER(c_double)]
        self.library.get_current_time.restype = None
        self.library.get_current_time(byref(current_time))
        return current_time.value
1110428
def __timestamp():
    """"""
    today = time.time()
    ret = struct.pack(b'=L', int(today))
    return ret
72815
def load(self):
        
        try:
            return self._load.loc[[self.timeindex], :]
        except:
            return self._load.loc[self.timeindex, :]
1134575
def dispatch(self):
        ''
        import flask
        body = flask.request.get_json()
        return self. dispatch_with_args(body, argMap=dict())
905204
def timed (log=sys.stderr, limit=2.0):
    """"""
    return lambda func: timeit(func, log, limit)
1304493
def get_time(self, instance):
        
        url = '/instances/{}'.format(instance)
        response = self.get_proto(url)
        message = yamcsManagement_pb2.YamcsInstance()
        message.ParseFromString(response.content)
        if message.HasField('missionTime'):
            return parse_isostring(message.missionTime)
        return None
491016
def get(self):
        ''''''
        if self.bucket.get() < 1:
            return None
        now = time.time()
        self.mutex.acquire()
        try:
            task = self.priority_queue.get_nowait()
            self.bucket.desc()
        except Queue.Empty:
            self.mutex.release()
            return None
        task.exetime = now + self.processing_timeout
        self.processing.put(task)
        self.mutex.release()
        return task.taskid