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

Implements the Distutils &#039;sdist&#039; command (create a source distribution).&quot;&quot;&quot;

import os
import sys
from types import *
from glob import glob
from warnings import warn

from distutils.core import Command
from distutils import dir_util, dep_util, file_util, archive_util
from distutils.text_file import TextFile
from distutils.errors import *
from distutils.filelist import FileList
from distutils import log
from distutils.util import convert_path

def show_formats():
    &quot;&quot;&quot;Print all possible values for the &#039;formats&#039; option (used by
    the &quot;--help-formats&quot; command-line option).
    &quot;&quot;&quot;
    from distutils.fancy_getopt import FancyGetopt
    from distutils.archive_util import ARCHIVE_FORMATS
    formats = []
    for format in ARCHIVE_FORMATS.keys():
        formats.append((&quot;formats=&quot; + format, None,
                        ARCHIVE_FORMATS[format][2]))
    formats.sort()
    FancyGetopt(formats).print_help(
        &quot;List of available source distribution formats:&quot;)

class sdist(Command):

    description = &quot;create a source distribution (tarball, zip file, etc.)&quot;

    def checking_metadata(self):
        &quot;&quot;&quot;Callable used for the check sub-command.

        Placed here so user_options can view it&quot;&quot;&quot;
        return self.metadata_check

    user_options = [
        (&#039;template=&#039;, &#039;t&#039;,
         &quot;name of manifest template file [default: MANIFEST.in]&quot;),
        (&#039;manifest=&#039;, &#039;m&#039;,
         &quot;name of manifest file [default: MANIFEST]&quot;),
        (&#039;use-defaults&#039;, None,
         &quot;include the default file set in the manifest &quot;
         &quot;[default; disable with --no-defaults]&quot;),
        (&#039;no-defaults&#039;, None,
         &quot;don&#039;t include the default file set&quot;),
        (&#039;prune&#039;, None,
         &quot;specifically exclude files/directories that should not be &quot;
         &quot;distributed (build tree, RCS/CVS dirs, etc.) &quot;
         &quot;[default; disable with --no-prune]&quot;),
        (&#039;no-prune&#039;, None,
         &quot;don&#039;t automatically exclude anything&quot;),
        (&#039;manifest-only&#039;, &#039;o&#039;,
         &quot;just regenerate the manifest and then stop &quot;
         &quot;(implies --force-manifest)&quot;),
        (&#039;force-manifest&#039;, &#039;f&#039;,
         &quot;forcibly regenerate the manifest and carry on as usual. &quot;
         &quot;Deprecated: now the manifest is always regenerated.&quot;),
        (&#039;formats=&#039;, None,
         &quot;formats for source distribution (comma-separated list)&quot;),
        (&#039;keep-temp&#039;, &#039;k&#039;,
         &quot;keep the distribution tree around after creating &quot; +
         &quot;archive file(s)&quot;),
        (&#039;dist-dir=&#039;, &#039;d&#039;,
         &quot;directory to put the source distribution archive(s) in &quot;
         &quot;[default: dist]&quot;),
        (&#039;metadata-check&#039;, None,
         &quot;Ensure that all required elements of meta-data &quot;
         &quot;are supplied. Warn if any missing. [default]&quot;),
        (&#039;owner=&#039;, &#039;u&#039;,
         &quot;Owner name used when creating a tar file [default: current user]&quot;),
        (&#039;group=&#039;, &#039;g&#039;,
         &quot;Group name used when creating a tar file [default: current group]&quot;),
        ]

    boolean_options = [&#039;use-defaults&#039;, &#039;prune&#039;,
                       &#039;manifest-only&#039;, &#039;force-manifest&#039;,
                       &#039;keep-temp&#039;, &#039;metadata-check&#039;]

    help_options = [
        (&#039;help-formats&#039;, None,
         &quot;list available distribution formats&quot;, show_formats),
        ]

    negative_opt = {&#039;no-defaults&#039;: &#039;use-defaults&#039;,
                    &#039;no-prune&#039;: &#039;prune&#039; }

    sub_commands = [(&#039;check&#039;, checking_metadata)]

    def initialize_options(self):
        # &#039;template&#039; and &#039;manifest&#039; are, respectively, the names of
        # the manifest template and manifest file.
        self.template = None
        self.manifest = None

        # &#039;use_defaults&#039;: if true, we will include the default file set
        # in the manifest
        self.use_defaults = 1
        self.prune = 1

        self.manifest_only = 0
        self.force_manifest = 0

        self.formats = [&#039;gztar&#039;]
        self.keep_temp = 0
        self.dist_dir = None

        self.archive_files = None
        self.metadata_check = 1
        self.owner = None
        self.group = None

    def finalize_options(self):
        if self.manifest is None:
            self.manifest = &quot;MANIFEST&quot;
        if self.template is None:
            self.template = &quot;MANIFEST.in&quot;

        self.ensure_string_list(&#039;formats&#039;)

        bad_format = archive_util.check_archive_formats(self.formats)
        if bad_format:
            raise DistutilsOptionError(
                  &quot;unknown archive format &#039;%s&#039;&quot; % bad_format)

        if self.dist_dir is None:
            self.dist_dir = &quot;dist&quot;

    def run(self):
        # &#039;filelist&#039; contains the list of files that will make up the
        # manifest
        self.filelist = FileList()

        # Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        # Do whatever it takes to get the list of files to process
        # (process the manifest template, read an existing manifest,
        # whatever).  File list is accumulated in &#039;self.filelist&#039;.
        self.get_file_list()

        # If user just wanted us to regenerate the manifest, stop now.
        if self.manifest_only:
            return

        # Otherwise, go ahead and create the source distribution tarball,
        # or zipfile, or whatever.
        self.make_distribution()

    def check_metadata(self):
        &quot;&quot;&quot;Deprecated API.&quot;&quot;&quot;
        warn(&quot;distutils.command.sdist.check_metadata is deprecated, \
              use the check command instead&quot;, PendingDeprecationWarning)
        check = self.distribution.get_command_obj(&#039;check&#039;)
        check.ensure_finalized()
        check.run()

    def get_file_list(self):
        &quot;&quot;&quot;Figure out the list of files to include in the source
        distribution, and put it in &#039;self.filelist&#039;.  This might involve
        reading the manifest template (and writing the manifest), or just
        reading the manifest, or just using the default file set -- it all
        depends on the user&#039;s options.
        &quot;&quot;&quot;
        # new behavior when using a template:
        # the file list is recalculated every time because
        # even if MANIFEST.in or setup.py are not changed
        # the user might have added some files in the tree that
        # need to be included.
        #
        #  This makes --force the default and only behavior with templates.
        template_exists = os.path.isfile(self.template)
        if not template_exists and self._manifest_is_not_generated():
            self.read_manifest()
            self.filelist.sort()
            self.filelist.remove_duplicates()
            return

        if not template_exists:
            self.warn((&quot;manifest template &#039;%s&#039; does not exist &quot; +
                        &quot;(using default file list)&quot;) %
                        self.template)
        self.filelist.findall()

        if self.use_defaults:
            self.add_defaults()

        if template_exists:
            self.read_template()

        if self.prune:
            self.prune_file_list()

        self.filelist.sort()
        self.filelist.remove_duplicates()
        self.write_manifest()

    def add_defaults(self):
        &quot;&quot;&quot;Add all the default files to self.filelist:
          - README or README.txt
          - setup.py
          - test/test*.py
          - all pure Python modules mentioned in setup script
          - all files pointed by package_data (build_py)
          - all files defined in data_files.
          - all files defined as scripts.
          - all C sources listed as part of extensions or C libraries
            in the setup script (doesn&#039;t catch C headers!)
        Warns if (README or README.txt) or setup.py are missing; everything
        else is optional.
        &quot;&quot;&quot;
        standards = [(&#039;README&#039;, &#039;README.txt&#039;), self.distribution.script_name]
        for fn in standards:
            if isinstance(fn, tuple):
                alts = fn
                got_it = False
                for fn in alts:
                    if os.path.exists(fn):
                        got_it = True
                        self.filelist.append(fn)
                        break

                if not got_it:
                    self.warn(&quot;standard file not found: should have one of &quot; +
                              &#039;, &#039;.join(alts))
            else:
                if os.path.exists(fn):
                    self.filelist.append(fn)
                else:
                    self.warn(&quot;standard file &#039;%s&#039; not found&quot; % fn)

        optional = [&#039;test/test*.py&#039;, &#039;setup.cfg&#039;]
        for pattern in optional:
            files = filter(os.path.isfile, glob(pattern))
            self.filelist.extend(files)

        # build_py is used to get:
        #  - python modules
        #  - files defined in package_data
        build_py = self.get_finalized_command(&#039;build_py&#039;)

        # getting python files
        if self.distribution.has_pure_modules():
            self.filelist.extend(build_py.get_source_files())

        # getting package_data files
        # (computed in build_py.data_files by build_py.finalize_options)
        for pkg, src_dir, build_dir, filenames in build_py.data_files:
            for filename in filenames:
                self.filelist.append(os.path.join(src_dir, filename))

        # getting distribution.data_files
        if self.distribution.has_data_files():
            for item in self.distribution.data_files:
                if isinstance(item, str): # plain file
                    item = convert_path(item)
                    if os.path.isfile(item):
                        self.filelist.append(item)
                else:    # a (dirname, filenames) tuple
                    dirname, filenames = item
                    for f in filenames:
                        f = convert_path(f)
                        if os.path.isfile(f):
                            self.filelist.append(f)

        if self.distribution.has_ext_modules():
            build_ext = self.get_finalized_command(&#039;build_ext&#039;)
            self.filelist.extend(build_ext.get_source_files())

        if self.distribution.has_c_libraries():
            build_clib = self.get_finalized_command(&#039;build_clib&#039;)
            self.filelist.extend(build_clib.get_source_files())

        if self.distribution.has_scripts():
            build_scripts = self.get_finalized_command(&#039;build_scripts&#039;)
            self.filelist.extend(build_scripts.get_source_files())

    def read_template(self):
        &quot;&quot;&quot;Read and parse manifest template file named by self.template.

        (usually &quot;MANIFEST.in&quot;) The parsing and processing is done by
        &#039;self.filelist&#039;, which updates itself accordingly.
        &quot;&quot;&quot;
        log.info(&quot;reading manifest template &#039;%s&#039;&quot;, self.template)
        template = TextFile(self.template, strip_comments=1, skip_blanks=1,
                            join_lines=1, lstrip_ws=1, rstrip_ws=1,
                            collapse_join=1)

        try:
            while True:
                line = template.readline()
                if line is None:            # end of file
                    break

                try:
                    self.filelist.process_template_line(line)
                # the call above can raise a DistutilsTemplateError for
                # malformed lines, or a ValueError from the lower-level
                # convert_path function
                except (DistutilsTemplateError, ValueError) as msg:
                    self.warn(&quot;%s, line %d: %s&quot; % (template.filename,
                                                   template.current_line,
                                                   msg))
        finally:
            template.close()

    def prune_file_list(self):
        &quot;&quot;&quot;Prune off branches that might slip into the file list as created
        by &#039;read_template()&#039;, but really don&#039;t belong there:
          * the build tree (typically &quot;build&quot;)
          * the release tree itself (only an issue if we ran &quot;sdist&quot;
            previously with --keep-temp, or it aborted)
          * any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories
        &quot;&quot;&quot;
        build = self.get_finalized_command(&#039;build&#039;)
        base_dir = self.distribution.get_fullname()

        self.filelist.exclude_pattern(None, prefix=build.build_base)
        self.filelist.exclude_pattern(None, prefix=base_dir)

        if sys.platform == &#039;win32&#039;:
            seps = r&#039;/|\\&#039;
        else:
            seps = &#039;/&#039;

        vcs_dirs = [&#039;RCS&#039;, &#039;CVS&#039;, r&#039;\.svn&#039;, r&#039;\.hg&#039;, r&#039;\.git&#039;, r&#039;\.bzr&#039;,
                    &#039;_darcs&#039;]
        vcs_ptrn = r&#039;(^|%s)(%s)(%s).*&#039; % (seps, &#039;|&#039;.join(vcs_dirs), seps)
        self.filelist.exclude_pattern(vcs_ptrn, is_regex=1)

    def write_manifest(self):
        &quot;&quot;&quot;Write the file list in &#039;self.filelist&#039; (presumably as filled in
        by &#039;add_defaults()&#039; and &#039;read_template()&#039;) to the manifest file
        named by &#039;self.manifest&#039;.
        &quot;&quot;&quot;
        if self._manifest_is_not_generated():
            log.info(&quot;not writing to manually maintained &quot;
                     &quot;manifest file &#039;%s&#039;&quot; % self.manifest)
            return

        content = self.filelist.files[:]
        content.insert(0, &#039;# file GENERATED by distutils, do NOT edit&#039;)
        self.execute(file_util.write_file, (self.manifest, content),
                     &quot;writing manifest file &#039;%s&#039;&quot; % self.manifest)

    def _manifest_is_not_generated(self):
        # check for special comment used in 3.1.3 and higher
        if not os.path.isfile(self.manifest):
            return False

        fp = open(self.manifest)
        try:
            first_line = fp.readline()
        finally:
            fp.close()
        return first_line != &#039;# file GENERATED by distutils, do NOT edit\n&#039;

    def read_manifest(self):
        &quot;&quot;&quot;Read the manifest file (named by &#039;self.manifest&#039;) and use it to
        fill in &#039;self.filelist&#039;, the list of files to include in the source
        distribution.
        &quot;&quot;&quot;
        log.info(&quot;reading manifest file &#039;%s&#039;&quot;, self.manifest)
        manifest = open(self.manifest)
        for line in manifest:
            # ignore comments and blank lines
            line = line.strip()
            if line.startswith(&#039;#&#039;) or not line:
                continue
            self.filelist.append(line)
        manifest.close()

    def make_release_tree(self, base_dir, files):
        &quot;&quot;&quot;Create the directory tree that will become the source
        distribution archive.  All directories implied by the filenames in
        &#039;files&#039; are created under &#039;base_dir&#039;, and then we hard link or copy
        (if hard linking is unavailable) those files into place.
        Essentially, this duplicates the developer&#039;s source tree, but in a
        directory named after the distribution, containing only the files
        to be distributed.
        &quot;&quot;&quot;
        # Create all the directories under &#039;base_dir&#039; necessary to
        # put &#039;files&#039; there; the &#039;mkpath()&#039; is just so we don&#039;t die
        # if the manifest happens to be empty.
        self.mkpath(base_dir)
        dir_util.create_tree(base_dir, files, dry_run=self.dry_run)

        # And walk over the list of files, either making a hard link (if
        # os.link exists) to each one that doesn&#039;t already exist in its
        # corresponding location under &#039;base_dir&#039;, or copying each file
        # that&#039;s out-of-date in &#039;base_dir&#039;.  (Usually, all files will be
        # out-of-date, because by default we blow away &#039;base_dir&#039; when
        # we&#039;re done making the distribution archives.)

        if hasattr(os, &#039;link&#039;):        # can make hard links on this system
            link = &#039;hard&#039;
            msg = &quot;making hard links in %s...&quot; % base_dir
        else:                           # nope, have to copy
            link = None
            msg = &quot;copying files to %s...&quot; % base_dir

        if not files:
            log.warn(&quot;no files to distribute -- empty manifest?&quot;)
        else:
            log.info(msg)
        for file in files:
            if not os.path.isfile(file):
                log.warn(&quot;&#039;%s&#039; not a regular file -- skipping&quot;, file)
            else:
                dest = os.path.join(base_dir, file)
                self.copy_file(file, dest, link=link)

        self.distribution.metadata.write_pkg_info(base_dir)

    def make_distribution(self):
        &quot;&quot;&quot;Create the source distribution(s).  First, we create the release
        tree with &#039;make_release_tree()&#039;; then, we create all required
        archive files (according to &#039;self.formats&#039;) from the release tree.
        Finally, we clean up by blowing away the release tree (unless
        &#039;self.keep_temp&#039; is true).  The list of archive files created is
        stored so it can be retrieved later by &#039;get_archive_files()&#039;.
        &quot;&quot;&quot;
        # Don&#039;t warn about missing meta-data here -- should be (and is!)
        # done elsewhere.
        base_dir = self.distribution.get_fullname()
        base_name = os.path.join(self.dist_dir, base_dir)

        self.make_release_tree(base_dir, self.filelist.files)
        archive_files = []              # remember names of files we create
        # tar archive must be created last to avoid overwrite and remove
        if &#039;tar&#039; in self.formats:
            self.formats.append(self.formats.pop(self.formats.index(&#039;tar&#039;)))

        for fmt in self.formats:
            file = self.make_archive(base_name, fmt, base_dir=base_dir,
                                     owner=self.owner, group=self.group)
            archive_files.append(file)
            self.distribution.dist_files.append((&#039;sdist&#039;, &#039;&#039;, file))

        self.archive_files = archive_files

        if not self.keep_temp:
            dir_util.remove_tree(base_dir, dry_run=self.dry_run)

    def get_archive_files(self):
        &quot;&quot;&quot;Return the list of archive files created when the command
        was run, or None if the command hasn&#039;t run yet.
        &quot;&quot;&quot;
        return self.archive_files
</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>