1 #! /usr/bin/env python 2 3 """\ 4 bundlebuilder.py -- Tools to assemble MacOS X (application) bundles. 5 6 This module contains two classes to build so called "bundles" for 7 MacOS X. BundleBuilder is a general tool, AppBuilder is a subclass 8 specialized in building application bundles. 9 10 [Bundle|App]Builder objects are instantiated with a bunch of keyword 11 arguments, and have a build() method that will do all the work. See 12 the class doc strings for a description of the constructor arguments. 13 14 The module contains a main program that can be used in two ways: 15 16 % python bundlebuilder.py [options] build 17 % python buildapp.py [options] build 18 19 Where "buildapp.py" is a user-supplied setup.py-like script following 20 this model: 21 22 from bundlebuilder import buildapp 23 buildapp(<lots-of-keyword-args>) 24 25 """ 26 27 28 __all__ = ["BundleBuilder", "BundleBuilderError", "AppBuilder", "buildapp"] 29 30 31 from warnings import warnpy3k 32 warnpy3k("In 3.x, the bundlebuilder module is removed.", stacklevel=2) 33 34 import sys 35 import os, errno, shutil 36 import imp, marshal 37 import re 38 from copy import deepcopy 39 import getopt 40 from plistlib import Plist 41 from types import FunctionType as function 42 43 class BundleBuilderError(Exception): pass 44 45 46 class Defaults: 47 48 """Class attributes that don't start with an underscore and are 49 not functions or classmethods are (deep)copied to self.__dict__. 50 This allows for mutable default values. 51 """ 52 53 def __init__(self, **kwargs): 54 defaults = self._getDefaults() 55 defaults.update(kwargs) 56 self.__dict__.update(defaults) 57 58 def _getDefaults(cls): 59 defaults = {} 60 for base in cls.__bases__: 61 if hasattr(base, "_getDefaults"): 62 defaults.update(base._getDefaults()) 63 for name, value in cls.__dict__.items(): 64 if name[0] != "_" and not isinstance(value, 65 (function, classmethod)): 66 defaults[name] = deepcopy(value) 67 return defaults 68 _getDefaults = classmethod(_getDefaults) 69 70 71 class BundleBuilder(Defaults): 72 73 """BundleBuilder is a barebones class for assembling bundles. It 74 knows nothing about executables or icons, it only copies files 75 and creates the PkgInfo and Info.plist files. 76 """ 77 78 # (Note that Defaults.__init__ (deep)copies these values to 79 # instance variables. Mutable defaults are therefore safe.) 80 81 # Name of the bundle, with or without extension. 82 name = None 83 84 # The property list ("plist") 85 plist = Plist(CFBundleDevelopmentRegion = "English", 86 CFBundleInfoDictionaryVersion = "6.0") 87 88 # The type of the bundle. 89 type = "BNDL" 90 # The creator code of the bundle. 91 creator = None 92 93 # the CFBundleIdentifier (this is used for the preferences file name) 94 bundle_id = None 95 96 # List of files that have to be copied to <bundle>/Contents/Resources. 97 resources = [] 98 99 # List of (src, dest) tuples; dest should be a path relative to the bundle 100 # (eg. "Contents/Resources/MyStuff/SomeFile.ext). 101 files = [] 102 103 # List of shared libraries (dylibs, Frameworks) to bundle with the app 104 # will be placed in Contents/Frameworks 105 libs = [] 106 107 # Directory where the bundle will be assembled. 108 builddir = "build" 109 110 # Make symlinks instead copying files. This is handy during debugging, but 111 # makes the bundle non-distributable. 112 symlink = 0 113 114 # Verbosity level. 115 verbosity = 1 116 117 # Destination root directory 118 destroot = "" 119 120 def setup(self): 121 # XXX rethink self.name munging, this is brittle. 122 self.name, ext = os.path.splitext(self.name) 123 if not ext: 124 ext = ".bundle" 125 bundleextension = ext 126 # misc (derived) attributes 127 self.bundlepath = pathjoin(self.builddir, self.name + bundleextension) 128 129 plist = self.plist 130 plist.CFBundleName = self.name 131 plist.CFBundlePackageType = self.type 132 if self.creator is None: 133 if hasattr(plist, "CFBundleSignature"): 134 self.creator = plist.CFBundleSignature 135 else: 136 self.creator = "????" 137 plist.CFBundleSignature = self.creator 138 if self.bundle_id: 139 plist.CFBundleIdentifier = self.bundle_id 140 elif not hasattr(plist, "CFBundleIdentifier"): 141 plist.CFBundleIdentifier = self.name 142 143 def build(self): 144 """Build the bundle.""" 145 builddir = self.builddir 146 if builddir and not os.path.exists(builddir): 147 os.mkdir(builddir) 148 self.message("Building %s" % repr(self.bundlepath), 1) 149 if os.path.exists(self.bundlepath): 150 shutil.rmtree(self.bundlepath) 151 if os.path.exists(self.bundlepath + '~'): 152 shutil.rmtree(self.bundlepath + '~') 153 bp = self.bundlepath 154 155 # Create the app bundle in a temporary location and then 156 # rename the completed bundle. This way the Finder will 157 # never see an incomplete bundle (where it might pick up 158 # and cache the wrong meta data) 159 self.bundlepath = bp + '~' 160 try: 161 os.mkdir(self.bundlepath) 162 self.preProcess() 163 self._copyFiles() 164 self._addMetaFiles() 165 self.postProcess() 166 os.rename(self.bundlepath, bp) 167 finally: 168 self.bundlepath = bp 169 self.message("Done.", 1) 170 171 def preProcess(self): 172 """Hook for subclasses.""" 173 pass 174 def postProcess(self): 175 """Hook for subclasses.""" 176 pass 177 178 def _addMetaFiles(self): 179 contents = pathjoin(self.bundlepath, "Contents") 180 makedirs(contents) 181 # 182 # Write Contents/PkgInfo 183 assert len(self.type) == len(self.creator) == 4, \ 184 "type and creator must be 4-byte strings." 185 pkginfo = pathjoin(contents, "PkgInfo") 186 f = open(pkginfo, "wb") 187 f.write(self.type + self.creator) 188 f.close() 189 # 190 # Write Contents/Info.plist 191 infoplist = pathjoin(contents, "Info.plist") 192 self.plist.write(infoplist) 193 194 def _copyFiles(self): 195 files = self.files[:] 196 for path in self.resources: 197 files.append((path, pathjoin("Contents", "Resources", 198 os.path.basename(path)))) 199 for path in self.libs: 200 files.append((path, pathjoin("Contents", "Frameworks", 201 os.path.basename(path)))) 202 if self.symlink: 203 self.message("Making symbolic links", 1) 204 msg = "Making symlink from" 205 else: 206 self.message("Copying files", 1) 207 msg = "Copying" 208 files.sort() 209 for src, dst in files: 210 if os.path.isdir(src): 211 self.message("%s %s/ to %s/" % (msg, src, dst), 2) 212 else: 213 self.message("%s %s to %s" % (msg, src, dst), 2) 214 dst = pathjoin(self.bundlepath, dst) 215 if self.symlink: 216 symlink(src, dst, mkdirs=1) 217 else: 218 copy(src, dst, mkdirs=1) 219 220 def message(self, msg, level=0): 221 if level <= self.verbosity: 222 indent = "" 223 if level > 1: 224 indent = (level - 1) * " " 225 sys.stderr.write(indent + msg + "\n") 226 227 def report(self): 228 # XXX something decent 229 pass 230 231 232 if __debug__: 233 PYC_EXT = ".pyc" 234 else: 235 PYC_EXT = ".pyo" 236 237 MAGIC = imp.get_magic() 238 USE_ZIPIMPORT = "zipimport" in sys.builtin_module_names 239 240 # For standalone apps, we have our own minimal site.py. We don't need 241 # all the cruft of the real site.py. 242 SITE_PY = """\ 243 import sys 244 if not %(semi_standalone)s: 245 del sys.path[1:] # sys.path[0] is Contents/Resources/ 246 """ 247 248 ZIP_ARCHIVE = "Modules.zip" 249 SITE_PY_ZIP = SITE_PY + ("sys.path.append(sys.path[0] + '/%s')\n" % ZIP_ARCHIVE) 250 251 def getPycData(fullname, code, ispkg): 252 if ispkg: 253 fullname += ".__init__" 254 path = fullname.replace(".", os.sep) + PYC_EXT 255 return path, MAGIC + '\0\0\0\0' + marshal.dumps(code) 256 257 # 258 # Extension modules can't be in the modules zip archive, so a placeholder 259 # is added instead, that loads the extension from a specified location. 260 # 261 EXT_LOADER = """\ 262 def __load(): 263 import imp, sys, os 264 for p in sys.path: 265 path = os.path.join(p, "%(filename)s") 266 if os.path.exists(path): 267 break 268 else: 269 assert 0, "file not found: %(filename)s" 270 mod = imp.load_dynamic("%(name)s", path) 271 272 __load() 273 del __load 274 """ 275 276 MAYMISS_MODULES = ['os2', 'nt', 'ntpath', 'dos', 'dospath', 277 'win32api', 'ce', '_winreg', 'nturl2path', 'sitecustomize', 278 'org.python.core', 'riscos', 'riscosenviron', 'riscospath' 279 ] 280 281 STRIP_EXEC = "/usr/bin/strip" 282 283 # 284 # We're using a stock interpreter to run the app, yet we need 285 # a way to pass the Python main program to the interpreter. The 286 # bootstrapping script fires up the interpreter with the right 287 # arguments. os.execve() is used as OSX doesn't like us to 288 # start a real new process. Also, the executable name must match 289 # the CFBundleExecutable value in the Info.plist, so we lie 290 # deliberately with argv[0]. The actual Python executable is 291 # passed in an environment variable so we can "repair" 292 # sys.executable later. 293 # 294 BOOTSTRAP_SCRIPT = """\ 295 #!%(hashbang)s 296 297 import sys, os 298 execdir = os.path.dirname(sys.argv[0]) 299 executable = os.path.join(execdir, "%(executable)s") 300 resdir = os.path.join(os.path.dirname(execdir), "Resources") 301 libdir = os.path.join(os.path.dirname(execdir), "Frameworks") 302 mainprogram = os.path.join(resdir, "%(mainprogram)s") 303 304 if %(optimize)s: 305 sys.argv.insert(1, '-O') 306 307 sys.argv.insert(1, mainprogram) 308 if %(standalone)s or %(semi_standalone)s: 309 os.environ["PYTHONPATH"] = resdir 310 if %(standalone)s: 311 os.environ["PYTHONHOME"] = resdir 312 else: 313 pypath = os.getenv("PYTHONPATH", "") 314 if pypath: 315 pypath = ":" + pypath 316 os.environ["PYTHONPATH"] = resdir + pypath 317 318 os.environ["PYTHONEXECUTABLE"] = executable 319 os.environ["DYLD_LIBRARY_PATH"] = libdir 320 os.environ["DYLD_FRAMEWORK_PATH"] = libdir 321 os.execve(executable, sys.argv, os.environ) 322 """ 323 324 325 # 326 # Optional wrapper that converts "dropped files" into sys.argv values. 327 # 328 ARGV_EMULATOR = """\ 329 import argvemulator, os 330 331 argvemulator.ArgvCollector().mainloop() 332 execfile(os.path.join(os.path.split(__file__)[0], "%(realmainprogram)s")) 333 """ 334 335 # 336 # When building a standalone app with Python.framework, we need to copy 337 # a subset from Python.framework to the bundle. The following list 338 # specifies exactly what items we'll copy. 339 # 340 PYTHONFRAMEWORKGOODIES = [ 341 "Python", # the Python core library 342 "Resources/English.lproj", 343 "Resources/Info.plist", 344 ] 345 346 def isFramework(): 347 return sys.exec_prefix.find("Python.framework") > 0 348 349 350 LIB = os.path.join(sys.prefix, "lib", "python" + sys.version[:3]) 351 SITE_PACKAGES = os.path.join(LIB, "site-packages") 352 353 354 class AppBuilder(BundleBuilder): 355 356 use_zipimport = USE_ZIPIMPORT 357 358 # Override type of the bundle. 359 type = "APPL" 360 361 # platform, name of the subfolder of Contents that contains the executable. 362 platform = "MacOS" 363 364 # A Python main program. If this argument is given, the main 365 # executable in the bundle will be a small wrapper that invokes 366 # the main program. (XXX Discuss why.) 367 mainprogram = None 368 369 # The main executable. If a Python main program is specified 370 # the executable will be copied to Resources and be invoked 371 # by the wrapper program mentioned above. Otherwise it will 372 # simply be used as the main executable. 373 executable = None 374 375 # The name of the main nib, for Cocoa apps. *Must* be specified 376 # when building a Cocoa app. 377 nibname = None 378 379 # The name of the icon file to be copied to Resources and used for 380 # the Finder icon. 381 iconfile = None 382 383 # Symlink the executable instead of copying it. 384 symlink_exec = 0 385 386 # If True, build standalone app. 387 standalone = 0 388 389 # If True, build semi-standalone app (only includes third-party modules). 390 semi_standalone = 0 391 392 # If set, use this for #! lines in stead of sys.executable 393 python = None 394 395 # If True, add a real main program that emulates sys.argv before calling 396 # mainprogram 397 argv_emulation = 0 398 399 # The following attributes are only used when building a standalone app. 400 401 # Exclude these modules. 402 excludeModules = [] 403 404 # Include these modules. 405 includeModules = [] 406 407 # Include these packages. 408 includePackages = [] 409 410 # Strip binaries from debug info. 411 strip = 0 412 413 # Found Python modules: [(name, codeobject, ispkg), ...] 414 pymodules = [] 415 416 # Modules that modulefinder couldn't find: 417 missingModules = [] 418 maybeMissingModules = [] 419 420 def setup(self): 421 if ((self.standalone or self.semi_standalone) 422 and self.mainprogram is None): 423 raise BundleBuilderError, ("must specify 'mainprogram' when " 424 "building a standalone application.") 425 if self.mainprogram is None and self.executable is None: 426 raise BundleBuilderError, ("must specify either or both of " 427 "'executable' and 'mainprogram'") 428 429 self.execdir = pathjoin("Contents", self.platform) 430 431 if self.name is not None: 432 pass 433 elif self.mainprogram is not None: 434 self.name = os.path.splitext(os.path.basename(self.mainprogram))[0] 435 elif self.executable is not None: 436 self.name = os.path.splitext(os.path.basename(self.executable))[0] 437 if self.name[-4:] != ".app": 438 self.name += ".app" 439 440 if self.executable is None: 441 if not self.standalone and not isFramework(): 442 self.symlink_exec = 1 443 if self.python: 444 self.executable = self.python 445 else: 446 self.executable = sys.executable 447 448 if self.nibname: 449 self.plist.NSMainNibFile = self.nibname 450 if not hasattr(self.plist, "NSPrincipalClass"): 451 self.plist.NSPrincipalClass = "NSApplication" 452 453 if self.standalone and isFramework(): 454 self.addPythonFramework() 455 456 BundleBuilder.setup(self) 457 458 self.plist.CFBundleExecutable = self.name 459 460 if self.standalone or self.semi_standalone: 461 self.findDependencies() 462 463 def preProcess(self): 464 resdir = "Contents/Resources" 465 if self.executable is not None: 466 if self.mainprogram is None: 467 execname = self.name 468 else: 469 execname = os.path.basename(self.executable) 470 execpath = pathjoin(self.execdir, execname) 471 if not self.symlink_exec: 472 self.files.append((self.destroot + self.executable, execpath)) 473 self.execpath = execpath 474 475 if self.mainprogram is not None: 476 mainprogram = os.path.basename(self.mainprogram) 477 self.files.append((self.mainprogram, pathjoin(resdir, mainprogram))) 478 if self.argv_emulation: 479 # Change the main program, and create the helper main program (which 480 # does argv collection and then calls the real main). 481 # Also update the included modules (if we're creating a standalone 482 # program) and the plist 483 realmainprogram = mainprogram 484 mainprogram = '__argvemulator_' + mainprogram 485 resdirpath = pathjoin(self.bundlepath, resdir) 486 mainprogrampath = pathjoin(resdirpath, mainprogram) 487 makedirs(resdirpath) 488 open(mainprogrampath, "w").write(ARGV_EMULATOR % locals()) 489 if self.standalone or self.semi_standalone: 490 self.includeModules.append("argvemulator") 491 self.includeModules.append("os") 492 if "CFBundleDocumentTypes" not in self.plist: 493 self.plist["CFBundleDocumentTypes"] = [ 494 { "CFBundleTypeOSTypes" : [ 495 "****", 496 "fold", 497 "disk"], 498 "CFBundleTypeRole": "Viewer"}] 499 # Write bootstrap script 500 executable = os.path.basename(self.executable) 501 execdir = pathjoin(self.bundlepath, self.execdir) 502 bootstrappath = pathjoin(execdir, self.name) 503 makedirs(execdir) 504 if self.standalone or self.semi_standalone: 505 # XXX we're screwed when the end user has deleted 506 # /usr/bin/python 507 hashbang = "/usr/bin/python" 508 elif self.python: 509 hashbang = self.python 510 else: 511 hashbang = os.path.realpath(sys.executable) 512 standalone = self.standalone 513 semi_standalone = self.semi_standalone 514 optimize = sys.flags.optimize 515 open(bootstrappath, "w").write(BOOTSTRAP_SCRIPT % locals()) 516 os.chmod(bootstrappath, 0775) 517 518 if self.iconfile is not None: 519 iconbase = os.path.basename(self.iconfile) 520 self.plist.CFBundleIconFile = iconbase 521 self.files.append((self.iconfile, pathjoin(resdir, iconbase))) 522 523 def postProcess(self): 524 if self.standalone or self.semi_standalone: 525 self.addPythonModules() 526 if self.strip and not self.symlink: 527 self.stripBinaries() 528 529 if self.symlink_exec and self.executable: 530 self.message("Symlinking executable %s to %s" % (self.executable, 531 self.execpath), 2) 532 dst = pathjoin(self.bundlepath, self.execpath) 533 makedirs(os.path.dirname(dst)) 534 os.symlink(os.path.abspath(self.executable), dst) 535 536 if self.missingModules or self.maybeMissingModules: 537 self.reportMissing() 538 539 def addPythonFramework(self): 540 # If we're building a standalone app with Python.framework, 541 # include a minimal subset of Python.framework, *unless* 542 # Python.framework was specified manually in self.libs. 543 for lib in self.libs: 544 if os.path.basename(lib) == "Python.framework": 545 # a Python.framework was specified as a library 546 return 547 548 frameworkpath = sys.exec_prefix[:sys.exec_prefix.find( 549 "Python.framework") + len("Python.framework")] 550 551 version = sys.version[:3] 552 frameworkpath = pathjoin(frameworkpath, "Versions", version) 553 destbase = pathjoin("Contents", "Frameworks", "Python.framework", 554 "Versions", version) 555 for item in PYTHONFRAMEWORKGOODIES: 556 src = pathjoin(frameworkpath, item) 557 dst = pathjoin(destbase, item) 558 self.files.append((src, dst)) 559 560 def _getSiteCode(self): 561 if self.use_zipimport: 562 return compile(SITE_PY % {"semi_standalone": self.semi_standalone}, 563 "<-bundlebuilder.py->", "exec") 564 565 def addPythonModules(self): 566 self.message("Adding Python modules", 1) 567 568 if self.use_zipimport: 569 # Create a zip file containing all modules as pyc. 570 import zipfile 571 relpath = pathjoin("Contents", "Resources", ZIP_ARCHIVE) 572 abspath = pathjoin(self.bundlepath, relpath) 573 zf = zipfile.ZipFile(abspath, "w", zipfile.ZIP_DEFLATED) 574 for name, code, ispkg in self.pymodules: 575 self.message("Adding Python module %s" % name, 2) 576 path, pyc = getPycData(name, code, ispkg) 577 zf.writestr(path, pyc) 578 zf.close() 579 # add site.pyc 580 sitepath = pathjoin(self.bundlepath, "Contents", "Resources", 581 "site" + PYC_EXT) 582 writePyc(self._getSiteCode(), sitepath) 583 else: 584 # Create individual .pyc files. 585 for name, code, ispkg in self.pymodules: 586 if ispkg: 587 name += ".__init__" 588 path = name.split(".") 589 path = pathjoin("Contents", "Resources", *path) + PYC_EXT 590 591 if ispkg: 592 self.message("Adding Python package %s" % path, 2) 593 else: 594 self.message("Adding Python module %s" % path, 2) 595 596 abspath = pathjoin(self.bundlepath, path) 597 makedirs(os.path.dirname(abspath)) 598 writePyc(code, abspath) 599 600 def stripBinaries(self): 601 if not os.path.exists(STRIP_EXEC): 602 self.message("Error: can't strip binaries: no strip program at " 603 "%s" % STRIP_EXEC, 0) 604 else: 605 import stat 606 self.message("Stripping binaries", 1) 607 def walk(top): 608 for name in os.listdir(top): 609 path = pathjoin(top, name) 610 if os.path.islink(path): 611 continue 612 if os.path.isdir(path): 613 walk(path) 614 else: 615 mod = os.stat(path)[stat.ST_MODE] 616 if not (mod & 0100): 617 continue 618 relpath = path[len(self.bundlepath):] 619 self.message("Stripping %s" % relpath, 2) 620 inf, outf = os.popen4("%s -S \"%s\"" % 621 (STRIP_EXEC, path)) 622 output = outf.read().strip() 623 if output: 624 # usually not a real problem, like when we're 625 # trying to strip a script 626 self.message("Problem stripping %s:" % relpath, 3) 627 self.message(output, 3) 628 walk(self.bundlepath) 629 630 def findDependencies(self): 631 self.message("Finding module dependencies", 1) 632 import modulefinder 633 mf = modulefinder.ModuleFinder(excludes=self.excludeModules) 634 if self.use_zipimport: 635 # zipimport imports zlib, must add it manually 636 mf.import_hook("zlib") 637 # manually add our own site.py 638 site = mf.add_module("site") 639 site.__code__ = self._getSiteCode() 640 mf.scan_code(site.__code__, site) 641 642 # warnings.py gets imported implicitly from C 643 mf.import_hook("warnings") 644 645 includeModules = self.includeModules[:] 646 for name in self.includePackages: 647 includeModules.extend(findPackageContents(name).keys()) 648 for name in includeModules: 649 try: 650 mf.import_hook(name) 651 except ImportError: 652 self.missingModules.append(name) 653 654 mf.run_script(self.mainprogram) 655 modules = mf.modules.items() 656 modules.sort() 657 for name, mod in modules: 658 path = mod.__file__ 659 if path and self.semi_standalone: 660 # skip the standard library 661 if path.startswith(LIB) and not path.startswith(SITE_PACKAGES): 662 continue 663 if path and mod.__code__ is None: 664 # C extension 665 filename = os.path.basename(path) 666 pathitems = name.split(".")[:-1] + [filename] 667 dstpath = pathjoin(*pathitems) 668 if self.use_zipimport: 669 if name != "zlib": 670 # neatly pack all extension modules in a subdirectory, 671 # except zlib, since it's necessary for bootstrapping. 672 dstpath = pathjoin("ExtensionModules", dstpath) 673 # Python modules are stored in a Zip archive, but put 674 # extensions in Contents/Resources/. Add a tiny "loader" 675 # program in the Zip archive. Due to Thomas Heller. 676 source = EXT_LOADER % {"name": name, "filename": dstpath} 677 code = compile(source, "<dynloader for %s>" % name, "exec") 678 mod.__code__ = code 679 self.files.append((path, pathjoin("Contents", "Resources", dstpath))) 680 if mod.__code__ is not None: 681 ispkg = mod.__path__ is not None 682 if not self.use_zipimport or name != "site": 683 # Our site.py is doing the bootstrapping, so we must 684 # include a real .pyc file if self.use_zipimport is True. 685 self.pymodules.append((name, mod.__code__, ispkg)) 686 687 if hasattr(mf, "any_missing_maybe"): 688 missing, maybe = mf.any_missing_maybe() 689 else: 690 missing = mf.any_missing() 691 maybe = [] 692 self.missingModules.extend(missing) 693 self.maybeMissingModules.extend(maybe) 694 695 def reportMissing(self): 696 missing = [name for name in self.missingModules 697 if name not in MAYMISS_MODULES] 698 if self.maybeMissingModules: 699 maybe = self.maybeMissingModules 700 else: 701 maybe = [name for name in missing if "." in name] 702 missing = [name for name in missing if "." not in name] 703 missing.sort() 704 maybe.sort() 705 if maybe: 706 self.message("Warning: couldn't find the following submodules:", 1) 707 self.message(" (Note that these could be false alarms -- " 708 "it's not always", 1) 709 self.message(" possible to distinguish between \"from package " 710 "import submodule\" ", 1) 711 self.message(" and \"from package import name\")", 1) 712 for name in maybe: 713 self.message(" ? " + name, 1) 714 if missing: 715 self.message("Warning: couldn't find the following modules:", 1) 716 for name in missing: 717 self.message(" ? " + name, 1) 718 719 def report(self): 720 # XXX something decent 721 import pprint 722 pprint.pprint(self.__dict__) 723 if self.standalone or self.semi_standalone: 724 self.reportMissing() 725 726 # 727 # Utilities. 728 # 729 730 SUFFIXES = [_suf for _suf, _mode, _tp in imp.get_suffixes()] 731 identifierRE = re.compile(r"[_a-zA-z][_a-zA-Z0-9]*$") 732 733 def findPackageContents(name, searchpath=None): 734 head = name.split(".")[-1] 735 if identifierRE.match(head) is None: 736 return {} 737 try: 738 fp, path, (ext, mode, tp) = imp.find_module(head, searchpath) 739 except ImportError: 740 return {} 741 modules = {name: None} 742 if tp == imp.PKG_DIRECTORY and path: 743 files = os.listdir(path) 744 for sub in files: 745 sub, ext = os.path.splitext(sub) 746 fullname = name + "." + sub 747 if sub != "__init__" and fullname not in modules: 748 modules.update(findPackageContents(fullname, [path])) 749 return modules 750 751 def writePyc(code, path): 752 f = open(path, "wb") 753 f.write(MAGIC) 754 f.write("\0" * 4) # don't bother about a time stamp 755 marshal.dump(code, f) 756 f.close() 757 758 def copy(src, dst, mkdirs=0): 759 """Copy a file or a directory.""" 760 if mkdirs: 761 makedirs(os.path.dirname(dst)) 762 if os.path.isdir(src): 763 shutil.copytree(src, dst, symlinks=1) 764 else: 765 shutil.copy2(src, dst) 766 767 def copytodir(src, dstdir): 768 """Copy a file or a directory to an existing directory.""" 769 dst = pathjoin(dstdir, os.path.basename(src)) 770 copy(src, dst) 771 772 def makedirs(dir): 773 """Make all directories leading up to 'dir' including the leaf 774 directory. Don't moan if any path element already exists.""" 775 try: 776 os.makedirs(dir) 777 except OSError, why: 778 if why.errno != errno.EEXIST: 779 raise 780 781 def symlink(src, dst, mkdirs=0): 782 """Copy a file or a directory.""" 783 if not os.path.exists(src): 784 raise IOError, "No such file or directory: '%s'" % src 785 if mkdirs: 786 makedirs(os.path.dirname(dst)) 787 os.symlink(os.path.abspath(src), dst) 788 789 def pathjoin(*args): 790 """Safe wrapper for os.path.join: asserts that all but the first 791 argument are relative paths.""" 792 for seg in args[1:]: 793 assert seg[0] != "/" 794 return os.path.join(*args) 795 796 797 cmdline_doc = """\ 798 Usage: 799 python bundlebuilder.py [options] command 800 python mybuildscript.py [options] command 801 802 Commands: 803 build build the application 804 report print a report 805 806 Options: 807 -b, --builddir=DIR the build directory; defaults to "build" 808 -n, --name=NAME application name 809 -r, --resource=FILE extra file or folder to be copied to Resources 810 -f, --file=SRC:DST extra file or folder to be copied into the bundle; 811 DST must be a path relative to the bundle root 812 -e, --executable=FILE the executable to be used 813 -m, --mainprogram=FILE the Python main program 814 -a, --argv add a wrapper main program to create sys.argv 815 -p, --plist=FILE .plist file (default: generate one) 816 --nib=NAME main nib name 817 -c, --creator=CCCC 4-char creator code (default: '????') 818 --iconfile=FILE filename of the icon (an .icns file) to be used 819 as the Finder icon 820 --bundle-id=ID the CFBundleIdentifier, in reverse-dns format 821 (eg. org.python.BuildApplet; this is used for 822 the preferences file name) 823 -l, --link symlink files/folder instead of copying them 824 --link-exec symlink the executable instead of copying it 825 --standalone build a standalone application, which is fully 826 independent of a Python installation 827 --semi-standalone build a standalone application, which depends on 828 an installed Python, yet includes all third-party 829 modules. 830 --no-zipimport Do not copy code into a zip file 831 --python=FILE Python to use in #! line in stead of current Python 832 --lib=FILE shared library or framework to be copied into 833 the bundle 834 -x, --exclude=MODULE exclude module (with --(semi-)standalone) 835 -i, --include=MODULE include module (with --(semi-)standalone) 836 --package=PACKAGE include a whole package (with --(semi-)standalone) 837 --strip strip binaries (remove debug info) 838 -v, --verbose increase verbosity level 839 -q, --quiet decrease verbosity level 840 -h, --help print this message 841 """ 842 843 def usage(msg=None): 844 if msg: 845 print msg 846 print cmdline_doc 847 sys.exit(1) 848 849 def main(builder=None): 850 if builder is None: 851 builder = AppBuilder(verbosity=1) 852 853 shortopts = "b:n:r:f:e:m:c:p:lx:i:hvqa" 854 longopts = ("builddir=", "name=", "resource=", "file=", "executable=", 855 "mainprogram=", "creator=", "nib=", "plist=", "link", 856 "link-exec", "help", "verbose", "quiet", "argv", "standalone", 857 "exclude=", "include=", "package=", "strip", "iconfile=", 858 "lib=", "python=", "semi-standalone", "bundle-id=", "destroot=" 859 "no-zipimport" 860 ) 861 862 try: 863 options, args = getopt.getopt(sys.argv[1:], shortopts, longopts) 864 except getopt.error: 865 usage() 866 867 for opt, arg in options: 868 if opt in ('-b', '--builddir'): 869 builder.builddir = arg 870 elif opt in ('-n', '--name'): 871 builder.name = arg 872 elif opt in ('-r', '--resource'): 873 builder.resources.append(os.path.normpath(arg)) 874 elif opt in ('-f', '--file'): 875 srcdst = arg.split(':') 876 if len(srcdst) != 2: 877 usage("-f or --file argument must be two paths, " 878 "separated by a colon") 879 builder.files.append(srcdst) 880 elif opt in ('-e', '--executable'): 881 builder.executable = arg 882 elif opt in ('-m', '--mainprogram'): 883 builder.mainprogram = arg 884 elif opt in ('-a', '--argv'): 885 builder.argv_emulation = 1 886 elif opt in ('-c', '--creator'): 887 builder.creator = arg 888 elif opt == '--bundle-id': 889 builder.bundle_id = arg 890 elif opt == '--iconfile': 891 builder.iconfile = arg 892 elif opt == "--lib": 893 builder.libs.append(os.path.normpath(arg)) 894 elif opt == "--nib": 895 builder.nibname = arg 896 elif opt in ('-p', '--plist'): 897 builder.plist = Plist.fromFile(arg) 898 elif opt in ('-l', '--link'): 899 builder.symlink = 1 900 elif opt == '--link-exec': 901 builder.symlink_exec = 1 902 elif opt in ('-h', '--help'): 903 usage() 904 elif opt in ('-v', '--verbose'): 905 builder.verbosity += 1 906 elif opt in ('-q', '--quiet'): 907 builder.verbosity -= 1 908 elif opt == '--standalone': 909 builder.standalone = 1 910 elif opt == '--semi-standalone': 911 builder.semi_standalone = 1 912 elif opt == '--python': 913 builder.python = arg 914 elif opt in ('-x', '--exclude'): 915 builder.excludeModules.append(arg) 916 elif opt in ('-i', '--include'): 917 builder.includeModules.append(arg) 918 elif opt == '--package': 919 builder.includePackages.append(arg) 920 elif opt == '--strip': 921 builder.strip = 1 922 elif opt == '--destroot': 923 builder.destroot = arg 924 elif opt == '--no-zipimport': 925 builder.use_zipimport = False 926 927 if len(args) != 1: 928 usage("Must specify one command ('build', 'report' or 'help')") 929 command = args[0] 930 931 if command == "build": 932 builder.setup() 933 builder.build() 934 elif command == "report": 935 builder.setup() 936 builder.report() 937 elif command == "help": 938 usage() 939 else: 940 usage("Unknown command '%s'" % command) 941 942 943 def buildapp(**kwargs): 944 builder = AppBuilder(**kwargs) 945 main(builder) 946 947 948 if __name__ == "__main__": 949 main() 950
