mirror of https://github.com/python/cpython
938 lines
33 KiB
Python
Executable File
938 lines
33 KiB
Python
Executable File
#! /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.")
|
|
|
|
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/
|
|
"""
|
|
|
|
if USE_ZIPIMPORT:
|
|
ZIP_ARCHIVE = "Modules.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 = ['mac', '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")
|
|
|
|
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",
|
|
"Resources/version.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):
|
|
|
|
# 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 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 not self.plist.has_key("CFBundleDocumentTypes"):
|
|
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
|
|
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):
|
|
return compile(SITE_PY % {"semi_standalone": self.semi_standalone},
|
|
"<-bundlebuilder.py->", "exec")
|
|
|
|
def addPythonModules(self):
|
|
self.message("Adding Python modules", 1)
|
|
|
|
if 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 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 USE_ZIPIMPORT:
|
|
if name != "zlib":
|
|
# neatly pack all extension modules in a subdirectory,
|
|
# except zlib, since it's neccesary 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 USE_ZIPIMPORT or name != "site":
|
|
# Our site.py is doing the bootstrapping, so we must
|
|
# include a real .pyc file if 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.
|
|
--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=")
|
|
|
|
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
|
|
|
|
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()
|