text: """distutils.command.bdist_wininst
  
  Implements the Distutils 'bdist_wininst' command: create a windows installer
  exe-program."""
  
  import os
  import sys
  import warnings
  from distutils.core import Command
  from distutils.util import get_platform
  from distutils.dir_util import remove_tree
  from distutils.errors import *
  from distutils.sysconfig import get_python_version
  from distutils import log
  
  class bdist_wininst(Command):
  
      description = "create an executable installer for MS Windows"
  
      user_options = [('bdist-dir=', None,
                       "temporary directory for creating the distribution"),
                      ('plat-name=', 'p',
                       "platform name to embed in generated filenames "
                       "(default: %s)" % get_platform()),
                      ('keep-temp', 'k',
                       "keep the pseudo-installation tree around after " +
                       "creating the distribution archive"),
                      ('target-version=', None,
                       "require a specific python version" +
                       " on the target system"),
                      ('no-target-compile', 'c',
                       "do not compile .py to .pyc on the target system"),
                      ('no-target-optimize', 'o',
                       "do not compile .py to .pyo (optimized) "
                       "on the target system"),
                      ('dist-dir=', 'd',
                       "directory to put final built distributions in"),
                      ('bitmap=', 'b',
                       "bitmap to use for the installer instead of python-powered logo"),
                      ('title=', 't',
                       "title to display on the installer background instead of default"),
                      ('skip-build', None,
                       "skip rebuilding everything (for testing/debugging)"),
                      ('install-script=', None,
                       "basename of installation script to be run after "
                       "installation or before deinstallation"),
                      ('pre-install-script=', None,
                       "Fully qualified filename of a script to be run before "
                       "any files are installed.  This script need not be in the "
                       "distribution"),
                      ('user-access-control=', None,
                       "specify Vista's UAC handling - 'none'/default=no "
                       "handling, 'auto'=use UAC if target Python installed for "
                       "all users, 'force'=always use UAC"),
                     ]
  
      boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
                         'skip-build']
  
      # bpo-10945: bdist_wininst requires mbcs encoding only available on Windows
      _unsupported = (sys.platform != "win32")
  
      def __init__(self, *args, **kw):
          super().__init__(*args, **kw)
          warnings.warn("bdist_wininst command is deprecated since Python 3.8, "
                        "use bdist_wheel (wheel packages) instead",
                        DeprecationWarning, 2)
  
      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('bdist', ('skip_build', 'skip_build'))
  
          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 'plat_name' - so set that up manually.
                  bdist = self.distribution.get_command_obj('bdist')
                  bdist.plat_name = self.plat_name
                  # next the command will be initialized using that name
              bdist_base = self.get_finalized_command('bdist').bdist_base
              self.bdist_dir = os.path.join(bdist_base, 'wininst')
  
          if not self.target_version:
              self.target_version = ""
  
          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(
                        "target version can only be %s, or the '--skip-build'" \
                        " option must be specified" % (short_version,))
              self.target_version = short_version
  
          self.set_undefined_options('bdist',
                                     ('dist_dir', 'dist_dir'),
                                     ('plat_name', 'plat_name'),
                                    )
  
          if self.install_script:
              for script in self.distribution.scripts:
                  if self.install_script == os.path.basename(script):
                      break
              else:
                  raise DistutilsOptionError(
                        "install_script '%s' not found in scripts"
                        % self.install_script)
  
      def run(self):
          if (sys.platform != "win32" and
              (self.distribution.has_ext_modules() or
               self.distribution.has_c_libraries())):
              raise DistutilsPlatformError \
                    ("distribution contains extensions and/or C libraries; "
                     "must be compiled on a Windows 32 platform")
  
          if not self.skip_build:
              self.run_command('build')
  
          install = self.reinitialize_command('install', 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('install_lib')
          # 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, "Should have already checked this"
                  target_version = '%d.%d' % sys.version_info[:2]
              plat_specifier = ".%s-%s" % (self.plat_name, target_version)
              build = self.get_finalized_command('build')
              build.build_lib = os.path.join(build.build_base,
                                             'lib' + 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 ('purelib', 'platlib', 'headers', 'scripts', 'data'):
              value = key.upper()
              if key == 'headers':
                  value = value + '/Include/$dist_name'
              setattr(install,
                      'install_' + key,
                      value)
  
          log.info("installing to %s", self.bdist_dir)
          install.ensure_finalized()
  
          # avoid warning of 'install_lib' about installing
          # into a directory not in sys.path
          sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))
  
          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, "zip",
                                      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 = 'any'
          self.distribution.dist_files.append(('bdist_wininst', pyversion,
                                               self.get_installer_filename(fullname)))
          # remove the zip-file again
          log.debug("removing temporary file '%s'", 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("[metadata]")
  
          # 'info' will be displayed in the installer's dialog box,
          # describing the items to be installed.
          info = (metadata.long_description or '') + '\n'
  
          # Escape newline characters
          def escape(s):
              return s.replace("\n", "\\n")
  
          for name in ["author", "author_email", "description", "maintainer",
                       "maintainer_email", "name", "url", "version"]:
              data = getattr(metadata, name, "")
              if data:
                  info = info + ("\n    %s: %s" % \
                                 (name.capitalize(), escape(data)))
                  lines.append("%s=%s" % (name, escape(data)))
  
          # The [setup] section contains entries controlling
          # the installer runtime.
          lines.append("\n[Setup]")
          if self.install_script:
              lines.append("install_script=%s" % self.install_script)
          lines.append("info=%s" % escape(info))
          lines.append("target_compile=%d" % (not self.no_target_compile))
          lines.append("target_optimize=%d" % (not self.no_target_optimize))
          if self.target_version:
              lines.append("target_version=%s" % self.target_version)
          if self.user_access_control:
              lines.append("user_access_control=%s" % self.user_access_control)
  
          title = self.title or self.distribution.get_fullname()
          lines.append("title=%s" % escape(title))
          import time
          import distutils
          build_info = "Built %s with distutils-%s" % \
                       (time.ctime(time.time()), distutils.__version__)
          lines.append("build_info=%s" % build_info)
          return "\n".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("creating %s" % installer_name)
  
          if bitmap:
              with open(bitmap, "rb") as f:
                  bitmapdata = f.read()
              bitmaplen = len(bitmapdata)
          else:
              bitmaplen = 0
  
          with open(installer_name, "wb") as file:
              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("mbcs")
  
              # Append the pre-install script
              cfgdata = cfgdata + b"\0"
              if self.pre_install_script:
                  # We need to normalize newlines, so we open in text mode and
                  # convert back to bytes. "latin-1" simply avoids any possible
                  # failures.
                  with open(self.pre_install_script, "r",
                            encoding="latin-1") as script:
                      script_data = script.read().encode("latin-1")
                  cfgdata = cfgdata + script_data + b"\n\0"
              else:
                  # empty pre-install script
                  cfgdata = cfgdata + b"\0"
              file.write(cfgdata)
  
              # The 'magic number' 0x1234567B is used to make sure that the
              # binary layout of 'cfgdata' 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("<iii",
                                  0x1234567B,       # tag
                                  len(cfgdata),     # length
                                  bitmaplen,        # number of bytes in bitmap
                                  )
              file.write(header)
              with open(arcname, "rb") as f:
                  file.write(f.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's better to include this in the name
              installer_name = os.path.join(self.dist_dir,
                                            "%s.%s-py%s.exe" %
                                             (fullname, self.plat_name, self.target_version))
          else:
              installer_name = os.path.join(self.dist_dir,
                                            "%s.%s.exe" % (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 "--target-version" 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 < cur_version:
              if self.target_version < "2.4":
                  bv = '6.0'
              elif self.target_version == "2.4":
                  bv = '7.1'
              elif self.target_version == "2.5":
                  bv = '8.0'
              elif self.target_version <= "3.2":
                  bv = '9.0'
              elif self.target_version <= "3.4":
                  bv = '10.0'
              else:
                  bv = '14.0'
          else:
              # for current version - use authoritative check.
              try:
                  from msvcrt import CRT_ASSEMBLY_VERSION
              except ImportError:
                  # cross-building, so assume the latest version
                  bv = '14.0'
              else:
                  # as far as we know, CRT is binary compatible based on
                  # the first field, so assume 'x.0' until proven otherwise
                  major = CRT_ASSEMBLY_VERSION.partition('.')[0]
                  bv = major + '.0'
  
  
          # 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 "win" but is not "win32"
          # we want to strip "win" and leave the rest (e.g. -amd64)
          # for all other cases, we don't want any suffix
          if self.plat_name != 'win32' and self.plat_name[:3] == 'win':
              sfix = self.plat_name[3:]
          else:
              sfix = ''
  
          filename = os.path.join(directory, "wininst-%s%s.exe" % (bv, sfix))
          f = open(filename, "rb")
          try:
              f = open(filename, "rb")
          except IOError as e:
              raise DistutilsFileError(str(e) + ', %s not included in the Debian packages.' % filename)
          try:
              return f.read()
          finally:
              f.close()
  