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

Utility functions for operating on single files.
&quot;&quot;&quot;

import os
from distutils.errors import DistutilsFileError
from distutils import log

# for generating verbose output in &#039;copy_file()&#039;
_copy_action = { None:   &#039;copying&#039;,
                 &#039;hard&#039;: &#039;hard linking&#039;,
                 &#039;sym&#039;:  &#039;symbolically linking&#039; }


def _copy_file_contents(src, dst, buffer_size=16*1024):
    &quot;&quot;&quot;Copy the file &#039;src&#039; to &#039;dst&#039;; both must be filenames.  Any error
    opening either file, reading from &#039;src&#039;, or writing to &#039;dst&#039;, raises
    DistutilsFileError.  Data is read/written in chunks of &#039;buffer_size&#039;
    bytes (default 16k).  No attempt is made to handle anything apart from
    regular files.
    &quot;&quot;&quot;
    # Stolen from shutil module in the standard library, but with
    # custom error-handling added.
    fsrc = None
    fdst = None
    try:
        try:
            fsrc = open(src, &#039;rb&#039;)
        except OSError as e:
            raise DistutilsFileError(&quot;could not open &#039;%s&#039;: %s&quot; % (src, e.strerror))

        if os.path.exists(dst):
            try:
                os.unlink(dst)
            except OSError as e:
                raise DistutilsFileError(
                      &quot;could not delete &#039;%s&#039;: %s&quot; % (dst, e.strerror))

        try:
            fdst = open(dst, &#039;wb&#039;)
        except OSError as e:
            raise DistutilsFileError(
                  &quot;could not create &#039;%s&#039;: %s&quot; % (dst, e.strerror))

        while True:
            try:
                buf = fsrc.read(buffer_size)
            except OSError as e:
                raise DistutilsFileError(
                      &quot;could not read from &#039;%s&#039;: %s&quot; % (src, e.strerror))

            if not buf:
                break

            try:
                fdst.write(buf)
            except OSError as e:
                raise DistutilsFileError(
                      &quot;could not write to &#039;%s&#039;: %s&quot; % (dst, e.strerror))
    finally:
        if fdst:
            fdst.close()
        if fsrc:
            fsrc.close()

def copy_file(src, dst, preserve_mode=1, preserve_times=1, update=0,
              link=None, verbose=1, dry_run=0):
    &quot;&quot;&quot;Copy a file &#039;src&#039; to &#039;dst&#039;.  If &#039;dst&#039; is a directory, then &#039;src&#039; is
    copied there with the same name; otherwise, it must be a filename.  (If
    the file exists, it will be ruthlessly clobbered.)  If &#039;preserve_mode&#039;
    is true (the default), the file&#039;s mode (type and permission bits, or
    whatever is analogous on the current platform) is copied.  If
    &#039;preserve_times&#039; is true (the default), the last-modified and
    last-access times are copied as well.  If &#039;update&#039; is true, &#039;src&#039; will
    only be copied if &#039;dst&#039; does not exist, or if &#039;dst&#039; does exist but is
    older than &#039;src&#039;.

    &#039;link&#039; allows you to make hard links (os.link) or symbolic links
    (os.symlink) instead of copying: set it to &quot;hard&quot; or &quot;sym&quot;; if it is
    None (the default), files are copied.  Don&#039;t set &#039;link&#039; on systems that
    don&#039;t support it: &#039;copy_file()&#039; doesn&#039;t check if hard or symbolic
    linking is available. If hardlink fails, falls back to
    _copy_file_contents().

    Under Mac OS, uses the native file copy function in macostools; on
    other systems, uses &#039;_copy_file_contents()&#039; to copy file contents.

    Return a tuple (dest_name, copied): &#039;dest_name&#039; is the actual name of
    the output file, and &#039;copied&#039; is true if the file was copied (or would
    have been copied, if &#039;dry_run&#039; true).
    &quot;&quot;&quot;
    # XXX if the destination file already exists, we clobber it if
    # copying, but blow up if linking.  Hmmm.  And I don&#039;t know what
    # macostools.copyfile() does.  Should definitely be consistent, and
    # should probably blow up if destination exists and we would be
    # changing it (ie. it&#039;s not already a hard/soft link to src OR
    # (not update) and (src newer than dst).

    from distutils.dep_util import newer
    from stat import ST_ATIME, ST_MTIME, ST_MODE, S_IMODE

    if not os.path.isfile(src):
        raise DistutilsFileError(
              &quot;can&#039;t copy &#039;%s&#039;: doesn&#039;t exist or not a regular file&quot; % src)

    if os.path.isdir(dst):
        dir = dst
        dst = os.path.join(dst, os.path.basename(src))
    else:
        dir = os.path.dirname(dst)

    if update and not newer(src, dst):
        if verbose &gt;= 1:
            log.debug(&quot;not copying %s (output up-to-date)&quot;, src)
        return (dst, 0)

    try:
        action = _copy_action[link]
    except KeyError:
        raise ValueError(&quot;invalid value &#039;%s&#039; for &#039;link&#039; argument&quot; % link)

    if verbose &gt;= 1:
        if os.path.basename(dst) == os.path.basename(src):
            log.info(&quot;%s %s -&gt; %s&quot;, action, src, dir)
        else:
            log.info(&quot;%s %s -&gt; %s&quot;, action, src, dst)

    if dry_run:
        return (dst, 1)

    # If linking (hard or symbolic), use the appropriate system call
    # (Unix only, of course, but that&#039;s the caller&#039;s responsibility)
    elif link == &#039;hard&#039;:
        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
            try:
                os.link(src, dst)
                return (dst, 1)
            except OSError:
                # If hard linking fails, fall back on copying file
                # (some special filesystems don&#039;t support hard linking
                #  even under Unix, see issue #8876).
                pass
    elif link == &#039;sym&#039;:
        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
            os.symlink(src, dst)
            return (dst, 1)

    # Otherwise (non-Mac, not linking), copy the file contents and
    # (optionally) copy the times and mode.
    _copy_file_contents(src, dst)
    if preserve_mode or preserve_times:
        st = os.stat(src)

        # According to David Ascher &lt;da@ski.org&gt;, utime() should be done
        # before chmod() (at least under NT).
        if preserve_times:
            os.utime(dst, (st[ST_ATIME], st[ST_MTIME]))
        if preserve_mode:
            os.chmod(dst, S_IMODE(st[ST_MODE]))

    return (dst, 1)


# XXX I suspect this is Unix-specific -- need porting help!
def move_file (src, dst,
               verbose=1,
               dry_run=0):

    &quot;&quot;&quot;Move a file &#039;src&#039; to &#039;dst&#039;.  If &#039;dst&#039; is a directory, the file will
    be moved into it with the same name; otherwise, &#039;src&#039; is just renamed
    to &#039;dst&#039;.  Return the new full name of the file.

    Handles cross-device moves on Unix using &#039;copy_file()&#039;.  What about
    other systems???
    &quot;&quot;&quot;
    from os.path import exists, isfile, isdir, basename, dirname
    import errno

    if verbose &gt;= 1:
        log.info(&quot;moving %s -&gt; %s&quot;, src, dst)

    if dry_run:
        return dst

    if not isfile(src):
        raise DistutilsFileError(&quot;can&#039;t move &#039;%s&#039;: not a regular file&quot; % src)

    if isdir(dst):
        dst = os.path.join(dst, basename(src))
    elif exists(dst):
        raise DistutilsFileError(
              &quot;can&#039;t move &#039;%s&#039;: destination &#039;%s&#039; already exists&quot; %
              (src, dst))

    if not isdir(dirname(dst)):
        raise DistutilsFileError(
              &quot;can&#039;t move &#039;%s&#039;: destination &#039;%s&#039; not a valid path&quot; %
              (src, dst))

    copy_it = False
    try:
        os.rename(src, dst)
    except OSError as e:
        (num, msg) = e.args
        if num == errno.EXDEV:
            copy_it = True
        else:
            raise DistutilsFileError(
                  &quot;couldn&#039;t move &#039;%s&#039; to &#039;%s&#039;: %s&quot; % (src, dst, msg))

    if copy_it:
        copy_file(src, dst, verbose=verbose)
        try:
            os.unlink(src)
        except OSError as e:
            (num, msg) = e.args
            try:
                os.unlink(dst)
            except OSError:
                pass
            raise DistutilsFileError(
                  &quot;couldn&#039;t move &#039;%s&#039; to &#039;%s&#039; by copy/delete: &quot;
                  &quot;delete &#039;%s&#039; failed: %s&quot;
                  % (src, dst, src, msg))
    return dst


def write_file (filename, contents):
    &quot;&quot;&quot;Create a file with the specified name and write &#039;contents&#039; (a
    sequence of strings without line terminators) to it.
    &quot;&quot;&quot;
    f = open(filename, &quot;w&quot;)
    try:
        for line in contents:
            f.write(line + &quot;\n&quot;)
    finally:
        f.close()
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>