| #! /usr/bin/env python | |
| """\ | |
| bundlebuilder.py -- Tools to assemble MacOS X (application) bundles. | |
| This module contains two classes to build so called "bundles" for | |
| MacOS X. BundleBuilder is a general tool, AppBuilder is a subclass | |
| specialized in building application bundles. | |
| [Bundle|App]Builder objects are instantiated with a bunch of keyword | |
| arguments, and have a build() method that will do all the work. See | |
| the class doc strings for a description of the constructor arguments. | |
| The module contains a main program that can be used in two ways: | |
| % python bundlebuilder.py [options] build | |
| % python buildapp.py [options] build | |
| Where "buildapp.py" is a user-supplied setup.py-like script following | |
| this model: | |
| from bundlebuilder import buildapp | |
| buildapp(<lots-of-keyword-args>) | |
| """ | |
| __all__ = ["BundleBuilder", "BundleBuilderError", "AppBuilder", "buildapp"] | |
| from warnings import warnpy3k | |
| warnpy3k("In 3.x, the bundlebuilder module is removed.", stacklevel=2) | |
| import sys | |
| import os, errno, shutil | |
| import imp, marshal | |
| import re | |
| from copy import deepcopy | |
| import getopt | |
| from plistlib import Plist | |
| from types import FunctionType as function | |
| class BundleBuilderError(Exception): pass | |
| class Defaults: | |
| """Class attributes that don't start with an underscore and are | |
| not functions or classmethods are (deep)copied to self.__dict__. | |
| This allows for mutable default values. | |
| """ | |
| def __init__(self, **kwargs): | |
| defaults = self._getDefaults() | |
| defaults.update(kwargs) | |
| self.__dict__.update(defaults) | |
| def _getDefaults(cls): | |
| defaults = {} | |
| for base in cls.__bases__: | |
| if hasattr(base, "_getDefaults"): | |
| defaults.update(base._getDefaults()) | |
| for name, value in cls.__dict__.items(): | |
| if name[0] != "_" and not isinstance(value, | |
| (function, classmethod)): | |
| defaults[name] = deepcopy(value) | |
| return defaults | |
| _getDefaults = classmethod(_getDefaults) | |
| class BundleBuilder(Defaults): | |
| """BundleBuilder is a barebones class for assembling bundles. It | |
| knows nothing about executables or icons, it only copies files | |
| and creates the PkgInfo and Info.plist files. | |
| """ | |
| # (Note that Defaults.__init__ (deep)copies these values to | |
| # instance variables. Mutable defaults are therefore safe.) | |
| # Name of the bundle, with or without extension. | |
| name = None | |
| # The property list ("plist") | |
| plist = Plist(CFBundleDevelopmentRegion = "English", | |
| CFBundleInfoDictionaryVersion = "6.0") | |
| # The type of the bundle. | |
| type = "BNDL" | |
| # The creator code of the bundle. | |
| creator = None | |
| # the CFBundleIdentifier (this is used for the preferences file name) | |
| bundle_id = None | |
| # List of files that have to be copied to <bundle>/Contents/Resources. | |
| resources = [] | |
| # List of (src, dest) tuples; dest should be a path relative to the bundle | |
| # (eg. "Contents/Resources/MyStuff/SomeFile.ext). | |
| files = [] | |
| # List of shared libraries (dylibs, Frameworks) to bundle with the app | |
| # will be placed in Contents/Frameworks | |
| libs = [] | |
| # Directory where the bundle will be assembled. | |
| builddir = "build" | |
| # Make symlinks instead copying files. This is handy during debugging, but | |
| # makes the bundle non-distributable. | |
| symlink = 0 | |
| # Verbosity level. | |
| verbosity = 1 | |
| # Destination root directory | |
| destroot = "" | |
| def setup(self): | |
| # XXX rethink self.name munging, this is brittle. | |
| self.name, ext = os.path.splitext(self.name) | |
| if not ext: | |
| ext = ".bundle" | |
| bundleextension = ext | |
| # misc (derived) attributes | |
| self.bundlepath = pathjoin(self.builddir, self.name + bundleextension) | |
| plist = self.plist | |
| plist.CFBundleName = self.name | |
| plist.CFBundlePackageType = self.type | |
| if self.creator is None: | |
| if hasattr(plist, "CFBundleSignature"): | |
| self.creator = plist.CFBundleSignature | |
| else: | |
| self.creator = "????" | |
| plist.CFBundleSignature = self.creator | |
| if self.bundle_id: | |
| plist.CFBundleIdentifier = self.bundle_id | |
| elif not hasattr(plist, "CFBundleIdentifier"): | |
| plist.CFBundleIdentifier = self.name | |
| def build(self): | |
| """Build the bundle.""" | |
| builddir = self.builddir | |
| if builddir and not os.path.exists(builddir): | |
| os.mkdir(builddir) | |
| self.message("Building %s" % repr(self.bundlepath), 1) | |
| if os.path.exists(self.bundlepath): | |
| shutil.rmtree(self.bundlepath) | |
| if os.path.exists(self.bundlepath + '~'): | |
| shutil.rmtree(self.bundlepath + '~') | |
| bp = self.bundlepath | |
| # Create the app bundle in a temporary location and then | |
| # rename the completed bundle. This way the Finder will | |
| # never see an incomplete bundle (where it might pick up | |
| # and cache the wrong meta data) | |
| self.bundlepath = bp + '~' | |
| try: | |
| os.mkdir(self.bundlepath) | |
| self.preProcess() | |
| self._copyFiles() | |
| self._addMetaFiles() | |
| self.postProcess() | |
| os.rename(self.bundlepath, bp) | |
| finally: | |
| self.bundlepath = bp | |
| self.message("Done.", 1) | |
| def preProcess(self): | |
| """Hook for subclasses.""" | |
| pass | |
| def postProcess(self): | |
| """Hook for subclasses.""" | |
| pass | |
| def _addMetaFiles(self): | |
| contents = pathjoin(self.bundlepath, "Contents") | |
| makedirs(contents) | |
| # | |
| # Write Contents/PkgInfo | |
| assert len(self.type) == len(self.creator) == 4, \ | |
| "type and creator must be 4-byte strings." | |
| pkginfo = pathjoin(contents, "PkgInfo") | |
| f = open(pkginfo, "wb") | |
| f.write(self.type + self.creator) | |
| f.close() | |
| # | |
| # Write Contents/Info.plist | |
| infoplist = pathjoin(contents, "Info.plist") | |
| self.plist.write(infoplist) | |
| def _copyFiles(self): | |
| files = self.files[:] | |
| for path in self.resources: | |
| files.append((path, pathjoin("Contents", "Resources", | |
| os.path.basename(path)))) | |
| for path in self.libs: | |
| files.append((path, pathjoin("Contents", "Frameworks", | |
| os.path.basename(path)))) | |
| if self.symlink: | |
| self.message("Making symbolic links", 1) | |
| msg = "Making symlink from" | |
| else: | |
| self.message("Copying files", 1) | |
| msg = "Copying" | |
| files.sort() | |
| for src, dst in files: | |
| if os.path.isdir(src): | |
| self.message("%s %s/ to %s/" % (msg, src, dst), 2) | |
| else: | |
| self.message("%s %s to %s" % (msg, src, dst), 2) | |
| dst = pathjoin(self.bundlepath, dst) | |
| if self.symlink: | |
| symlink(src, dst, mkdirs=1) | |
| else: | |
| copy(src, dst, mkdirs=1) | |
| def message(self, msg, level=0): | |
| if level <= self.verbosity: | |
| indent = "" | |
| if level > 1: | |
| indent = (level - 1) * " " | |
| sys.stderr.write(indent + msg + "\n") | |
| def report(self): | |
| # XXX something decent | |
| pass | |
| if __debug__: | |
| PYC_EXT = ".pyc" | |
| else: | |
| PYC_EXT = ".pyo" | |
| MAGIC = imp.get_magic() | |
| USE_ZIPIMPORT = "zipimport" in sys.builtin_module_names | |
| # For standalone apps, we have our own minimal site.py. We don't need | |
| # all the cruft of the real site.py. | |
| SITE_PY = """\ | |
| import sys | |
| if not %(semi_standalone)s: | |
| del sys.path[1:] # sys.path[0] is Contents/Resources/ | |
| """ | |
| ZIP_ARCHIVE = "Modules.zip" | |
| SITE_PY_ZIP = SITE_PY + ("sys.path.append(sys.path[0] + '/%s')\n" % ZIP_ARCHIVE) | |
| def getPycData(fullname, code, ispkg): | |
| if ispkg: | |
| fullname += ".__init__" | |
| path = fullname.replace(".", os.sep) + PYC_EXT | |
| return path, MAGIC + '\0\0\0\0' + marshal.dumps(code) | |
| # | |
| # Extension modules can't be in the modules zip archive, so a placeholder | |
| # is added instead, that loads the extension from a specified location. | |
| # | |
| EXT_LOADER = """\ | |
| def __load(): | |
| import imp, sys, os | |
| for p in sys.path: | |
| path = os.path.join(p, "%(filename)s") | |
| if os.path.exists(path): | |
| break | |
| else: | |
| assert 0, "file not found: %(filename)s" | |
| mod = imp.load_dynamic("%(name)s", path) | |
| __load() | |
| del __load | |
| """ | |
| MAYMISS_MODULES = ['os2', 'nt', 'ntpath', 'dos', 'dospath', | |
| 'win32api', 'ce', '_winreg', 'nturl2path', 'sitecustomize', | |
| 'org.python.core', 'riscos', 'riscosenviron', 'riscospath' | |
| ] | |
| STRIP_EXEC = "/usr/bin/strip" | |
| # | |
| # We're using a stock interpreter to run the app, yet we need | |
| # a way to pass the Python main program to the interpreter. The | |
| # bootstrapping script fires up the interpreter with the right | |
| # arguments. os.execve() is used as OSX doesn't like us to | |
| # start a real new process. Also, the executable name must match | |
| # the CFBundleExecutable value in the Info.plist, so we lie | |
| # deliberately with argv[0]. The actual Python executable is | |
| # passed in an environment variable so we can "repair" | |
| # sys.executable later. | |
| # | |
| BOOTSTRAP_SCRIPT = """\ | |
| #!%(hashbang)s | |
| import sys, os | |
| execdir = os.path.dirname(sys.argv[0]) | |
| executable = os.path.join(execdir, "%(executable)s") | |
| resdir = os.path.join(os.path.dirname(execdir), "Resources") | |
| libdir = os.path.join(os.path.dirname(execdir), "Frameworks") | |
| mainprogram = os.path.join(resdir, "%(mainprogram)s") | |
| if %(optimize)s: | |
| sys.argv.insert(1, '-O') | |
| sys.argv.insert(1, mainprogram) | |
| if %(standalone)s or %(semi_standalone)s: | |
| os.environ["PYTHONPATH"] = resdir | |
| if %(standalone)s: | |
| os.environ["PYTHONHOME"] = resdir | |
| else: | |
| pypath = os.getenv("PYTHONPATH", "") | |
| if pypath: | |
| pypath = ":" + pypath | |
| os.environ["PYTHONPATH"] = resdir + pypath | |
| os.environ["PYTHONEXECUTABLE"] = executable | |
| os.environ["DYLD_LIBRARY_PATH"] = libdir | |
| os.environ["DYLD_FRAMEWORK_PATH"] = libdir | |
| os.execve(executable, sys.argv, os.environ) | |
| """ | |
| # | |
| # Optional wrapper that converts "dropped files" into sys.argv values. | |
| # | |
| ARGV_EMULATOR = """\ | |
| import argvemulator, os | |
| argvemulator.ArgvCollector().mainloop() | |
| execfile(os.path.join(os.path.split(__file__)[0], "%(realmainprogram)s")) | |
| """ | |
| # | |
| # When building a standalone app with Python.framework, we need to copy | |
| # a subset from Python.framework to the bundle. The following list | |
| # specifies exactly what items we'll copy. | |
| # | |
| PYTHONFRAMEWORKGOODIES = [ | |
| "Python", # the Python core library | |
| "Resources/English.lproj", | |
| "Resources/Info.plist", | |
| ] | |
| def isFramework(): | |
| return sys.exec_prefix.find("Python.framework") > 0 | |
| LIB = os.path.join(sys.prefix, "lib", "python" + sys.version[:3]) | |
| SITE_PACKAGES = os.path.join(LIB, "site-packages") | |
| class AppBuilder(BundleBuilder): | |
| use_zipimport = USE_ZIPIMPORT | |
| # Override type of the bundle. | |
| type = "APPL" | |
| # platform, name of the subfolder of Contents that contains the executable. | |
| platform = "MacOS" | |
| # A Python main program. If this argument is given, the main | |
| # executable in the bundle will be a small wrapper that invokes | |
| # the main program. (XXX Discuss why.) | |
| mainprogram = None | |
| # The main executable. If a Python main program is specified | |
| # the executable will be copied to Resources and be invoked | |
| # by the wrapper program mentioned above. Otherwise it will | |
| # simply be used as the main executable. | |
| executable = None | |
| # The name of the main nib, for Cocoa apps. *Must* be specified | |
| # when building a Cocoa app. | |
| nibname = None | |
| # The name of the icon file to be copied to Resources and used for | |
| # the Finder icon. | |
| iconfile = None | |
| # Symlink the executable instead of copying it. | |
| symlink_exec = 0 | |
| # If True, build standalone app. | |
| standalone = 0 | |
| # If True, build semi-standalone app (only includes third-party modules). | |
| semi_standalone = 0 | |
| # If set, use this for #! lines in stead of sys.executable | |
| python = None | |
| # If True, add a real main program that emulates sys.argv before calling | |
| # mainprogram | |
| argv_emulation = 0 | |
| # The following attributes are only used when building a standalone app. | |
| # Exclude these modules. | |
| excludeModules = [] | |
| # Include these modules. | |
| includeModules = [] | |
| # Include these packages. | |
| includePackages = [] | |
| # Strip binaries from debug info. | |
| strip = 0 | |
| # Found Python modules: [(name, codeobject, ispkg), ...] | |
| pymodules = [] | |
| # Modules that modulefinder couldn't find: | |
| missingModules = [] | |
| maybeMissingModules = [] | |
| def setup(self): | |
| if ((self.standalone or self.semi_standalone) | |
| and self.mainprogram is None): | |
| raise BundleBuilderError, ("must specify 'mainprogram' when " | |
| "building a standalone application.") | |
| if self.mainprogram is None and self.executable is None: | |
| raise BundleBuilderError, ("must specify either or both of " | |
| "'executable' and 'mainprogram'") | |
| self.execdir = pathjoin("Contents", self.platform) | |
| if self.name is not None: | |
| pass | |
| elif self.mainprogram is not None: | |
| self.name = os.path.splitext(os.path.basename(self.mainprogram))[0] | |
| elif self.executable is not None: | |
| self.name = os.path.splitext(os.path.basename(self.executable))[0] | |
| if self.name[-4:] != ".app": | |
| self.name += ".app" | |
| if self.executable is None: | |
| if not self.standalone and not isFramework(): | |
| self.symlink_exec = 1 | |
| if self.python: | |
| self.executable = self.python | |
| else: | |
| self.executable = sys.executable | |
| if self.nibname: | |
| self.plist.NSMainNibFile = self.nibname | |
| if not hasattr(self.plist, "NSPrincipalClass"): | |
| self.plist.NSPrincipalClass = "NSApplication" | |
| if self.standalone and isFramework(): | |
| self.addPythonFramework() | |
| BundleBuilder.setup(self) | |
| self.plist.CFBundleExecutable = self.name | |
| if self.standalone or self.semi_standalone: | |
| self.findDependencies() | |
| def preProcess(self): | |
| resdir = "Contents/Resources" | |
| if self.executable is not None: | |
| if self.mainprogram is None: | |
| execname = self.name | |
| else: | |
| execname = os.path.basename(self.executable) | |
| execpath = pathjoin(self.execdir, execname) | |
| if not self.symlink_exec: | |
| self.files.append((self.destroot + self.executable, execpath)) | |
| self.execpath = execpath | |
| if self.mainprogram is not None: | |
| mainprogram = os.path.basename(self.mainprogram) | |
| self.files.append((self.mainprogram, pathjoin(resdir, mainprogram))) | |
| if self.argv_emulation: | |
| # Change the main program, and create the helper main program (which | |
| # does argv collection and then calls the real main). | |
| # Also update the included modules (if we're creating a standalone | |
| # program) and the plist | |
| realmainprogram = mainprogram | |
| mainprogram = '__argvemulator_' + mainprogram | |
| resdirpath = pathjoin(self.bundlepath, resdir) | |
| mainprogrampath = pathjoin(resdirpath, mainprogram) | |
| makedirs(resdirpath) | |
| open(mainprogrampath, "w").write(ARGV_EMULATOR % locals()) | |
| if self.standalone or self.semi_standalone: | |
| self.includeModules.append("argvemulator") | |
| self.includeModules.append("os") | |
| if "CFBundleDocumentTypes" not in self.plist: | |
| self.plist["CFBundleDocumentTypes"] = [ | |
| { "CFBundleTypeOSTypes" : [ | |
| "****", | |
| "fold", | |
| "disk"], | |
| "CFBundleTypeRole": "Viewer"}] | |
| # Write bootstrap script | |
| executable = os.path.basename(self.executable) | |
| execdir = pathjoin(self.bundlepath, self.execdir) | |
| bootstrappath = pathjoin(execdir, self.name) | |
| makedirs(execdir) | |
| if self.standalone or self.semi_standalone: | |
| # XXX we're screwed when the end user has deleted | |
| # /usr/bin/python | |
| hashbang = "/usr/bin/python" | |
| elif self.python: | |
| hashbang = self.python | |
| else: | |
| hashbang = os.path.realpath(sys.executable) | |
| standalone = self.standalone | |
| semi_standalone = self.semi_standalone | |
| optimize = sys.flags.optimize | |
| open(bootstrappath, "w").write(BOOTSTRAP_SCRIPT % locals()) | |
| os.chmod(bootstrappath, 0775) | |
| if self.iconfile is not None: | |
| iconbase = os.path.basename(self.iconfile) | |
| self.plist.CFBundleIconFile = iconbase | |
| self.files.append((self.iconfile, pathjoin(resdir, iconbase))) | |
| def postProcess(self): | |
| if self.standalone or self.semi_standalone: | |
| self.addPythonModules() | |
| if self.strip and not self.symlink: | |
| self.stripBinaries() | |
| if self.symlink_exec and self.executable: | |
| self.message("Symlinking executable %s to %s" % (self.executable, | |
| self.execpath), 2) | |
| dst = pathjoin(self.bundlepath, self.execpath) | |
| makedirs(os.path.dirname(dst)) | |
| os.symlink(os.path.abspath(self.executable), dst) | |
| if self.missingModules or self.maybeMissingModules: | |
| self.reportMissing() | |
| def addPythonFramework(self): | |
| # If we're building a standalone app with Python.framework, | |
| # include a minimal subset of Python.framework, *unless* | |
| # Python.framework was specified manually in self.libs. | |
| for lib in self.libs: | |
| if os.path.basename(lib) == "Python.framework": | |
| # a Python.framework was specified as a library | |
| return | |
| frameworkpath = sys.exec_prefix[:sys.exec_prefix.find( | |
| "Python.framework") + len("Python.framework")] | |
| version = sys.version[:3] | |
| frameworkpath = pathjoin(frameworkpath, "Versions", version) | |
| destbase = pathjoin("Contents", "Frameworks", "Python.framework", | |
| "Versions", version) | |
| for item in PYTHONFRAMEWORKGOODIES: | |
| src = pathjoin(frameworkpath, item) | |
| dst = pathjoin(destbase, item) | |
| self.files.append((src, dst)) | |
| def _getSiteCode(self): | |
| if self.use_zipimport: | |
| return compile(SITE_PY % {"semi_standalone": self.semi_standalone}, | |
| "<-bundlebuilder.py->", "exec") | |
| def addPythonModules(self): | |
| self.message("Adding Python modules", 1) | |
| if self.use_zipimport: | |
| # Create a zip file containing all modules as pyc. | |
| import zipfile | |
| relpath = pathjoin("Contents", "Resources", ZIP_ARCHIVE) | |
| abspath = pathjoin(self.bundlepath, relpath) | |
| zf = zipfile.ZipFile(abspath, "w", zipfile.ZIP_DEFLATED) | |
| for name, code, ispkg in self.pymodules: | |
| self.message("Adding Python module %s" % name, 2) | |
| path, pyc = getPycData(name, code, ispkg) | |
| zf.writestr(path, pyc) | |
| zf.close() | |
| # add site.pyc | |
| sitepath = pathjoin(self.bundlepath, "Contents", "Resources", | |
| "site" + PYC_EXT) | |
| writePyc(self._getSiteCode(), sitepath) | |
| else: | |
| # Create individual .pyc files. | |
| for name, code, ispkg in self.pymodules: | |
| if ispkg: | |
| name += ".__init__" | |
| path = name.split(".") | |
| path = pathjoin("Contents", "Resources", *path) + PYC_EXT | |
| if ispkg: | |
| self.message("Adding Python package %s" % path, 2) | |
| else: | |
| self.message("Adding Python module %s" % path, 2) | |
| abspath = pathjoin(self.bundlepath, path) | |
| makedirs(os.path.dirname(abspath)) | |
| writePyc(code, abspath) | |
| def stripBinaries(self): | |
| if not os.path.exists(STRIP_EXEC): | |
| self.message("Error: can't strip binaries: no strip program at " | |
| "%s" % STRIP_EXEC, 0) | |
| else: | |
| import stat | |
| self.message("Stripping binaries", 1) | |
| def walk(top): | |
| for name in os.listdir(top): | |
| path = pathjoin(top, name) | |
| if os.path.islink(path): | |
| continue | |
| if os.path.isdir(path): | |
| walk(path) | |
| else: | |
| mod = os.stat(path)[stat.ST_MODE] | |
| if not (mod & 0100): | |
| continue | |
| relpath = path[len(self.bundlepath):] | |
| self.message("Stripping %s" % relpath, 2) | |
| inf, outf = os.popen4("%s -S \"%s\"" % | |
| (STRIP_EXEC, path)) | |
| output = outf.read().strip() | |
| if output: | |
| # usually not a real problem, like when we're | |
| # trying to strip a script | |
| self.message("Problem stripping %s:" % relpath, 3) | |
| self.message(output, 3) | |
| walk(self.bundlepath) | |
| def findDependencies(self): | |
| self.message("Finding module dependencies", 1) | |
| import modulefinder | |
| mf = modulefinder.ModuleFinder(excludes=self.excludeModules) | |
| if self.use_zipimport: | |
| # zipimport imports zlib, must add it manually | |
| mf.import_hook("zlib") | |
| # manually add our own site.py | |
| site = mf.add_module("site") | |
| site.__code__ = self._getSiteCode() | |
| mf.scan_code(site.__code__, site) | |
| # warnings.py gets imported implicitly from C | |
| mf.import_hook("warnings") | |
| includeModules = self.includeModules[:] | |
| for name in self.includePackages: | |
| includeModules.extend(findPackageContents(name).keys()) | |
| for name in includeModules: | |
| try: | |
| mf.import_hook(name) | |
| except ImportError: | |
| self.missingModules.append(name) | |
| mf.run_script(self.mainprogram) | |
| modules = mf.modules.items() | |
| modules.sort() | |
| for name, mod in modules: | |
| path = mod.__file__ | |
| if path and self.semi_standalone: | |
| # skip the standard library | |
| if path.startswith(LIB) and not path.startswith(SITE_PACKAGES): | |
| continue | |
| if path and mod.__code__ is None: | |
| # C extension | |
| filename = os.path.basename(path) | |
| pathitems = name.split(".")[:-1] + [filename] | |
| dstpath = pathjoin(*pathitems) | |
| if self.use_zipimport: | |
| if name != "zlib": | |
| # neatly pack all extension modules in a subdirectory, | |
| # except zlib, since it's necessary for bootstrapping. | |
| dstpath = pathjoin("ExtensionModules", dstpath) | |
| # Python modules are stored in a Zip archive, but put | |
| # extensions in Contents/Resources/. Add a tiny "loader" | |
| # program in the Zip archive. Due to Thomas Heller. | |
| source = EXT_LOADER % {"name": name, "filename": dstpath} | |
| code = compile(source, "<dynloader for %s>" % name, "exec") | |
| mod.__code__ = code | |
| self.files.append((path, pathjoin("Contents", "Resources", dstpath))) | |
| if mod.__code__ is not None: | |
| ispkg = mod.__path__ is not None | |
| if not self.use_zipimport or name != "site": | |
| # Our site.py is doing the bootstrapping, so we must | |
| # include a real .pyc file if self.use_zipimport is True. | |
| self.pymodules.append((name, mod.__code__, ispkg)) | |
| if hasattr(mf, "any_missing_maybe"): | |
| missing, maybe = mf.any_missing_maybe() | |
| else: | |
| missing = mf.any_missing() | |
| maybe = [] | |
| self.missingModules.extend(missing) | |
| self.maybeMissingModules.extend(maybe) | |
| def reportMissing(self): | |
| missing = [name for name in self.missingModules | |
| if name not in MAYMISS_MODULES] | |
| if self.maybeMissingModules: | |
| maybe = self.maybeMissingModules | |
| else: | |
| maybe = [name for name in missing if "." in name] | |
| missing = [name for name in missing if "." not in name] | |
| missing.sort() | |
| maybe.sort() | |
| if maybe: | |
| self.message("Warning: couldn't find the following submodules:", 1) | |
| self.message(" (Note that these could be false alarms -- " | |
| "it's not always", 1) | |
| self.message(" possible to distinguish between \"from package " | |
| "import submodule\" ", 1) | |
| self.message(" and \"from package import name\")", 1) | |
| for name in maybe: | |
| self.message(" ? " + name, 1) | |
| if missing: | |
| self.message("Warning: couldn't find the following modules:", 1) | |
| for name in missing: | |
| self.message(" ? " + name, 1) | |
| def report(self): | |
| # XXX something decent | |
| import pprint | |
| pprint.pprint(self.__dict__) | |
| if self.standalone or self.semi_standalone: | |
| self.reportMissing() | |
| # | |
| # Utilities. | |
| # | |
| SUFFIXES = [_suf for _suf, _mode, _tp in imp.get_suffixes()] | |
| identifierRE = re.compile(r"[_a-zA-z][_a-zA-Z0-9]*$") | |
| def findPackageContents(name, searchpath=None): | |
| head = name.split(".")[-1] | |
| if identifierRE.match(head) is None: | |
| return {} | |
| try: | |
| fp, path, (ext, mode, tp) = imp.find_module(head, searchpath) | |
| except ImportError: | |
| return {} | |
| modules = {name: None} | |
| if tp == imp.PKG_DIRECTORY and path: | |
| files = os.listdir(path) | |
| for sub in files: | |
| sub, ext = os.path.splitext(sub) | |
| fullname = name + "." + sub | |
| if sub != "__init__" and fullname not in modules: | |
| modules.update(findPackageContents(fullname, [path])) | |
| return modules | |
| def writePyc(code, path): | |
| f = open(path, "wb") | |
| f.write(MAGIC) | |
| f.write("\0" * 4) # don't bother about a time stamp | |
| marshal.dump(code, f) | |
| f.close() | |
| def copy(src, dst, mkdirs=0): | |
| """Copy a file or a directory.""" | |
| if mkdirs: | |
| makedirs(os.path.dirname(dst)) | |
| if os.path.isdir(src): | |
| shutil.copytree(src, dst, symlinks=1) | |
| else: | |
| shutil.copy2(src, dst) | |
| def copytodir(src, dstdir): | |
| """Copy a file or a directory to an existing directory.""" | |
| dst = pathjoin(dstdir, os.path.basename(src)) | |
| copy(src, dst) | |
| def makedirs(dir): | |
| """Make all directories leading up to 'dir' including the leaf | |
| directory. Don't moan if any path element already exists.""" | |
| try: | |
| os.makedirs(dir) | |
| except OSError, why: | |
| if why.errno != errno.EEXIST: | |
| raise | |
| def symlink(src, dst, mkdirs=0): | |
| """Copy a file or a directory.""" | |
| if not os.path.exists(src): | |
| raise IOError, "No such file or directory: '%s'" % src | |
| if mkdirs: | |
| makedirs(os.path.dirname(dst)) | |
| os.symlink(os.path.abspath(src), dst) | |
| def pathjoin(*args): | |
| """Safe wrapper for os.path.join: asserts that all but the first | |
| argument are relative paths.""" | |
| for seg in args[1:]: | |
| assert seg[0] != "/" | |
| return os.path.join(*args) | |
| cmdline_doc = """\ | |
| Usage: | |
| python bundlebuilder.py [options] command | |
| python mybuildscript.py [options] command | |
| Commands: | |
| build build the application | |
| report print a report | |
| Options: | |
| -b, --builddir=DIR the build directory; defaults to "build" | |
| -n, --name=NAME application name | |
| -r, --resource=FILE extra file or folder to be copied to Resources | |
| -f, --file=SRC:DST extra file or folder to be copied into the bundle; | |
| DST must be a path relative to the bundle root | |
| -e, --executable=FILE the executable to be used | |
| -m, --mainprogram=FILE the Python main program | |
| -a, --argv add a wrapper main program to create sys.argv | |
| -p, --plist=FILE .plist file (default: generate one) | |
| --nib=NAME main nib name | |
| -c, --creator=CCCC 4-char creator code (default: '????') | |
| --iconfile=FILE filename of the icon (an .icns file) to be used | |
| as the Finder icon | |
| --bundle-id=ID the CFBundleIdentifier, in reverse-dns format | |
| (eg. org.python.BuildApplet; this is used for | |
| the preferences file name) | |
| -l, --link symlink files/folder instead of copying them | |
| --link-exec symlink the executable instead of copying it | |
| --standalone build a standalone application, which is fully | |
| independent of a Python installation | |
| --semi-standalone build a standalone application, which depends on | |
| an installed Python, yet includes all third-party | |
| modules. | |
| --no-zipimport Do not copy code into a zip file | |
| --python=FILE Python to use in #! line in stead of current Python | |
| --lib=FILE shared library or framework to be copied into | |
| the bundle | |
| -x, --exclude=MODULE exclude module (with --(semi-)standalone) | |
| -i, --include=MODULE include module (with --(semi-)standalone) | |
| --package=PACKAGE include a whole package (with --(semi-)standalone) | |
| --strip strip binaries (remove debug info) | |
| -v, --verbose increase verbosity level | |
| -q, --quiet decrease verbosity level | |
| -h, --help print this message | |
| """ | |
| def usage(msg=None): | |
| if msg: | |
| print msg | |
| print cmdline_doc | |
| sys.exit(1) | |
| def main(builder=None): | |
| if builder is None: | |
| builder = AppBuilder(verbosity=1) | |
| shortopts = "b:n:r:f:e:m:c:p:lx:i:hvqa" | |
| longopts = ("builddir=", "name=", "resource=", "file=", "executable=", | |
| "mainprogram=", "creator=", "nib=", "plist=", "link", | |
| "link-exec", "help", "verbose", "quiet", "argv", "standalone", | |
| "exclude=", "include=", "package=", "strip", "iconfile=", | |
| "lib=", "python=", "semi-standalone", "bundle-id=", "destroot=" | |
| "no-zipimport" | |
| ) | |
| try: | |
| options, args = getopt.getopt(sys.argv[1:], shortopts, longopts) | |
| except getopt.error: | |
| usage() | |
| for opt, arg in options: | |
| if opt in ('-b', '--builddir'): | |
| builder.builddir = arg | |
| elif opt in ('-n', '--name'): | |
| builder.name = arg | |
| elif opt in ('-r', '--resource'): | |
| builder.resources.append(os.path.normpath(arg)) | |
| elif opt in ('-f', '--file'): | |
| srcdst = arg.split(':') | |
| if len(srcdst) != 2: | |
| usage("-f or --file argument must be two paths, " | |
| "separated by a colon") | |
| builder.files.append(srcdst) | |
| elif opt in ('-e', '--executable'): | |
| builder.executable = arg | |
| elif opt in ('-m', '--mainprogram'): | |
| builder.mainprogram = arg | |
| elif opt in ('-a', '--argv'): | |
| builder.argv_emulation = 1 | |
| elif opt in ('-c', '--creator'): | |
| builder.creator = arg | |
| elif opt == '--bundle-id': | |
| builder.bundle_id = arg | |
| elif opt == '--iconfile': | |
| builder.iconfile = arg | |
| elif opt == "--lib": | |
| builder.libs.append(os.path.normpath(arg)) | |
| elif opt == "--nib": | |
| builder.nibname = arg | |
| elif opt in ('-p', '--plist'): | |
| builder.plist = Plist.fromFile(arg) | |
| elif opt in ('-l', '--link'): | |
| builder.symlink = 1 | |
| elif opt == '--link-exec': | |
| builder.symlink_exec = 1 | |
| elif opt in ('-h', '--help'): | |
| usage() | |
| elif opt in ('-v', '--verbose'): | |
| builder.verbosity += 1 | |
| elif opt in ('-q', '--quiet'): | |
| builder.verbosity -= 1 | |
| elif opt == '--standalone': | |
| builder.standalone = 1 | |
| elif opt == '--semi-standalone': | |
| builder.semi_standalone = 1 | |
| elif opt == '--python': | |
| builder.python = arg | |
| elif opt in ('-x', '--exclude'): | |
| builder.excludeModules.append(arg) | |
| elif opt in ('-i', '--include'): | |
| builder.includeModules.append(arg) | |
| elif opt == '--package': | |
| builder.includePackages.append(arg) | |
| elif opt == '--strip': | |
| builder.strip = 1 | |
| elif opt == '--destroot': | |
| builder.destroot = arg | |
| elif opt == '--no-zipimport': | |
| builder.use_zipimport = False | |
| if len(args) != 1: | |
| usage("Must specify one command ('build', 'report' or 'help')") | |
| command = args[0] | |
| if command == "build": | |
| builder.setup() | |
| builder.build() | |
| elif command == "report": | |
| builder.setup() | |
| builder.report() | |
| elif command == "help": | |
| usage() | |
| else: | |
| usage("Unknown command '%s'" % command) | |
| def buildapp(**kwargs): | |
| builder = AppBuilder(**kwargs) | |
| main(builder) | |
| if __name__ == "__main__": | |
| main() |