If the hours are showing, return the current hour. If the minutes are showing, return the
current minute.
777210
private int getCurrentlyShowingValue() {
        int currentIndex = getCurrentItemShowing();
        switch(currentIndex) {
            case HOUR_INDEX:
                return mCurrentTime.getHour();
            case MINUTE_INDEX:
                return mCurrentTime.getMinute();
            case SECOND_INDEX:
                return mCurrentTime.getSecond();
            default:
                return -1;
        }
    }
1056524
def get_time(self):
        
        if isinstance(self.path, pathlib.Path):
            thetime = self.path.stat().st_mtime
        else:
            thetime = np.nan
        return thetime
385289
def check_time(value):
    """"""
    try:
        h, m = value.split(':')
        h = int(h)
        m = int(m)
        if h >= 24 or h < 0:
            raise ValueError
        if m >= 60 or m < 0:
            raise ValueError
    except ValueError:
        raise TimeDefinitionError("Invalid definition of time %r" % value)
269018
def minute_change(device):
    ''''''
    hours = datetime.now().strftime('%H')
    minutes = datetime.now().strftime('%M')

    def helper(current_y):
        with canvas(device) as draw:
            text(draw, (0, 1), hours, fill="white", font=proportional(CP437_FONT))
            text(draw, (15, 1), ":", fill="white", font=proportional(TINY_FONT))
            text(draw, (17, current_y), minutes, fill="white", font=proportional(CP437_FONT))
        time.sleep(0.1)
    for current_y in range(1, 9):
        helper(current_y)
    minutes = datetime.now().strftime('%M')
    for current_y in range(9, 1, -1):
        helper(current_y)
432626
function () {
        var day, hour, minute, second,
            gapTime = this._finishTime - ( this._beginTime += this.DELAY );

        if ( gapTime <= 0 ) {
            return {_gap: 0, day: 0, hour: 0, minute: 0, second: 0};
        } else {
            day = Math.floor( gapTime / 1000 / 60 / 60 / 24 );
            hour = Math.floor( gapTime / 1000 / 60 / 60 - (24 * day) );
            minute = Math.floor( gapTime / 1000 / 60 - (24 * 60 * day ) - (60 * hour) );
            second = Math.floor( gapTime / 1000 - (24 * 60 * 60 * day) - (60 * 60 * hour) - (60 * minute) );
            return {_gap: gapTime, day: day, hour: hour, minute: minute, second: second};
        }
    }
176131
function () {
            if (this._duration) {
                return this._duration;
            }
            if (this._start && this._end) {
                return moment.duration(this._end - this._start);
            }
            else {
                return moment.duration(0);
            }
        }
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
104684
def hour_match(data, hours):
    
    hours = [hours] if isinstance(hours, int) else hours
    return data.isin(hours)
735970
@Override
    public Moment currentTime() {

        if ((this.monotonic || MONOTON_MODE) && LeapSeconds.getInstance().isEnabled()) {
            long nanos = this.utcNanos();
            return Moment.of(Math.floorDiv(nanos, MRD), (int) Math.floorMod(nanos, MRD), TimeScale.UTC);
        } else {
            long millis = System.currentTimeMillis();
            int nanos = ((int) Math.floorMod(millis, 1000)) * MIO;
            return Moment.of(Math.floorDiv(millis, 1000), nanos, TimeScale.POSIX);
        }

    }
1042037
def hours(self,local=False):
        
        delta = self.delta(local)
        return delta.total_seconds()/3600
1117997
def remaining_time(self):
        """"""
        if self.rate == 0:
            return None
        else:
            remaining_progress = self.done - self.current
            if self.rate == 0:
                if self.done == 0:
                    return 0
                else:
                    return None

            return remaining_progress / self.rate
551307
def now(self):
        ''' 
        '''
        utcnow = datetime.utcnow()
        return utcnow + timedelta(hours=self.time_zone)
204900
function isNearToCurrentTime (seconds) {
        var currentTime = getCurrentTime();
        var targetTime = getClampedTime(seconds);
        return Math.abs(currentTime - targetTime) <= CURRENT_TIME_TOLERANCE;
      }
737326
def elapsed_time(self) -> float:
        
        current_time = datetime.utcnow()
        start = self.start_time or current_time
        end = self.end_time or current_time
        return (end - start).total_seconds()
902475
def TimeinOpen(self):
    
    now = TWTime().now.hour
    if now >= 9 and now <= 14:
      return True
    else:
      return False
119289
def elapsed_time(self):
        
        if self._end_time:
            elapsed_time = round(self._end_time - self._start_time, 3)
            return elapsed_time
        else:
            return None
767087
public int getCurrentItemShowing() {
        if (mCurrentItemShowing != HOUR_INDEX && mCurrentItemShowing != MINUTE_INDEX) {
            Log.e(TAG, "Current item showing was unfortunately set to " + mCurrentItemShowing);
            return -1;
        }
        return mCurrentItemShowing;
    }