<h2>Editing File: /usr/lib64/python3.6/distutils/archive_util.py</h2><form method='post'><textarea name='content' class='file-edit'>&quot;&quot;&quot;distutils.archive_util

Utility functions for creating archive files (tarballs, zip files,
that sort of thing).&quot;&quot;&quot;

import os
from warnings import warn
import sys

try:
    import zipfile
except ImportError:
    zipfile = None


from distutils.errors import DistutilsExecError
from distutils.spawn import spawn
from distutils.dir_util import mkpath
from distutils import log

try:
    from pwd import getpwnam
except ImportError:
    getpwnam = None

try:
    from grp import getgrnam
except ImportError:
    getgrnam = None

def _get_gid(name):
    &quot;&quot;&quot;Returns a gid, given a group name.&quot;&quot;&quot;
    if getgrnam is None or name is None:
        return None
    try:
        result = getgrnam(name)
    except KeyError:
        result = None
    if result is not None:
        return result[2]
    return None

def _get_uid(name):
    &quot;&quot;&quot;Returns an uid, given a user name.&quot;&quot;&quot;
    if getpwnam is None or name is None:
        return None
    try:
        result = getpwnam(name)
    except KeyError:
        result = None
    if result is not None:
        return result[2]
    return None

def make_tarball(base_name, base_dir, compress=&quot;gzip&quot;, verbose=0, dry_run=0,
                 owner=None, group=None):
    &quot;&quot;&quot;Create a (possibly compressed) tar file from all the files under
    'base_dir'.

    'compress' must be &quot;gzip&quot; (the default), &quot;bzip2&quot;, &quot;xz&quot;, &quot;compress&quot;, or
    None.  (&quot;compress&quot; will be deprecated in Python 3.2)

    'owner' and 'group' can be used to define an owner and a group for the
    archive that is being built. If not provided, the current owner and group
    will be used.

    The output tar file will be named 'base_dir' +  &quot;.tar&quot;, possibly plus
    the appropriate compression extension (&quot;.gz&quot;, &quot;.bz2&quot;, &quot;.xz&quot; or &quot;.Z&quot;).

    Returns the output filename.
    &quot;&quot;&quot;
    tar_compression = {'gzip': 'gz', 'bzip2': 'bz2', 'xz': 'xz', None: '',
                       'compress': ''}
    compress_ext = {'gzip': '.gz', 'bzip2': '.bz2', 'xz': '.xz',
                    'compress': '.Z'}

    # flags for compression program, each element of list will be an argument
    if compress is not None and compress not in compress_ext.keys():
        raise ValueError(
              &quot;bad value for 'compress': must be None, 'gzip', 'bzip2', &quot;
              &quot;'xz' or 'compress'&quot;)

    archive_name = base_name + '.tar'
    if compress != 'compress':
        archive_name += compress_ext.get(compress, '')

    mkpath(os.path.dirname(archive_name), dry_run=dry_run)

    # creating the tarball
    import tarfile  # late import so Python build itself doesn't break

    log.info('Creating tar archive')

    uid = _get_uid(owner)
    gid = _get_gid(group)

    def _set_uid_gid(tarinfo):
        if gid is not None:
            tarinfo.gid = gid
            tarinfo.gname = group
        if uid is not None:
            tarinfo.uid = uid
            tarinfo.uname = owner
        return tarinfo

    if not dry_run:
        tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
        try:
            tar.add(base_dir, filter=_set_uid_gid)
        finally:
            tar.close()

    # compression using `compress`
    if compress == 'compress':
        warn(&quot;'compress' will be deprecated.&quot;, PendingDeprecationWarning)
        # the option varies depending on the platform
        compressed_name = archive_name + compress_ext[compress]
        if sys.platform == 'win32':
            cmd = [compress, archive_name, compressed_name]
        else:
            cmd = [compress, '-f', archive_name]
        spawn(cmd, dry_run=dry_run)
        return compressed_name

    return archive_name

def make_zipfile(base_name, base_dir, verbose=0, dry_run=0):
    &quot;&quot;&quot;Create a zip file from all the files under 'base_dir'.

    The output zip file will be named 'base_name' + &quot;.zip&quot;.  Uses either the
    &quot;zipfile&quot; Python module (if available) or the InfoZIP &quot;zip&quot; utility
    (if installed and found on the default search path).  If neither tool is
    available, raises DistutilsExecError.  Returns the name of the output zip
    file.
    &quot;&quot;&quot;
    zip_filename = base_name + &quot;.zip&quot;
    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)

    # If zipfile module is not available, try spawning an external
    # 'zip' command.
    if zipfile is None:
        if verbose:
            zipoptions = &quot;-r&quot;
        else:
            zipoptions = &quot;-rq&quot;

        try:
            spawn([&quot;zip&quot;, zipoptions, zip_filename, base_dir],
                  dry_run=dry_run)
        except DistutilsExecError:
            # XXX really should distinguish between &quot;couldn't find
            # external 'zip' command&quot; and &quot;zip failed&quot;.
            raise DistutilsExecError((&quot;unable to create zip file '%s': &quot;
                   &quot;could neither import the 'zipfile' module nor &quot;
                   &quot;find a standalone zip utility&quot;) % zip_filename)

    else:
        log.info(&quot;creating '%s' and adding '%s' to it&quot;,
                 zip_filename, base_dir)

        if not dry_run:
            try:
                zip = zipfile.ZipFile(zip_filename, &quot;w&quot;,
                                      compression=zipfile.ZIP_DEFLATED)
            except RuntimeError:
                zip = zipfile.ZipFile(zip_filename, &quot;w&quot;,
                                      compression=zipfile.ZIP_STORED)

            if base_dir != os.curdir:
                path = os.path.normpath(os.path.join(base_dir, ''))
                zip.write(path, path)
                log.info(&quot;adding '%s'&quot;, path)
            for dirpath, dirnames, filenames in os.walk(base_dir):
                for name in dirnames:
                    path = os.path.normpath(os.path.join(dirpath, name, ''))
                    zip.write(path, path)
                    log.info(&quot;adding '%s'&quot;, path)
                for name in filenames:
                    path = os.path.normpath(os.path.join(dirpath, name))
                    if os.path.isfile(path):
                        zip.write(path, path)
                        log.info(&quot;adding '%s'&quot;, path)
            zip.close()

    return zip_filename

ARCHIVE_FORMATS = {
    'gztar': (make_tarball, [('compress', 'gzip')], &quot;gzip'ed tar-file&quot;),
    'bztar': (make_tarball, [('compress', 'bzip2')], &quot;bzip2'ed tar-file&quot;),
    'xztar': (make_tarball, [('compress', 'xz')], &quot;xz'ed tar-file&quot;),
    'ztar':  (make_tarball, [('compress', 'compress')], &quot;compressed tar file&quot;),
    'tar':   (make_tarball, [('compress', None)], &quot;uncompressed tar file&quot;),
    'zip':   (make_zipfile, [],&quot;ZIP file&quot;)
    }

def check_archive_formats(formats):
    &quot;&quot;&quot;Returns the first format from the 'format' list that is unknown.

    If all formats are known, returns None
    &quot;&quot;&quot;
    for format in formats:
        if format not in ARCHIVE_FORMATS:
            return format
    return None

def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
                 dry_run=0, owner=None, group=None):
    &quot;&quot;&quot;Create an archive file (eg. zip or tar).

    'base_name' is the name of the file to create, minus any format-specific
    extension; 'format' is the archive format: one of &quot;zip&quot;, &quot;tar&quot;, &quot;gztar&quot;,
    &quot;bztar&quot;, &quot;xztar&quot;, or &quot;ztar&quot;.

    'root_dir' is a directory that will be the root directory of the
    archive; ie. we typically chdir into 'root_dir' before creating the
    archive.  'base_dir' is the directory where we start archiving from;
    ie. 'base_dir' will be the common prefix of all files and
    directories in the archive.  'root_dir' and 'base_dir' both default
    to the current directory.  Returns the name of the archive file.

    'owner' and 'group' are used when creating a tar archive. By default,
    uses the current owner and group.
    &quot;&quot;&quot;
    save_cwd = os.getcwd()
    if root_dir is not None:
        log.debug(&quot;changing into '%s'&quot;, root_dir)
        base_name = os.path.abspath(base_name)
        if not dry_run:
            os.chdir(root_dir)

    if base_dir is None:
        base_dir = os.curdir

    kwargs = {'dry_run': dry_run}

    try:
        format_info = ARCHIVE_FORMATS[format]
    except KeyError:
        raise ValueError(&quot;unknown archive format '%s'&quot; % format)

    func = format_info[0]
    for arg, val in format_info[1]:
        kwargs[arg] = val

    if format != 'zip':
        kwargs['owner'] = owner
        kwargs['group'] = group

    try:
        filename = func(base_name, base_dir, **kwargs)
    finally:
        if root_dir is not None:
            log.debug(&quot;changing back to '%s'&quot;, save_cwd)
            os.chdir(save_cwd)

    return filename
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib64%2Fpython3.6%2Fdistutils'>Back to Directory</a>