<h2>Edit File - dir_util.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/lib64/python2.7/distutils/dir_util.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot;&quot;&quot;distutils.dir_util

Utility functions for manipulating directories and directory trees.&quot;&quot;&quot;

__revision__ = &quot;$Id$&quot;

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 &quot;creating /foo/bar/baz&quot; messages in dry-run mode
_path_created = {}

# I don&#039;t use os.makedirs because a) it&#039;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=0777, verbose=1, dry_run=0):
    &quot;&quot;&quot;Create a directory and any missing ancestor directories.

    If the directory already exists (or if &#039;name&#039; 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 &#039;verbose&#039; is true, print a one-line summary of each mkdir to stdout.
    Return the list of directories actually created.
    &quot;&quot;&quot;

    global _path_created

    # Detect a common bug -- name is None
    if not isinstance(name, basestring):
        raise DistutilsInternalError, \
              &quot;mkpath: &#039;name&#039; must be a string (got %r)&quot; % (name,)

    # XXX what&#039;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&#039;re not using a recursive algorithm)

    name = os.path.normpath(name)
    created_dirs = []
    if os.path.isdir(name) or name == &#039;&#039;:
        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 &#039;head&#039; contains the deepest directory that already exists
    # (that is, the child of &#039;head&#039; in &#039;name&#039; is the highest directory
    # that does *not* exist)
    for d in tails:
        #print &quot;head = %s, d = %s: &quot; % (head, d),
        head = os.path.join(head, d)
        abs_head = os.path.abspath(head)

        if _path_created.get(abs_head):
            continue

        if verbose &gt;= 1:
            log.info(&quot;creating %s&quot;, head)

        if not dry_run:
            try:
                os.mkdir(head, mode)
            except OSError, exc:
                if not (exc.errno == errno.EEXIST and os.path.isdir(head)):
                    raise DistutilsFileError(
                          &quot;could not create &#039;%s&#039;: %s&quot; % (head, exc.args[-1]))
            created_dirs.append(head)

        _path_created[abs_head] = 1
    return created_dirs

def create_tree(base_dir, files, mode=0777, verbose=1, dry_run=0):
    &quot;&quot;&quot;Create all the empty directories under &#039;base_dir&#039; needed to put &#039;files&#039;
    there.

    &#039;base_dir&#039; is just the name of a directory which doesn&#039;t necessarily
    exist yet; &#039;files&#039; is a list of filenames to be interpreted relative to
    &#039;base_dir&#039;.  &#039;base_dir&#039; + the directory portion of every file in &#039;files&#039;
    will be created if it doesn&#039;t already exist.  &#039;mode&#039;, &#039;verbose&#039; and
    &#039;dry_run&#039; flags are as for &#039;mkpath()&#039;.
    &quot;&quot;&quot;
    # First get the list of directories to create
    need_dir = {}
    for file in files:
        need_dir[os.path.join(base_dir, os.path.dirname(file))] = 1
    need_dirs = need_dir.keys()
    need_dirs.sort()

    # Now create them
    for dir in need_dirs:
        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):
    &quot;&quot;&quot;Copy an entire directory tree &#039;src&#039; to a new location &#039;dst&#039;.

    Both &#039;src&#039; and &#039;dst&#039; must be directory names.  If &#039;src&#039; is not a
    directory, raise DistutilsFileError.  If &#039;dst&#039; does not exist, it is
    created with &#039;mkpath()&#039;.  The end result of the copy is that every
    file in &#039;src&#039; is copied to &#039;dst&#039;, and directories under &#039;src&#039; are
    recursively copied to &#039;dst&#039;.  Return the list of files that were
    copied or might have been copied, using their output name.  The
    return value is unaffected by &#039;update&#039; or &#039;dry_run&#039;: it is simply
    the list of all files under &#039;src&#039;, with the names changed to be
    under &#039;dst&#039;.

    &#039;preserve_mode&#039; and &#039;preserve_times&#039; are the same as for
    &#039;copy_file&#039;; note that they only apply to regular files, not to
    directories.  If &#039;preserve_symlinks&#039; is true, symlinks will be
    copied as symlinks (on platforms that support them!); otherwise
    (the default), the destination of the symlink will be copied.
    &#039;update&#039; and &#039;verbose&#039; are the same as for &#039;copy_file&#039;.
    &quot;&quot;&quot;
    from distutils.file_util import copy_file

    if not dry_run and not os.path.isdir(src):
        raise DistutilsFileError, \
              &quot;cannot copy tree &#039;%s&#039;: not a directory&quot; % src
    try:
        names = os.listdir(src)
    except os.error, (errno, errstr):
        if dry_run:
            names = []
        else:
            raise DistutilsFileError, \
                  &quot;error listing files in &#039;%s&#039;: %s&quot; % (src, errstr)

    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(&#039;.nfs&#039;):
            # skip NFS rename files
            continue

        if preserve_symlinks and os.path.islink(src_name):
            link_dest = os.readlink(src_name)
            if verbose &gt;= 1:
                log.info(&quot;linking %s -&gt; %s&quot;, 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):
    &quot;&quot;&quot;Helper for remove_tree().&quot;&quot;&quot;
    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):
    &quot;&quot;&quot;Recursively remove an entire directory tree.

    Any errors are ignored (apart from being reported to stdout if &#039;verbose&#039;
    is true).
    &quot;&quot;&quot;
    global _path_created

    if verbose &gt;= 1:
        log.info(&quot;removing &#039;%s&#039; (and everything under it)&quot;, 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&#039;s already there
            abspath = os.path.abspath(cmd[1])
            if abspath in _path_created:
                del _path_created[abspath]
        except (IOError, OSError), exc:
            log.warn(&quot;error removing %s: %s&quot;, directory, exc)

def ensure_relative(path):
    &quot;&quot;&quot;Take the full path &#039;path&#039;, and make it a relative path.

    This is useful to make &#039;path&#039; the second argument to os.path.join().
    &quot;&quot;&quot;
    drive, path = os.path.splitdrive(path)
    if path[0:1] == os.sep:
        path = drive + path[1:]
    return path
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>