"""distutils.dep_util | |
Utility functions for simple, timestamp-based dependency of files | |
and groups of files; also, function based entirely on such | |
timestamp dependency analysis.""" | |
__revision__ = "$Id$" | |
import os | |
from distutils.errors import DistutilsFileError | |
def newer(source, target): | |
"""Tells if the target is newer than the source. | |
Return true if 'source' exists and is more recently modified than | |
'target', or if 'source' exists and 'target' doesn't. | |
Return false if both exist and 'target' is the same age or younger | |
than 'source'. Raise DistutilsFileError if 'source' does not exist. | |
Note that this test is not very accurate: files created in the same second | |
will have the same "age". | |
""" | |
if not os.path.exists(source): | |
raise DistutilsFileError("file '%s' does not exist" % | |
os.path.abspath(source)) | |
if not os.path.exists(target): | |
return True | |
return os.stat(source).st_mtime > os.stat(target).st_mtime | |
def newer_pairwise(sources, targets): | |
"""Walk two filename lists in parallel, testing if each source is newer | |
than its corresponding target. Return a pair of lists (sources, | |
targets) where source is newer than target, according to the semantics | |
of 'newer()'. | |
""" | |
if len(sources) != len(targets): | |
raise ValueError, "'sources' and 'targets' must be same length" | |
# build a pair of lists (sources, targets) where source is newer | |
n_sources = [] | |
n_targets = [] | |
for source, target in zip(sources, targets): | |
if newer(source, target): | |
n_sources.append(source) | |
n_targets.append(target) | |
return n_sources, n_targets | |
def newer_group(sources, target, missing='error'): | |
"""Return true if 'target' is out-of-date with respect to any file | |
listed in 'sources'. | |
In other words, if 'target' exists and is newer | |
than every file in 'sources', return false; otherwise return true. | |
'missing' controls what we do when a source file is missing; the | |
default ("error") is to blow up with an OSError from inside 'stat()'; | |
if it is "ignore", we silently drop any missing source files; if it is | |
"newer", any missing source files make us assume that 'target' is | |
out-of-date (this is handy in "dry-run" mode: it'll make you pretend to | |
carry out commands that wouldn't work because inputs are missing, but | |
that doesn't matter because you're not actually going to run the | |
commands). | |
""" | |
# If the target doesn't even exist, then it's definitely out-of-date. | |
if not os.path.exists(target): | |
return True | |
# Otherwise we have to find out the hard way: if *any* source file | |
# is more recent than 'target', then 'target' is out-of-date and | |
# we can immediately return true. If we fall through to the end | |
# of the loop, then 'target' is up-to-date and we return false. | |
target_mtime = os.stat(target).st_mtime | |
for source in sources: | |
if not os.path.exists(source): | |
if missing == 'error': # blow up when we stat() the file | |
pass | |
elif missing == 'ignore': # missing source dropped from | |
continue # target's dependency list | |
elif missing == 'newer': # missing source means target is | |
return True # out-of-date | |
if os.stat(source).st_mtime > target_mtime: | |
return True | |
return False |