Figure out the which mtime to check against.

    If we have to look up the path return that.
505676
def get_walk_after(filename, optimize_after=None):
    
    if Settings.optimize_after is not None:
        return Settings.optimize_after

    dirname = os.path.dirname(filename)
    if optimize_after is None:
        optimize_after = _get_parent_timestamp(dirname, optimize_after)
    return _max_timestamps(dirname, True, optimize_after)
335243
def conditions(self, full_path, environ):
        """"""
        mtime = int(time.time())
        return str(mtime), rfc822.formatdate(mtime)
662761
function getDirContentMTime(dirPath, ignoredDirs, ignoredFiles){
    let mtime
    if(fs.existsSync(dirPath)){
        _ignoredDirs.push.apply(_ignoredDirs, ignoredDirs)
        _ignoredFiles.push.apply(_ignoredFiles, ignoredFiles)
        mtime = recursiveGetDirContentMTime(dirPath)
    }
    return mtime
}
976982
def get_using_network_time():
    '''
    
    '''
    ret = salt.utils.mac_utils.execute_return_result(
        'systemsetup -getusingnetworktime')

    return salt.utils.mac_utils.validate_enabled(
        salt.utils.mac_utils.parse_return(ret)) == 'on'
539277
def check_time_extrator(self):
        

        if self.year_check and self.month_check and self.day_check:
            time = str(self.year) + '-' + str(self.month) + '-' + str(self.day)
            release_time = datetime.datetime.strptime(time, "%Y-%m-%d").date()
            return release_time
1208828
private long getLastTimeStamp(Path pathToCheck) {
    long lastTimeStamp = -1;
    long tmpTimeStamp = -1;
    try {
      for (FileStatus fileStat: fs.listStatus(pathToCheck)) {
        Path srcPath = fileStat.getPath();
        if (!fileStat.isDir()) {
          boolean checkFlag = true;
          if (release_pattern != null) {
            // just need to check the files that match the pattern
            Matcher m = release_pattern.matcher(srcPath.toString());
            if (!m.find()) {
              checkFlag = false;
            } 
          }
          if (checkFlag) {
            tmpTimeStamp = fileStat.getModificationTime();
          } else {
            continue;
          }
        } else {
          tmpTimeStamp = getLastTimeStamp(srcPath);
        }
        if (tmpTimeStamp > lastTimeStamp) {
          lastTimeStamp = tmpTimeStamp;
        }
      }
    } catch (IOException ioe) {
      LOG.error("IOException when checking timestamp ", ioe);
    }
    return lastTimeStamp;
  }
938209
def dir_modtime(dpath):
    
    return max(os.path.getmtime(d) for d, _, _ in os.walk(dpath))
450939
def set_mtime(self, name, mtime, size):
        """"""
        self.check_write(name)
        os.utime(os.path.join(self.cur_dir, name), (-1, mtime))
315505
def _getFromDt(self):
        
        myNow = timezone.localtime(timezone=self.tz)
        return self.__after(myNow) or self.__before(myNow)
1314076
def _check_touch(name, atime, mtime):
    '''
    
    '''
    ret = {
        'result': None,
        'comment': '',
        'changes': {'new': name},
    }
    if not os.path.exists(name):
        ret['comment'] = 'File {0} is set to be created'.format(name)
    else:
        stats = __salt__['file.stats'](name, follow_symlinks=False)
        if ((atime is not None
             and six.text_type(atime) != six.text_type(stats['atime'])) or
            (mtime is not None
                and six.text_type(mtime) != six.text_type(stats['mtime']))):
            ret['comment'] = 'Times set to be updated on file {0}'.format(name)
            ret['changes'] = {'touched': name}
        else:
            ret['result'] = True
            ret['comment'] = 'File {0} exists and has the correct times'.format(name)
    return ret
1075138
def has(self, key, mtime=None):
        
        v = self.__values.get(key, None)
        if not v:
            return False
        if self.check_modified_time:
            mtime = self._get_mtime(key, mtime)
            if mtime != self.__modified_times[key]:
                del self[key]
                return False
        return True
787621
function compareLastModifiedTime(stream, sourceFile, targetPath) {
	return stat(targetPath)
		.then(targetStat => {
			if (sourceFile.stat && sourceFile.stat.mtime > targetStat.mtime) {
				stream.push(sourceFile);
			}
		});
}
1277772
def GetPathInfo(self, timestamp=None):
    
    path_info_timestamp = self._LastEntryTimestamp(self._path_infos, timestamp)
    try:
      result = self._path_infos[path_info_timestamp].Copy()
    except KeyError:
      result = rdf_objects.PathInfo(
          path_type=self._path_type, components=self._components)

    stat_entry_timestamp = self._LastEntryTimestamp(self._stat_entries,
                                                    timestamp)
    result.last_stat_entry_timestamp = stat_entry_timestamp
    result.stat_entry = self._stat_entries.get(stat_entry_timestamp)

    hash_entry_timestamp = self._LastEntryTimestamp(self._hash_entries,
                                                    timestamp)
    result.last_hash_entry_timestamp = hash_entry_timestamp
    result.hash_entry = self._hash_entries.get(hash_entry_timestamp)

    return result
809733
public static function mTime($path)
    {
        $path = Normalize::diskFullPath($path);
        if (!self::exist($path)) {
            return 0;
        }

        return filemtime($path);
    }
349731
def mtime(filename, local = false)
      str = mdtm(filename)
      ary = str.scan(MDTM_REGEXP)[0].collect {|i| i.to_i}
      return local ? Time.local(*ary) : Time.gm(*ary)
    end
80853
def modification_time(path)
      is_uri = URI.parse(path)
      if !is_uri.host.nil?
        return web_modification_time is_uri
      end
      File.new(path).mtime
    end
170887
def getLTime():
    """"""

    _ltime = _time.localtime(_time.time())
    tlm_str = _time.strftime('%H:%M:%S (%d/%m/%Y)', _ltime)
    return tlm_str