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

Implements the Distutils &#039;bdist_wininst&#039; command: create a windows installer
exe-program.&quot;&quot;&quot;

import sys, os
from distutils.core import Command
from distutils.util import get_platform
from distutils.dir_util import create_tree, remove_tree
from distutils.errors import *
from distutils.sysconfig import get_python_version
from distutils import log

class bdist_wininst(Command):

    description = &quot;create an executable installer for MS Windows&quot;

    user_options = [(&#039;bdist-dir=&#039;, None,
                     &quot;temporary directory for creating the distribution&quot;),
                    (&#039;plat-name=&#039;, &#039;p&#039;,
                     &quot;platform name to embed in generated filenames &quot;
                     &quot;(default: %s)&quot; % get_platform()),
                    (&#039;keep-temp&#039;, &#039;k&#039;,
                     &quot;keep the pseudo-installation tree around after &quot; +
                     &quot;creating the distribution archive&quot;),
                    (&#039;target-version=&#039;, None,
                     &quot;require a specific python version&quot; +
                     &quot; on the target system&quot;),
                    (&#039;no-target-compile&#039;, &#039;c&#039;,
                     &quot;do not compile .py to .pyc on the target system&quot;),
                    (&#039;no-target-optimize&#039;, &#039;o&#039;,
                     &quot;do not compile .py to .pyo (optimized) &quot;
                     &quot;on the target system&quot;),
                    (&#039;dist-dir=&#039;, &#039;d&#039;,
                     &quot;directory to put final built distributions in&quot;),
                    (&#039;bitmap=&#039;, &#039;b&#039;,
                     &quot;bitmap to use for the installer instead of python-powered logo&quot;),
                    (&#039;title=&#039;, &#039;t&#039;,
                     &quot;title to display on the installer background instead of default&quot;),
                    (&#039;skip-build&#039;, None,
                     &quot;skip rebuilding everything (for testing/debugging)&quot;),
                    (&#039;install-script=&#039;, None,
                     &quot;basename of installation script to be run after &quot;
                     &quot;installation or before deinstallation&quot;),
                    (&#039;pre-install-script=&#039;, None,
                     &quot;Fully qualified filename of a script to be run before &quot;
                     &quot;any files are installed.  This script need not be in the &quot;
                     &quot;distribution&quot;),
                    (&#039;user-access-control=&#039;, None,
                     &quot;specify Vista&#039;s UAC handling - &#039;none&#039;/default=no &quot;
                     &quot;handling, &#039;auto&#039;=use UAC if target Python installed for &quot;
                     &quot;all users, &#039;force&#039;=always use UAC&quot;),
                   ]

    boolean_options = [&#039;keep-temp&#039;, &#039;no-target-compile&#039;, &#039;no-target-optimize&#039;,
                       &#039;skip-build&#039;]

    # bpo-10945: bdist_wininst requires mbcs encoding only available on Windows
    _unsupported = (sys.platform != &quot;win32&quot;)

    def initialize_options(self):
        self.bdist_dir = None
        self.plat_name = None
        self.keep_temp = 0
        self.no_target_compile = 0
        self.no_target_optimize = 0
        self.target_version = None
        self.dist_dir = None
        self.bitmap = None
        self.title = None
        self.skip_build = None
        self.install_script = None
        self.pre_install_script = None
        self.user_access_control = None


    def finalize_options(self):
        self.set_undefined_options(&#039;bdist&#039;, (&#039;skip_build&#039;, &#039;skip_build&#039;))

        if self.bdist_dir is None:
            if self.skip_build and self.plat_name:
                # If build is skipped and plat_name is overridden, bdist will
                # not see the correct &#039;plat_name&#039; - so set that up manually.
                bdist = self.distribution.get_command_obj(&#039;bdist&#039;)
                bdist.plat_name = self.plat_name
                # next the command will be initialized using that name
            bdist_base = self.get_finalized_command(&#039;bdist&#039;).bdist_base
            self.bdist_dir = os.path.join(bdist_base, &#039;wininst&#039;)

        if not self.target_version:
            self.target_version = &quot;&quot;

        if not self.skip_build and self.distribution.has_ext_modules():
            short_version = get_python_version()
            if self.target_version and self.target_version != short_version:
                raise DistutilsOptionError(
                      &quot;target version can only be %s, or the &#039;--skip-build&#039;&quot; \
                      &quot; option must be specified&quot; % (short_version,))
            self.target_version = short_version

        self.set_undefined_options(&#039;bdist&#039;,
                                   (&#039;dist_dir&#039;, &#039;dist_dir&#039;),
                                   (&#039;plat_name&#039;, &#039;plat_name&#039;),
                                  )

        if self.install_script:
            for script in self.distribution.scripts:
                if self.install_script == os.path.basename(script):
                    break
            else:
                raise DistutilsOptionError(
                      &quot;install_script &#039;%s&#039; not found in scripts&quot;
                      % self.install_script)

    def run(self):
        if (sys.platform != &quot;win32&quot; and
            (self.distribution.has_ext_modules() or
             self.distribution.has_c_libraries())):
            raise DistutilsPlatformError \
                  (&quot;distribution contains extensions and/or C libraries; &quot;
                   &quot;must be compiled on a Windows 32 platform&quot;)

        if not self.skip_build:
            self.run_command(&#039;build&#039;)

        install = self.reinitialize_command(&#039;install&#039;, reinit_subcommands=1)
        install.root = self.bdist_dir
        install.skip_build = self.skip_build
        install.warn_dir = 0
        install.plat_name = self.plat_name

        install_lib = self.reinitialize_command(&#039;install_lib&#039;)
        # we do not want to include pyc or pyo files
        install_lib.compile = 0
        install_lib.optimize = 0

        if self.distribution.has_ext_modules():
            # If we are building an installer for a Python version other
            # than the one we are currently running, then we need to ensure
            # our build_lib reflects the other Python version rather than ours.
            # Note that for target_version!=sys.version, we must have skipped the
            # build step, so there is no issue with enforcing the build of this
            # version.
            target_version = self.target_version
            if not target_version:
                assert self.skip_build, &quot;Should have already checked this&quot;
                target_version = &#039;%d.%d&#039; % sys.version_info[:2]
            plat_specifier = &quot;.%s-%s&quot; % (self.plat_name, target_version)
            build = self.get_finalized_command(&#039;build&#039;)
            build.build_lib = os.path.join(build.build_base,
                                           &#039;lib&#039; + plat_specifier)

        # Use a custom scheme for the zip-file, because we have to decide
        # at installation time which scheme to use.
        for key in (&#039;purelib&#039;, &#039;platlib&#039;, &#039;headers&#039;, &#039;scripts&#039;, &#039;data&#039;):
            value = key.upper()
            if key == &#039;headers&#039;:
                value = value + &#039;/Include/$dist_name&#039;
            setattr(install,
                    &#039;install_&#039; + key,
                    value)

        log.info(&quot;installing to %s&quot;, self.bdist_dir)
        install.ensure_finalized()

        # avoid warning of &#039;install_lib&#039; about installing
        # into a directory not in sys.path
        sys.path.insert(0, os.path.join(self.bdist_dir, &#039;PURELIB&#039;))

        install.run()

        del sys.path[0]

        # And make an archive relative to the root of the
        # pseudo-installation tree.
        from tempfile import mktemp
        archive_basename = mktemp()
        fullname = self.distribution.get_fullname()
        arcname = self.make_archive(archive_basename, &quot;zip&quot;,
                                    root_dir=self.bdist_dir)
        # create an exe containing the zip-file
        self.create_exe(arcname, fullname, self.bitmap)
        if self.distribution.has_ext_modules():
            pyversion = get_python_version()
        else:
            pyversion = &#039;any&#039;
        self.distribution.dist_files.append((&#039;bdist_wininst&#039;, pyversion,
                                             self.get_installer_filename(fullname)))
        # remove the zip-file again
        log.debug(&quot;removing temporary file &#039;%s&#039;&quot;, arcname)
        os.remove(arcname)

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

    def get_inidata(self):
        # Return data describing the installation.
        lines = []
        metadata = self.distribution.metadata

        # Write the [metadata] section.
        lines.append(&quot;[metadata]&quot;)

        # &#039;info&#039; will be displayed in the installer&#039;s dialog box,
        # describing the items to be installed.
        info = (metadata.long_description or &#039;&#039;) + &#039;\n&#039;

        # Escape newline characters
        def escape(s):
            return s.replace(&quot;\n&quot;, &quot;\\n&quot;)

        for name in [&quot;author&quot;, &quot;author_email&quot;, &quot;description&quot;, &quot;maintainer&quot;,
                     &quot;maintainer_email&quot;, &quot;name&quot;, &quot;url&quot;, &quot;version&quot;]:
            data = getattr(metadata, name, &quot;&quot;)
            if data:
                info = info + (&quot;\n    %s: %s&quot; % \
                               (name.capitalize(), escape(data)))
                lines.append(&quot;%s=%s&quot; % (name, escape(data)))

        # The [setup] section contains entries controlling
        # the installer runtime.
        lines.append(&quot;\n[Setup]&quot;)
        if self.install_script:
            lines.append(&quot;install_script=%s&quot; % self.install_script)
        lines.append(&quot;info=%s&quot; % escape(info))
        lines.append(&quot;target_compile=%d&quot; % (not self.no_target_compile))
        lines.append(&quot;target_optimize=%d&quot; % (not self.no_target_optimize))
        if self.target_version:
            lines.append(&quot;target_version=%s&quot; % self.target_version)
        if self.user_access_control:
            lines.append(&quot;user_access_control=%s&quot; % self.user_access_control)

        title = self.title or self.distribution.get_fullname()
        lines.append(&quot;title=%s&quot; % escape(title))
        import time
        import distutils
        build_info = &quot;Built %s with distutils-%s&quot; % \
                     (time.ctime(time.time()), distutils.__version__)
        lines.append(&quot;build_info=%s&quot; % build_info)
        return &quot;\n&quot;.join(lines)

    def create_exe(self, arcname, fullname, bitmap=None):
        import struct

        self.mkpath(self.dist_dir)

        cfgdata = self.get_inidata()

        installer_name = self.get_installer_filename(fullname)
        self.announce(&quot;creating %s&quot; % installer_name)

        if bitmap:
            bitmapdata = open(bitmap, &quot;rb&quot;).read()
            bitmaplen = len(bitmapdata)
        else:
            bitmaplen = 0

        file = open(installer_name, &quot;wb&quot;)
        file.write(self.get_exe_bytes())
        if bitmap:
            file.write(bitmapdata)

        # Convert cfgdata from unicode to ascii, mbcs encoded
        if isinstance(cfgdata, str):
            cfgdata = cfgdata.encode(&quot;mbcs&quot;)

        # Append the pre-install script
        cfgdata = cfgdata + b&quot;\0&quot;
        if self.pre_install_script:
            # We need to normalize newlines, so we open in text mode and
            # convert back to bytes. &quot;latin-1&quot; simply avoids any possible
            # failures.
            with open(self.pre_install_script, &quot;r&quot;,
                encoding=&quot;latin-1&quot;) as script:
                script_data = script.read().encode(&quot;latin-1&quot;)
            cfgdata = cfgdata + script_data + b&quot;\n\0&quot;
        else:
            # empty pre-install script
            cfgdata = cfgdata + b&quot;\0&quot;
        file.write(cfgdata)

        # The &#039;magic number&#039; 0x1234567B is used to make sure that the
        # binary layout of &#039;cfgdata&#039; is what the wininst.exe binary
        # expects.  If the layout changes, increment that number, make
        # the corresponding changes to the wininst.exe sources, and
        # recompile them.
        header = struct.pack(&quot;&lt;iii&quot;,
                             0x1234567B,       # tag
                             len(cfgdata),     # length
                             bitmaplen,        # number of bytes in bitmap
                             )
        file.write(header)
        file.write(open(arcname, &quot;rb&quot;).read())

    def get_installer_filename(self, fullname):
        # Factored out to allow overriding in subclasses
        if self.target_version:
            # if we create an installer for a specific python version,
            # it&#039;s better to include this in the name
            installer_name = os.path.join(self.dist_dir,
                                          &quot;%s.%s-py%s.exe&quot; %
                                           (fullname, self.plat_name, self.target_version))
        else:
            installer_name = os.path.join(self.dist_dir,
                                          &quot;%s.%s.exe&quot; % (fullname, self.plat_name))
        return installer_name

    def get_exe_bytes(self):
        # If a target-version other than the current version has been
        # specified, then using the MSVC version from *this* build is no good.
        # Without actually finding and executing the target version and parsing
        # its sys.version, we just hard-code our knowledge of old versions.
        # NOTE: Possible alternative is to allow &quot;--target-version&quot; to
        # specify a Python executable rather than a simple version string.
        # We can then execute this program to obtain any info we need, such
        # as the real sys.version string for the build.
        cur_version = get_python_version()

        # If the target version is *later* than us, then we assume they
        # use what we use
        # string compares seem wrong, but are what sysconfig.py itself uses
        if self.target_version and self.target_version &lt; cur_version:
            if self.target_version &lt; &quot;2.4&quot;:
                bv = &#039;6.0&#039;
            elif self.target_version == &quot;2.4&quot;:
                bv = &#039;7.1&#039;
            elif self.target_version == &quot;2.5&quot;:
                bv = &#039;8.0&#039;
            elif self.target_version &lt;= &quot;3.2&quot;:
                bv = &#039;9.0&#039;
            elif self.target_version &lt;= &quot;3.4&quot;:
                bv = &#039;10.0&#039;
            else:
                bv = &#039;14.0&#039;
        else:
            # for current version - use authoritative check.
            try:
                from msvcrt import CRT_ASSEMBLY_VERSION
            except ImportError:
                # cross-building, so assume the latest version
                bv = &#039;14.0&#039;
            else:
                # as far as we know, CRT is binary compatible based on
                # the first field, so assume &#039;x.0&#039; until proven otherwise
                major = CRT_ASSEMBLY_VERSION.partition(&#039;.&#039;)[0]
                bv = major + &#039;.0&#039;


        # wininst-x.y.exe is in the same directory as this file
        directory = os.path.dirname(__file__)
        # we must use a wininst-x.y.exe built with the same C compiler
        # used for python.  XXX What about mingw, borland, and so on?

        # if plat_name starts with &quot;win&quot; but is not &quot;win32&quot;
        # we want to strip &quot;win&quot; and leave the rest (e.g. -amd64)
        # for all other cases, we don&#039;t want any suffix
        if self.plat_name != &#039;win32&#039; and self.plat_name[:3] == &#039;win&#039;:
            sfix = self.plat_name[3:]
        else:
            sfix = &#039;&#039;

        filename = os.path.join(directory, &quot;wininst-%s%s.exe&quot; % (bv, sfix))
        f = open(filename, &quot;rb&quot;)
        try:
            return f.read()
        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>