Commits

Anonymous committed 56fda4e

Reformat docstrings.
Standardize whitespace in function calls.

Comments (0)

Files changed (2)

Lib/distutils/archive_util.py

 def make_tarball (base_name, base_dir, compress="gzip",
                   verbose=0, dry_run=0):
     """Create a (possibly compressed) tar file from all the files under
-       'base_dir'.  'compress' must be "gzip" (the default), "compress",
-       "bzip2", or None.  Both "tar" and the compression utility named by
-       'compress' must be on the default program search path, so this is
-       probably Unix-specific.  The output tar file will be named 'base_dir'
-       + ".tar", possibly plus the appropriate compression extension (".gz",
-       ".bz2" or ".Z").  Return the output filename."""
-
+    'base_dir'.  'compress' must be "gzip" (the default), "compress",
+    "bzip2", or None.  Both "tar" and the compression utility named by
+    'compress' must be on the default program search path, so this is
+    probably Unix-specific.  The output tar file will be named 'base_dir' +
+    ".tar", possibly plus the appropriate compression extension (".gz",
+    ".bz2" or ".Z").  Return the output filename.
+    """
     # XXX GNU tar 1.13 has a nifty option to add a prefix directory.
     # It's pretty new, though, so we certainly can't require it --
     # but it would be nice to take advantage of it to skip the
     archive_name = base_name + ".tar"
     mkpath(os.path.dirname(archive_name), verbose=verbose, dry_run=dry_run)
     cmd = ["tar", "-cf", archive_name, base_dir]
-    spawn (cmd, verbose=verbose, dry_run=dry_run)
+    spawn(cmd, verbose=verbose, dry_run=dry_run)
 
     if compress:
-        spawn ([compress] + compress_flags[compress] + [archive_name],
-               verbose=verbose, dry_run=dry_run)
+        spawn([compress] + compress_flags[compress] + [archive_name],
+              verbose=verbose, dry_run=dry_run)
         return archive_name + compress_ext[compress]
     else:
         return archive_name
 
 
 def make_zipfile (base_name, base_dir, verbose=0, dry_run=0):
-    """Create a zip file from all the files under 'base_dir'.  The
-       output zip file will be named 'base_dir' + ".zip".  Uses either the
-       InfoZIP "zip" utility (if installed and found on the default search
-       path) or the "zipfile" Python module (if available).  If neither
-       tool is available, raises DistutilsExecError.  Returns the name
-       of the output zip file."""
-
+    """Create a zip file from all the files under 'base_dir'.  The output
+    zip file will be named 'base_dir' + ".zip".  Uses either the InfoZIP
+    "zip" utility (if installed and found on the default search path) or
+    the "zipfile" Python module (if available).  If neither tool is
+    available, raises DistutilsExecError.  Returns the name of the output
+    zip file.
+    """
     # This initially assumed the Unix 'zip' utility -- but
     # apparently InfoZIP's zip.exe works the same under Windows, so
     # no changes needed!
     zip_filename = base_name + ".zip"
     mkpath(os.path.dirname(zip_filename), verbose=verbose, dry_run=dry_run)
     try:
-        spawn (["zip", "-rq", zip_filename, base_dir],
-               verbose=verbose, dry_run=dry_run)
+        spawn(["zip", "-rq", zip_filename, base_dir],
+              verbose=verbose, dry_run=dry_run)
     except DistutilsExecError:
 
         # XXX really should distinguish between "couldn't find
         def visit (z, dirname, names):
             for name in names:
                 path = os.path.normpath(os.path.join(dirname, name))
-                if os.path.isfile (path):
-                    z.write (path, path)
+                if os.path.isfile(path):
+                    z.write(path, path)
 
         if not dry_run:
-            z = zipfile.ZipFile (zip_filename, "wb",
-                                 compression=zipfile.ZIP_DEFLATED)
+            z = zipfile.ZipFile(zip_filename, "wb",
+                                compression=zipfile.ZIP_DEFLATED)
 
-            os.path.walk (base_dir, visit, z)
+            os.path.walk(base_dir, visit, z)
             z.close()
 
     return zip_filename
     if root_dir is not None:
         if verbose:
             print "changing into '%s'" % root_dir
-        base_name = os.path.abspath (base_name)
+        base_name = os.path.abspath(base_name)
         if not dry_run:
-            os.chdir (root_dir)
+            os.chdir(root_dir)
 
     if base_dir is None:
         base_dir = os.curdir
     func = format_info[0]
     for (arg,val) in format_info[1]:
         kwargs[arg] = val
-    filename = apply (func, (base_name, base_dir), kwargs)
+    filename = apply(func, (base_name, base_dir), kwargs)
 
     if root_dir is not None:
         if verbose:
             print "changing back to '%s'" % save_cwd
-        os.chdir (save_cwd)
+        os.chdir(save_cwd)
 
     return filename
 

Lib/distutils/dep_util.py

 
 def newer (source, target):
     """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."""
-
-    if not os.path.exists (source):
+    '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.
+    """
+    if not os.path.exists(source):
         raise DistutilsFileError, "file '%s' does not exist" % source
-    if not os.path.exists (target):
+    if not os.path.exists(target):
         return 1
 
     from stat import 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):
+    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 i in range (len (sources)):
-        if newer (sources[i], targets[i]):
-            n_sources.append (sources[i])
-            n_targets.append (targets[i])
+    for i in range(len(sources)):
+        if newer(sources[i], targets[i]):
+            n_sources.append(sources[i])
+            n_targets.append(targets[i])
 
     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)."""
-
+    """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):
+    if not os.path.exists(target):
         return 1
    
     # Otherwise we have to find out the hard way: if *any* source file
     # 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.
     from stat import ST_MTIME
-    target_mtime = os.stat (target)[ST_MTIME]
+    target_mtime = os.stat(target)[ST_MTIME]
     for source in sources:
-        if not os.path.exists (source):
+        if not os.path.exists(source):
             if missing == 'error':      # blow up when we stat() the file
                 pass                    
             elif missing == 'ignore':   # missing source dropped from 
 def make_file (src, dst, func, args,
                verbose=0, update_message=None, noupdate_message=None):
     """Makes 'dst' from 'src' (both filenames) by calling 'func' with
-       'args', but only if it needs to: i.e. if 'dst' does not exist or
-       'src' is newer than 'dst'."""
-
-    if newer (src, dst):
+    'args', but only if it needs to: i.e. if 'dst' does not exist or 'src'
+    is newer than 'dst'.
+    """
+    if newer(src, dst):
         if verbose and update_message:
             print update_message
-        apply (func, args)
+        apply(func, args)
     else:
         if verbose and noupdate_message:
             print noupdate_message