Restoring authorship annotation for <[email protected]>. Commit 1 of 2.

1 files changed, 210 insertions, 210 deletions

diff --git a/contrib/tools/python3/src/Lib/distutils/dir_util.py b/contrib/tools/python3/src/Lib/distutils/dir_util.py
index d5cd8e3e24f..44ddd6e6087 100644
--- a/contrib/tools/python3/src/Lib/distutils/dir_util.py
+++ b/contrib/tools/python3/src/Lib/distutils/dir_util.py
@@ -1,210 +1,210 @@
-"""distutils.dir_util
-
-Utility functions for manipulating directories and directory trees."""
-
-import os
-import errno
-from distutils.errors import DistutilsFileError, DistutilsInternalError
-from distutils import log
-
-# cache for by mkpath() -- in addition to cheapening redundant calls,
-# eliminates redundant "creating /foo/bar/baz" messages in dry-run mode
-_path_created = {}
-
-# I don't use os.makedirs because a) it's new to Python 1.5.2, and
-# b) it blows up if the directory already exists (I want to silently
-# succeed in that case).
-def mkpath(name, mode=0o777, verbose=1, dry_run=0):
-    """Create a directory and any missing ancestor directories.
-
-    If the directory already exists (or if 'name' is the empty string, which
-    means the current directory, which of course exists), then do nothing.
-    Raise DistutilsFileError if unable to create some directory along the way
-    (eg. some sub-path exists, but is a file rather than a directory).
-    If 'verbose' is true, print a one-line summary of each mkdir to stdout.
-    Return the list of directories actually created.
-    """
-
-    global _path_created
-
-    # Detect a common bug -- name is None
-    if not isinstance(name, str):
-        raise DistutilsInternalError(
-              "mkpath: 'name' must be a string (got %r)" % (name,))
-
-    # XXX what's the better way to handle verbosity? print as we create
-    # each directory in the path (the current behaviour), or only announce
-    # the creation of the whole path? (quite easy to do the latter since
-    # we're not using a recursive algorithm)
-
-    name = os.path.normpath(name)
-    created_dirs = []
-    if os.path.isdir(name) or name == '':
-        return created_dirs
-    if _path_created.get(os.path.abspath(name)):
-        return created_dirs
-
-    (head, tail) = os.path.split(name)
-    tails = [tail]                      # stack of lone dirs to create
-
-    while head and tail and not os.path.isdir(head):
-        (head, tail) = os.path.split(head)
-        tails.insert(0, tail)          # push next higher dir onto stack
-
-    # now 'head' contains the deepest directory that already exists
-    # (that is, the child of 'head' in 'name' is the highest directory
-    # that does *not* exist)
-    for d in tails:
-        #print "head = %s, d = %s: " % (head, d),
-        head = os.path.join(head, d)
-        abs_head = os.path.abspath(head)
-
-        if _path_created.get(abs_head):
-            continue
-
-        if verbose >= 1:
-            log.info("creating %s", head)
-
-        if not dry_run:
-            try:
-                os.mkdir(head, mode)
-            except OSError as exc:
-                if not (exc.errno == errno.EEXIST and os.path.isdir(head)):
-                    raise DistutilsFileError(
-                          "could not create '%s': %s" % (head, exc.args[-1]))
-            created_dirs.append(head)
-
-        _path_created[abs_head] = 1
-    return created_dirs
-
-def create_tree(base_dir, files, mode=0o777, verbose=1, dry_run=0):
-    """Create all the empty directories under 'base_dir' needed to put 'files'
-    there.
-
-    'base_dir' is just the name of a directory which doesn't necessarily
-    exist yet; 'files' is a list of filenames to be interpreted relative to
-    'base_dir'.  'base_dir' + the directory portion of every file in 'files'
-    will be created if it doesn't already exist.  'mode', 'verbose' and
-    'dry_run' flags are as for 'mkpath()'.
-    """
-    # First get the list of directories to create
-    need_dir = set()
-    for file in files:
-        need_dir.add(os.path.join(base_dir, os.path.dirname(file)))
-
-    # Now create them
-    for dir in sorted(need_dir):
-        mkpath(dir, mode, verbose=verbose, dry_run=dry_run)
-
-def copy_tree(src, dst, preserve_mode=1, preserve_times=1,
-              preserve_symlinks=0, update=0, verbose=1, dry_run=0):
-    """Copy an entire directory tree 'src' to a new location 'dst'.
-
-    Both 'src' and 'dst' must be directory names.  If 'src' is not a
-    directory, raise DistutilsFileError.  If 'dst' does not exist, it is
-    created with 'mkpath()'.  The end result of the copy is that every
-    file in 'src' is copied to 'dst', and directories under 'src' are
-    recursively copied to 'dst'.  Return the list of files that were
-    copied or might have been copied, using their output name.  The
-    return value is unaffected by 'update' or 'dry_run': it is simply
-    the list of all files under 'src', with the names changed to be
-    under 'dst'.
-
-    'preserve_mode' and 'preserve_times' are the same as for
-    'copy_file'; note that they only apply to regular files, not to
-    directories.  If 'preserve_symlinks' is true, symlinks will be
-    copied as symlinks (on platforms that support them!); otherwise
-    (the default), the destination of the symlink will be copied.
-    'update' and 'verbose' are the same as for 'copy_file'.
-    """
-    from distutils.file_util import copy_file
-
-    if not dry_run and not os.path.isdir(src):
-        raise DistutilsFileError(
-              "cannot copy tree '%s': not a directory" % src)
-    try:
-        names = os.listdir(src)
-    except OSError as e:
-        if dry_run:
-            names = []
-        else:
-            raise DistutilsFileError(
-                  "error listing files in '%s': %s" % (src, e.strerror))
-
-    if not dry_run:
-        mkpath(dst, verbose=verbose)
-
-    outputs = []
-
-    for n in names:
-        src_name = os.path.join(src, n)
-        dst_name = os.path.join(dst, n)
-
-        if n.startswith('.nfs'):
-            # skip NFS rename files
-            continue
-
-        if preserve_symlinks and os.path.islink(src_name):
-            link_dest = os.readlink(src_name)
-            if verbose >= 1:
-                log.info("linking %s -> %s", dst_name, link_dest)
-            if not dry_run:
-                os.symlink(link_dest, dst_name)
-            outputs.append(dst_name)
-
-        elif os.path.isdir(src_name):
-            outputs.extend(
-                copy_tree(src_name, dst_name, preserve_mode,
-                          preserve_times, preserve_symlinks, update,
-                          verbose=verbose, dry_run=dry_run))
-        else:
-            copy_file(src_name, dst_name, preserve_mode,
-                      preserve_times, update, verbose=verbose,
-                      dry_run=dry_run)
-            outputs.append(dst_name)
-
-    return outputs
-
-def _build_cmdtuple(path, cmdtuples):
-    """Helper for remove_tree()."""
-    for f in os.listdir(path):
-        real_f = os.path.join(path,f)
-        if os.path.isdir(real_f) and not os.path.islink(real_f):
-            _build_cmdtuple(real_f, cmdtuples)
-        else:
-            cmdtuples.append((os.remove, real_f))
-    cmdtuples.append((os.rmdir, path))
-
-def remove_tree(directory, verbose=1, dry_run=0):
-    """Recursively remove an entire directory tree.
-
-    Any errors are ignored (apart from being reported to stdout if 'verbose'
-    is true).
-    """
-    global _path_created
-
-    if verbose >= 1:
-        log.info("removing '%s' (and everything under it)", directory)
-    if dry_run:
-        return
-    cmdtuples = []
-    _build_cmdtuple(directory, cmdtuples)
-    for cmd in cmdtuples:
-        try:
-            cmd[0](cmd[1])
-            # remove dir from cache if it's already there
-            abspath = os.path.abspath(cmd[1])
-            if abspath in _path_created:
-                del _path_created[abspath]
-        except OSError as exc:
-            log.warn("error removing %s: %s", directory, exc)
-
-def ensure_relative(path):
-    """Take the full path 'path', and make it a relative path.
-
-    This is useful to make 'path' the second argument to os.path.join().
-    """
-    drive, path = os.path.splitdrive(path)
-    if path[0:1] == os.sep:
-        path = drive + path[1:]
-    return path
+"""distutils.dir_util 
+ 
+Utility functions for manipulating directories and directory trees.""" 
+ 
+import os 
+import errno 
+from distutils.errors import DistutilsFileError, DistutilsInternalError 
+from distutils import log 
+ 
+# cache for by mkpath() -- in addition to cheapening redundant calls, 
+# eliminates redundant "creating /foo/bar/baz" messages in dry-run mode 
+_path_created = {} 
+ 
+# I don't use os.makedirs because a) it's new to Python 1.5.2, and 
+# b) it blows up if the directory already exists (I want to silently 
+# succeed in that case). 
+def mkpath(name, mode=0o777, verbose=1, dry_run=0): 
+    """Create a directory and any missing ancestor directories. 
+ 
+    If the directory already exists (or if 'name' is the empty string, which 
+    means the current directory, which of course exists), then do nothing. 
+    Raise DistutilsFileError if unable to create some directory along the way 
+    (eg. some sub-path exists, but is a file rather than a directory). 
+    If 'verbose' is true, print a one-line summary of each mkdir to stdout. 
+    Return the list of directories actually created. 
+    """ 
+ 
+    global _path_created 
+ 
+    # Detect a common bug -- name is None 
+    if not isinstance(name, str): 
+        raise DistutilsInternalError( 
+              "mkpath: 'name' must be a string (got %r)" % (name,)) 
+ 
+    # XXX what's the better way to handle verbosity? print as we create 
+    # each directory in the path (the current behaviour), or only announce 
+    # the creation of the whole path? (quite easy to do the latter since 
+    # we're not using a recursive algorithm) 
+ 
+    name = os.path.normpath(name) 
+    created_dirs = [] 
+    if os.path.isdir(name) or name == '': 
+        return created_dirs 
+    if _path_created.get(os.path.abspath(name)): 
+        return created_dirs 
+ 
+    (head, tail) = os.path.split(name) 
+    tails = [tail]                      # stack of lone dirs to create 
+ 
+    while head and tail and not os.path.isdir(head): 
+        (head, tail) = os.path.split(head) 
+        tails.insert(0, tail)          # push next higher dir onto stack 
+ 
+    # now 'head' contains the deepest directory that already exists 
+    # (that is, the child of 'head' in 'name' is the highest directory 
+    # that does *not* exist) 
+    for d in tails: 
+        #print "head = %s, d = %s: " % (head, d), 
+        head = os.path.join(head, d) 
+        abs_head = os.path.abspath(head) 
+ 
+        if _path_created.get(abs_head): 
+            continue 
+ 
+        if verbose >= 1: 
+            log.info("creating %s", head) 
+ 
+        if not dry_run: 
+            try: 
+                os.mkdir(head, mode) 
+            except OSError as exc: 
+                if not (exc.errno == errno.EEXIST and os.path.isdir(head)): 
+                    raise DistutilsFileError( 
+                          "could not create '%s': %s" % (head, exc.args[-1])) 
+            created_dirs.append(head) 
+ 
+        _path_created[abs_head] = 1 
+    return created_dirs 
+ 
+def create_tree(base_dir, files, mode=0o777, verbose=1, dry_run=0): 
+    """Create all the empty directories under 'base_dir' needed to put 'files' 
+    there. 
+ 
+    'base_dir' is just the name of a directory which doesn't necessarily 
+    exist yet; 'files' is a list of filenames to be interpreted relative to 
+    'base_dir'.  'base_dir' + the directory portion of every file in 'files' 
+    will be created if it doesn't already exist.  'mode', 'verbose' and 
+    'dry_run' flags are as for 'mkpath()'. 
+    """ 
+    # First get the list of directories to create 
+    need_dir = set() 
+    for file in files: 
+        need_dir.add(os.path.join(base_dir, os.path.dirname(file))) 
+ 
+    # Now create them 
+    for dir in sorted(need_dir): 
+        mkpath(dir, mode, verbose=verbose, dry_run=dry_run) 
+ 
+def copy_tree(src, dst, preserve_mode=1, preserve_times=1, 
+              preserve_symlinks=0, update=0, verbose=1, dry_run=0): 
+    """Copy an entire directory tree 'src' to a new location 'dst'. 
+ 
+    Both 'src' and 'dst' must be directory names.  If 'src' is not a 
+    directory, raise DistutilsFileError.  If 'dst' does not exist, it is 
+    created with 'mkpath()'.  The end result of the copy is that every 
+    file in 'src' is copied to 'dst', and directories under 'src' are 
+    recursively copied to 'dst'.  Return the list of files that were 
+    copied or might have been copied, using their output name.  The 
+    return value is unaffected by 'update' or 'dry_run': it is simply 
+    the list of all files under 'src', with the names changed to be 
+    under 'dst'. 
+ 
+    'preserve_mode' and 'preserve_times' are the same as for 
+    'copy_file'; note that they only apply to regular files, not to 
+    directories.  If 'preserve_symlinks' is true, symlinks will be 
+    copied as symlinks (on platforms that support them!); otherwise 
+    (the default), the destination of the symlink will be copied. 
+    'update' and 'verbose' are the same as for 'copy_file'. 
+    """ 
+    from distutils.file_util import copy_file 
+ 
+    if not dry_run and not os.path.isdir(src): 
+        raise DistutilsFileError( 
+              "cannot copy tree '%s': not a directory" % src) 
+    try: 
+        names = os.listdir(src) 
+    except OSError as e: 
+        if dry_run: 
+            names = [] 
+        else: 
+            raise DistutilsFileError( 
+                  "error listing files in '%s': %s" % (src, e.strerror)) 
+ 
+    if not dry_run: 
+        mkpath(dst, verbose=verbose) 
+ 
+    outputs = [] 
+ 
+    for n in names: 
+        src_name = os.path.join(src, n) 
+        dst_name = os.path.join(dst, n) 
+ 
+        if n.startswith('.nfs'): 
+            # skip NFS rename files 
+            continue 
+ 
+        if preserve_symlinks and os.path.islink(src_name): 
+            link_dest = os.readlink(src_name) 
+            if verbose >= 1: 
+                log.info("linking %s -> %s", dst_name, link_dest) 
+            if not dry_run: 
+                os.symlink(link_dest, dst_name) 
+            outputs.append(dst_name) 
+ 
+        elif os.path.isdir(src_name): 
+            outputs.extend( 
+                copy_tree(src_name, dst_name, preserve_mode, 
+                          preserve_times, preserve_symlinks, update, 
+                          verbose=verbose, dry_run=dry_run)) 
+        else: 
+            copy_file(src_name, dst_name, preserve_mode, 
+                      preserve_times, update, verbose=verbose, 
+                      dry_run=dry_run) 
+            outputs.append(dst_name) 
+ 
+    return outputs 
+ 
+def _build_cmdtuple(path, cmdtuples): 
+    """Helper for remove_tree().""" 
+    for f in os.listdir(path): 
+        real_f = os.path.join(path,f) 
+        if os.path.isdir(real_f) and not os.path.islink(real_f): 
+            _build_cmdtuple(real_f, cmdtuples) 
+        else: 
+            cmdtuples.append((os.remove, real_f)) 
+    cmdtuples.append((os.rmdir, path)) 
+ 
+def remove_tree(directory, verbose=1, dry_run=0): 
+    """Recursively remove an entire directory tree. 
+ 
+    Any errors are ignored (apart from being reported to stdout if 'verbose' 
+    is true). 
+    """ 
+    global _path_created 
+ 
+    if verbose >= 1: 
+        log.info("removing '%s' (and everything under it)", directory) 
+    if dry_run: 
+        return 
+    cmdtuples = [] 
+    _build_cmdtuple(directory, cmdtuples) 
+    for cmd in cmdtuples: 
+        try: 
+            cmd[0](cmd[1]) 
+            # remove dir from cache if it's already there 
+            abspath = os.path.abspath(cmd[1]) 
+            if abspath in _path_created: 
+                del _path_created[abspath] 
+        except OSError as exc: 
+            log.warn("error removing %s: %s", directory, exc) 
+ 
+def ensure_relative(path): 
+    """Take the full path 'path', and make it a relative path. 
+ 
+    This is useful to make 'path' the second argument to os.path.join(). 
+    """ 
+    drive, path = os.path.splitdrive(path) 
+    if path[0:1] == os.sep: 
+        path = drive + path[1:] 
+    return path