1"""distutils.command.bdist_wininst 2 3Implements the Distutils 'bdist_wininst' command: create a windows installer 4exe-program.""" 5 6import sys, os 7from distutils.core import Command 8from distutils.util import get_platform 9from distutils.dir_util import create_tree, remove_tree 10from distutils.errors import * 11from distutils.sysconfig import get_python_version 12from distutils import log 13 14class bdist_wininst(Command): 15 16 description = "create an executable installer for MS Windows" 17 18 user_options = [('bdist-dir=', None, 19 "temporary directory for creating the distribution"), 20 ('plat-name=', 'p', 21 "platform name to embed in generated filenames " 22 "(default: %s)" % get_platform()), 23 ('keep-temp', 'k', 24 "keep the pseudo-installation tree around after " + 25 "creating the distribution archive"), 26 ('target-version=', None, 27 "require a specific python version" + 28 " on the target system"), 29 ('no-target-compile', 'c', 30 "do not compile .py to .pyc on the target system"), 31 ('no-target-optimize', 'o', 32 "do not compile .py to .pyo (optimized) " 33 "on the target system"), 34 ('dist-dir=', 'd', 35 "directory to put final built distributions in"), 36 ('bitmap=', 'b', 37 "bitmap to use for the installer instead of python-powered logo"), 38 ('title=', 't', 39 "title to display on the installer background instead of default"), 40 ('skip-build', None, 41 "skip rebuilding everything (for testing/debugging)"), 42 ('install-script=', None, 43 "basename of installation script to be run after " 44 "installation or before deinstallation"), 45 ('pre-install-script=', None, 46 "Fully qualified filename of a script to be run before " 47 "any files are installed. This script need not be in the " 48 "distribution"), 49 ('user-access-control=', None, 50 "specify Vista's UAC handling - 'none'/default=no " 51 "handling, 'auto'=use UAC if target Python installed for " 52 "all users, 'force'=always use UAC"), 53 ] 54 55 boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize', 56 'skip-build'] 57 58 def initialize_options(self): 59 self.bdist_dir = None 60 self.plat_name = None 61 self.keep_temp = 0 62 self.no_target_compile = 0 63 self.no_target_optimize = 0 64 self.target_version = None 65 self.dist_dir = None 66 self.bitmap = None 67 self.title = None 68 self.skip_build = None 69 self.install_script = None 70 self.pre_install_script = None 71 self.user_access_control = None 72 73 74 def finalize_options(self): 75 self.set_undefined_options('bdist', ('skip_build', 'skip_build')) 76 77 if self.bdist_dir is None: 78 if self.skip_build and self.plat_name: 79 # If build is skipped and plat_name is overridden, bdist will 80 # not see the correct 'plat_name' - so set that up manually. 81 bdist = self.distribution.get_command_obj('bdist') 82 bdist.plat_name = self.plat_name 83 # next the command will be initialized using that name 84 bdist_base = self.get_finalized_command('bdist').bdist_base 85 self.bdist_dir = os.path.join(bdist_base, 'wininst') 86 87 if not self.target_version: 88 self.target_version = "" 89 90 if not self.skip_build and self.distribution.has_ext_modules(): 91 short_version = get_python_version() 92 if self.target_version and self.target_version != short_version: 93 raise DistutilsOptionError( 94 "target version can only be %s, or the '--skip-build'" \ 95 " option must be specified" % (short_version,)) 96 self.target_version = short_version 97 98 self.set_undefined_options('bdist', 99 ('dist_dir', 'dist_dir'), 100 ('plat_name', 'plat_name'), 101 ) 102 103 if self.install_script: 104 for script in self.distribution.scripts: 105 if self.install_script == os.path.basename(script): 106 break 107 else: 108 raise DistutilsOptionError( 109 "install_script '%s' not found in scripts" 110 % self.install_script) 111 112 def run(self): 113 if (sys.platform != "win32" and 114 (self.distribution.has_ext_modules() or 115 self.distribution.has_c_libraries())): 116 raise DistutilsPlatformError \ 117 ("distribution contains extensions and/or C libraries; " 118 "must be compiled on a Windows 32 platform") 119 120 if not self.skip_build: 121 self.run_command('build') 122 123 install = self.reinitialize_command('install', reinit_subcommands=1) 124 install.root = self.bdist_dir 125 install.skip_build = self.skip_build 126 install.warn_dir = 0 127 install.plat_name = self.plat_name 128 129 install_lib = self.reinitialize_command('install_lib') 130 # we do not want to include pyc or pyo files 131 install_lib.compile = 0 132 install_lib.optimize = 0 133 134 if self.distribution.has_ext_modules(): 135 # If we are building an installer for a Python version other 136 # than the one we are currently running, then we need to ensure 137 # our build_lib reflects the other Python version rather than ours. 138 # Note that for target_version!=sys.version, we must have skipped the 139 # build step, so there is no issue with enforcing the build of this 140 # version. 141 target_version = self.target_version 142 if not target_version: 143 assert self.skip_build, "Should have already checked this" 144 target_version = '%d.%d' % sys.version_info[:2] 145 plat_specifier = ".%s-%s" % (self.plat_name, target_version) 146 build = self.get_finalized_command('build') 147 build.build_lib = os.path.join(build.build_base, 148 'lib' + plat_specifier) 149 150 # Use a custom scheme for the zip-file, because we have to decide 151 # at installation time which scheme to use. 152 for key in ('purelib', 'platlib', 'headers', 'scripts', 'data'): 153 value = key.upper() 154 if key == 'headers': 155 value = value + '/Include/$dist_name' 156 setattr(install, 157 'install_' + key, 158 value) 159 160 log.info("installing to %s", self.bdist_dir) 161 install.ensure_finalized() 162 163 # avoid warning of 'install_lib' about installing 164 # into a directory not in sys.path 165 sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB')) 166 167 install.run() 168 169 del sys.path[0] 170 171 # And make an archive relative to the root of the 172 # pseudo-installation tree. 173 from tempfile import mktemp 174 archive_basename = mktemp() 175 fullname = self.distribution.get_fullname() 176 arcname = self.make_archive(archive_basename, "zip", 177 root_dir=self.bdist_dir) 178 # create an exe containing the zip-file 179 self.create_exe(arcname, fullname, self.bitmap) 180 if self.distribution.has_ext_modules(): 181 pyversion = get_python_version() 182 else: 183 pyversion = 'any' 184 self.distribution.dist_files.append(('bdist_wininst', pyversion, 185 self.get_installer_filename(fullname))) 186 # remove the zip-file again 187 log.debug("removing temporary file '%s'", arcname) 188 os.remove(arcname) 189 190 if not self.keep_temp: 191 remove_tree(self.bdist_dir, dry_run=self.dry_run) 192 193 def get_inidata(self): 194 # Return data describing the installation. 195 lines = [] 196 metadata = self.distribution.metadata 197 198 # Write the [metadata] section. 199 lines.append("[metadata]") 200 201 # 'info' will be displayed in the installer's dialog box, 202 # describing the items to be installed. 203 info = (metadata.long_description or '') + '\n' 204 205 # Escape newline characters 206 def escape(s): 207 return s.replace("\n", "\\n") 208 209 for name in ["author", "author_email", "description", "maintainer", 210 "maintainer_email", "name", "url", "version"]: 211 data = getattr(metadata, name, "") 212 if data: 213 info = info + ("\n %s: %s" % \ 214 (name.capitalize(), escape(data))) 215 lines.append("%s=%s" % (name, escape(data))) 216 217 # The [setup] section contains entries controlling 218 # the installer runtime. 219 lines.append("\n[Setup]") 220 if self.install_script: 221 lines.append("install_script=%s" % self.install_script) 222 lines.append("info=%s" % escape(info)) 223 lines.append("target_compile=%d" % (not self.no_target_compile)) 224 lines.append("target_optimize=%d" % (not self.no_target_optimize)) 225 if self.target_version: 226 lines.append("target_version=%s" % self.target_version) 227 if self.user_access_control: 228 lines.append("user_access_control=%s" % self.user_access_control) 229 230 title = self.title or self.distribution.get_fullname() 231 lines.append("title=%s" % escape(title)) 232 import time 233 import distutils 234 build_info = "Built %s with distutils-%s" % \ 235 (time.ctime(time.time()), distutils.__version__) 236 lines.append("build_info=%s" % build_info) 237 return "\n".join(lines) 238 239 def create_exe(self, arcname, fullname, bitmap=None): 240 import struct 241 242 self.mkpath(self.dist_dir) 243 244 cfgdata = self.get_inidata() 245 246 installer_name = self.get_installer_filename(fullname) 247 self.announce("creating %s" % installer_name) 248 249 if bitmap: 250 bitmapdata = open(bitmap, "rb").read() 251 bitmaplen = len(bitmapdata) 252 else: 253 bitmaplen = 0 254 255 file = open(installer_name, "wb") 256 file.write(self.get_exe_bytes()) 257 if bitmap: 258 file.write(bitmapdata) 259 260 # Convert cfgdata from unicode to ascii, mbcs encoded 261 if isinstance(cfgdata, str): 262 cfgdata = cfgdata.encode("mbcs") 263 264 # Append the pre-install script 265 cfgdata = cfgdata + b"\0" 266 if self.pre_install_script: 267 # We need to normalize newlines, so we open in text mode and 268 # convert back to bytes. "latin-1" simply avoids any possible 269 # failures. 270 with open(self.pre_install_script, "r", 271 encoding="latin-1") as script: 272 script_data = script.read().encode("latin-1") 273 cfgdata = cfgdata + script_data + b"\n\0" 274 else: 275 # empty pre-install script 276 cfgdata = cfgdata + b"\0" 277 file.write(cfgdata) 278 279 # The 'magic number' 0x1234567B is used to make sure that the 280 # binary layout of 'cfgdata' is what the wininst.exe binary 281 # expects. If the layout changes, increment that number, make 282 # the corresponding changes to the wininst.exe sources, and 283 # recompile them. 284 header = struct.pack("<iii", 285 0x1234567B, # tag 286 len(cfgdata), # length 287 bitmaplen, # number of bytes in bitmap 288 ) 289 file.write(header) 290 file.write(open(arcname, "rb").read()) 291 292 def get_installer_filename(self, fullname): 293 # Factored out to allow overriding in subclasses 294 if self.target_version: 295 # if we create an installer for a specific python version, 296 # it's better to include this in the name 297 installer_name = os.path.join(self.dist_dir, 298 "%s.%s-py%s.exe" % 299 (fullname, self.plat_name, self.target_version)) 300 else: 301 installer_name = os.path.join(self.dist_dir, 302 "%s.%s.exe" % (fullname, self.plat_name)) 303 return installer_name 304 305 def get_exe_bytes(self): 306 # If a target-version other than the current version has been 307 # specified, then using the MSVC version from *this* build is no good. 308 # Without actually finding and executing the target version and parsing 309 # its sys.version, we just hard-code our knowledge of old versions. 310 # NOTE: Possible alternative is to allow "--target-version" to 311 # specify a Python executable rather than a simple version string. 312 # We can then execute this program to obtain any info we need, such 313 # as the real sys.version string for the build. 314 cur_version = get_python_version() 315 316 # If the target version is *later* than us, then we assume they 317 # use what we use 318 # string compares seem wrong, but are what sysconfig.py itself uses 319 if self.target_version and self.target_version < cur_version: 320 if self.target_version < "2.4": 321 bv = '6.0' 322 elif self.target_version == "2.4": 323 bv = '7.1' 324 elif self.target_version == "2.5": 325 bv = '8.0' 326 elif self.target_version <= "3.2": 327 bv = '9.0' 328 elif self.target_version <= "3.4": 329 bv = '10.0' 330 else: 331 bv = '14.0' 332 else: 333 # for current version - use authoritative check. 334 try: 335 from msvcrt import CRT_ASSEMBLY_VERSION 336 except ImportError: 337 # cross-building, so assume the latest version 338 bv = '14.0' 339 else: 340 # as far as we know, CRT is binary compatible based on 341 # the first field, so assume 'x.0' until proven otherwise 342 major = CRT_ASSEMBLY_VERSION.partition('.')[0] 343 bv = major + '.0' 344 345 346 # wininst-x.y.exe is in the same directory as this file 347 directory = os.path.dirname(__file__) 348 # we must use a wininst-x.y.exe built with the same C compiler 349 # used for python. XXX What about mingw, borland, and so on? 350 351 # if plat_name starts with "win" but is not "win32" 352 # we want to strip "win" and leave the rest (e.g. -amd64) 353 # for all other cases, we don't want any suffix 354 if self.plat_name != 'win32' and self.plat_name[:3] == 'win': 355 sfix = self.plat_name[3:] 356 else: 357 sfix = '' 358 359 filename = os.path.join(directory, "wininst-%s%s.exe" % (bv, sfix)) 360 f = open(filename, "rb") 361 try: 362 return f.read() 363 finally: 364 f.close() 365