Returns the last modified timestamp of the given File.
199743
private static long getLastModifiedTime(File file) {
    long fileLastModified = file.lastModified();
    // If the file is absent, we don't know if it changed (maybe was deleted),
    // so assume it has just changed.
    if (fileLastModified == 0) {
      fileLastModified = new Date().getTime();
    }
    return fileLastModified;
  }
246577
def get_last_modified_date(
            self,
            bucket: str,
            key: str,
    ) -> datetime:
        
        response = self.get_all_metadata(bucket, key)
        return response['LastModified']
1195059
def _file_timestamp_info(self, path):
        
        files = [os.path.join(path, fname) for fname in os.listdir(path) if '.py' in fname]
        return dict ([(fname, os.path.getmtime(fname)) for fname in files])
55363
def timestamp
      if File.exist?(name)
        File.mtime(name.to_s)
      else
        Rake::EARLY
      end
    end
1230347
def get_path_modified_time(path):
        

        return float(foundations.common.get_first_item(str(os.path.getmtime(path)).split(".")))
356903
public long getLogFileTimestamp(File file) {
        if (file == null) {
            return -1L;
        }

        String name = file.getName();

        // Check name for extension
        if (name == null || name.length() == 0 || !name.endsWith(EXTENSION)) {
            return -1L;
        }

        try {
            return Long.parseLong(name.substring(0, name.indexOf(EXTENSION)));
        } catch (NumberFormatException ex) {
            return -1L;
        }
    }
527224
def wasModified(self):
        
        self.filePath.restat()
        mtime = self.filePath.getmtime()
        if mtime >= self.lastModified:
            return True
        else:
            return False
1110428
def __timestamp():
    """"""
    today = time.time()
    ret = struct.pack(b'=L', int(today))
    return ret
490307
function getAddMtime(file, done) {
    fs.stat(path.join(source, file), addMtime);


    /**
     * Adds `stats.mtime` of `file` to its metadata.
     *
     * @param {Error} err
     * @param {fs.Stats} stats
     * @api private
     */

    function addMtime(err, stats) {
      if (err) {
        // Skip elements of `files` that don't point to existing files.
        // This can happen if some other Metalsmith plugin does something
        // strange with `files`.
        if (err.code === 'ENOENT') {
          debug('file %s not found', file);
          return done();
        }
        return done(err);
      }

      debug('mtime of file %s is %s', file, stats.mtime);
      files[file].mtime = stats.mtime;
      done();
    }
  }
787621
function compareLastModifiedTime(stream, sourceFile, targetPath) {
	return stat(targetPath)
		.then(targetStat => {
			if (sourceFile.stat && sourceFile.stat.mtime > targetStat.mtime) {
				stream.push(sourceFile);
			}
		});
}
770027
def timestamp_file():
    """"""
    config_dir = os.path.join(
        os.path.expanduser("~"), BaseGlobalConfig.config_local_dir
    )

    if not os.path.exists(config_dir):
        os.mkdir(config_dir)

    timestamp_file = os.path.join(config_dir, "cumulus_timestamp")

    try:
        with open(timestamp_file, "r+") as f:
            yield f
    except IOError:  # file does not exist
        with open(timestamp_file, "w+") as f:
            yield f
179728
def last_update_time(self) -> float:
        """"""
        stdout = self.stdout_interceptor
        stderr = self.stderr_interceptor

        return max([
            self._last_update_time,
            stdout.last_write_time if stdout else 0,
            stderr.last_write_time if stderr else 0,
        ])
484795
def last_modified(self):
        """"""
        # FIXME: Make this sensible
        last_modified = time.strftime(
            "%a, %d %b %Y %H:%M:%S GMT",
            time.gmtime(time.time()))
        return last_modified
1020128
function processFileByModifiedTime(stream, firstPass, basePath, file, cache) {
  var newTime = file.stat && file.stat.mtime;
  var filePath = basePath ? path.relative(basePath, file.path) : file.path;
  var oldTime = cache[filePath];

  cache[filePath] = newTime.getTime();

  if ((!oldTime && firstPass) || (oldTime && oldTime !== newTime.getTime())) {
    stream.push(file);
  }
}
755086
private void determineChangesSince(File file, long lastScanTime) {
		try {
			if (GlobalConfiguration.verboseMode && log.isLoggable(Level.INFO)) {
				log.info("Firing file changed event " + file);
			}
			listener.fileChanged(file);
			if (file.isDirectory()) {
				File[] filesOfInterest = file.listFiles(new RecentChangeFilter(lastScanTime));
				for (File f : filesOfInterest) {
					if (f.isDirectory()) {
						determineChangesSince(f, lastScanTime);
					}
					else {
						if (GlobalConfiguration.verboseMode && log.isLoggable(Level.INFO)) {
							log.info("Observed last modification time change for " + f + "  (lastScanTime="
									+ lastScanTime + ")");
							log.info("Firing file changed event " + file);
						}
						listener.fileChanged(f);
					}
				}
			}
		}
		catch (Throwable t) {
			if (log.isLoggable(Level.SEVERE)) {
				log.log(Level.SEVERE, "FileWatcher caught serious error, see cause", t);
			}
		}
	}
521021
public long getLastModified() {
        if(matchedEntry != null){
            return matchedEntry.getLastModified();
        } else if (matchedZipFile != null){
            return matchedZipFile.getLastModified();
        } else if (matchedFile != null){
            return matchedFile.lastModified();
        } else {
            return 0;
        }
    }
214139
def modification_time(self):
    """"""
    timestamp = getattr(
        self._cpio_archive_file_entry, 'modification_time', None)
    if timestamp is None:
      return None
    return dfdatetime_posix_time.PosixTime(timestamp=timestamp)