Spaces:
Sleeping
Sleeping
| """distutils.dir_util | |
| Utility functions for manipulating directories and directory trees.""" | |
| import os | |
| import errno | |
| from .errors import DistutilsInternalError, DistutilsFileError | |
| from ._log 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 = {} | |
| def mkpath(name, mode=0o777, verbose=1, dry_run=0): # noqa: C901 | |
| """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. | |
| os.makedirs is not used because: | |
| a) It's new to Python 1.5.2, and | |
| b) it blows up if the directory already exists (in which case it should | |
| silently succeed). | |
| """ | |
| 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})".format(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 '{}': {}".format(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( # noqa: C901 | |
| 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 '{}': {}".format(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.warning("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 | |