Return ellapsed time and reset start.
482442
def runtime(self):
        
        t = time.time() - self.start
        self.start = time.time()
        return t
1122781
def reset(self) -> None:
        
        self._overallstart = get_now_utc_pendulum()
        self._starttimes.clear()
        self._totaldurations.clear()
        self._count.clear()
        self._stack.clear()
227949
def end_time(self):
        """"""
        try:
            return self.start_time + SCAN_DURATION[self.sector]
        except KeyError:
            return self.start_time
1139133
def reset(self):
        """"""

        sun = ephem.Sun()
        this_time = Time(self.date.get(), scale='utc')
        sun.compute(this_time.iso)
        self.sun = Coord((sun.ra, sun.dec))

        self.doplot()
        self.plot_pointings()
948156
def elapsed(self):
        """"""
        if not self.started or self._start_time is None:
            return 0.0
        return self._timing_data[-1][0] - self._start_time
218893
def ResetTimingValues(self):
        
        self._log.debug("In ResetTimingValues()")
        for tmp_timing in self.timing_maps.itervalues():
            tmp_timing.average = 0.
            tmp_timing.minimum = 0.
            tmp_timing.maximum = 0.
            tmp_timing.total_elapsed = 0.
            tmp_timing.calls = 0.
905204
def timed (log=sys.stderr, limit=2.0):
    """"""
    return lambda func: timeit(func, log, limit)
1146876
def itimes(self, start=0, stop=-1, callback=None, **kwargs):
        ''''''
        backend = self.read_backend
        res = backend.structure(self).itimes(start, stop, **kwargs)
        return backend.execute(res, callback or self.load_keys)
1152707
def reset(self):
        """"""
        self.data_stack = stack.Stack()
        self.return_stack = stack.Stack()
        self.instruction_pointer = 0
        return self
1184021
def get_start_time(self):
        
        start_time = c_double()
        self.library.get_start_time.argtypes = [POINTER(c_double)]
        self.library.get_start_time.restype = None
        self.library.get_start_time(byref(start_time))
        return start_time.value
1276622
def reset(self):
        """"""
        if self._rst is None:
            return
        # Set reset high for a millisecond.
        self._gpio.set_high(self._rst)
        time.sleep(0.001)
        # Set reset low for 10 milliseconds.
        self._gpio.set_low(self._rst)
        time.sleep(0.010)
        # Set reset high again.
        self._gpio.set_high(self._rst)
758173
function resetTimer() {
              if( cancelTimer ) {
                cancelTimer();
                cancelTimer = null;
              }
              if( start && Date.now() - start > maxWait ) {
                if(!runScheduledForNextTick){
                  runScheduledForNextTick = true;
                  utils.compile(runNow);
                }
              }
              else {
                if( !start ) { start = Date.now(); }
                cancelTimer = utils.wait(runNow, wait);
              }
            }
418682
def reset(self):
        """"""
        self.minimum = None
        self.maximum = None
        self.start_time = None  # datetime, absolute start time

        self.idx_current = None
        self.idx_markers = []
        self.idx_annot = []

        if self.scene is not None:
            self.scene.clear()
        self.scene = None
877587
public function resetTimer()
    {
        if (empty($this->timer) === true) {
            $this->timer = time() + $this->maxRuntime;
        }
    }
166500
function getElapsedTime(startTime) {
	const prettyHrtime = require("pretty-hrtime");
	const timeDiff = process.hrtime(startTime);
	return prettyHrtime(timeDiff);
}
873627
def clear_start_date(self):
        
        if (self.get_start_date_metadata().is_read_only() or
                self.get_start_date_metadata().is_required()):
            raise NoAccess()
        default_start_date = self._start_date_metadata['default_date_time_values'][0]
        self.my_osid_object_form._my_map['startDate'] = DateTime(year=default_start_date.year,
                                                                 month=default_start_date.month,
                                                                 day=default_start_date.day,
                                                                 hour=default_start_date.hour,
                                                                 minute=default_start_date.minute,
                                                                 second=default_start_date.second,
                                                                 microsecond=default_start_date.microsecond)
112278
def reset(self):
        """"""
        if self.resetable:
            for i in range(len(self)):
                self[i] = self.default