From 25335618bf8755ce6b116ee14f47f5a1f2c821e9 Mon Sep 17 00:00:00 2001 From: Lorry Date: Wed, 22 Aug 2012 15:47:16 +0100 Subject: Tarball conversion --- setup.py | 780 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 780 insertions(+) create mode 100755 setup.py (limited to 'setup.py') diff --git a/setup.py b/setup.py new file mode 100755 index 0000000..a21ebe8 --- /dev/null +++ b/setup.py @@ -0,0 +1,780 @@ +#! /usr/bin/env python + +"""Installation script for bzr. +Run it with + './setup.py install', or + './setup.py --help' for more options +""" + +import os +import os.path +import sys +import copy +import glob + +if sys.version_info < (2, 6): + sys.stderr.write("[ERROR] Not a supported Python version. Need 2.6+\n") + sys.exit(1) + +# NOTE: The directory containing setup.py, whether run by 'python setup.py' or +# './setup.py' or the equivalent with another path, should always be at the +# start of the path, so this should find the right one... +import bzrlib + +def get_long_description(): + dirname = os.path.dirname(__file__) + readme = os.path.join(dirname, 'README') + f = open(readme, 'rb') + try: + return f.read() + finally: + f.close() + + +## +# META INFORMATION FOR SETUP +# see http://docs.python.org/dist/meta-data.html +META_INFO = { + 'name': 'bzr', + 'version': bzrlib.__version__, + 'author': 'Canonical Ltd', + 'author_email': 'bazaar@lists.canonical.com', + 'url': 'http://bazaar.canonical.com/', + 'description': 'Friendly distributed version control system', + 'license': 'GNU GPL v2', + 'download_url': 'https://launchpad.net/bzr/+download', + 'long_description': get_long_description(), + 'classifiers': [ + 'Development Status :: 6 - Mature', + 'Environment :: Console', + 'Intended Audience :: Developers', + 'Intended Audience :: System Administrators', + 'License :: OSI Approved :: GNU General Public License (GPL)', + 'Operating System :: Microsoft :: Windows', + 'Operating System :: OS Independent', + 'Operating System :: POSIX', + 'Programming Language :: Python', + 'Programming Language :: C', + 'Topic :: Software Development :: Version Control', + ], + } + +# The list of packages is automatically generated later. Add other things +# that are part of BZRLIB here. +BZRLIB = {} + +PKG_DATA = {# install files from selftest suite + 'package_data': {'bzrlib': ['doc/api/*.txt', + 'tests/test_patches_data/*', + 'help_topics/en/*.txt', + 'tests/ssl_certs/ca.crt', + 'tests/ssl_certs/server_without_pass.key', + 'tests/ssl_certs/server_with_pass.key', + 'tests/ssl_certs/server.crt', + ]}, + } +I18N_FILES = [] +for filepath in glob.glob("bzrlib/locale/*/LC_MESSAGES/*.mo"): + langfile = filepath[len("bzrlib/locale/"):] + targetpath = os.path.dirname(os.path.join("share/locale", langfile)) + I18N_FILES.append((targetpath, [filepath])) + +def get_bzrlib_packages(): + """Recurse through the bzrlib directory, and extract the package names""" + + packages = [] + base_path = os.path.dirname(os.path.abspath(bzrlib.__file__)) + for root, dirs, files in os.walk(base_path): + if '__init__.py' in files: + assert root.startswith(base_path) + # Get just the path below bzrlib + package_path = root[len(base_path):] + # Remove leading and trailing slashes + package_path = package_path.strip('\\/') + if not package_path: + package_name = 'bzrlib' + else: + package_name = ('bzrlib.' + + package_path.replace('/', '.').replace('\\', '.')) + packages.append(package_name) + return sorted(packages) + + +BZRLIB['packages'] = get_bzrlib_packages() + + +from distutils import log +from distutils.core import setup +from distutils.command.install_scripts import install_scripts +from distutils.command.install_data import install_data +from distutils.command.build import build + +############################### +# Overridden distutils actions +############################### + +class my_install_scripts(install_scripts): + """ Customized install_scripts distutils action. + Create bzr.bat for win32. + """ + def run(self): + install_scripts.run(self) # standard action + + if sys.platform == "win32": + try: + scripts_dir = os.path.join(sys.prefix, 'Scripts') + script_path = self._quoted_path(os.path.join(scripts_dir, + "bzr")) + python_exe = self._quoted_path(sys.executable) + args = self._win_batch_args() + batch_str = "@%s %s %s" % (python_exe, script_path, args) + batch_path = os.path.join(self.install_dir, "bzr.bat") + f = file(batch_path, "w") + f.write(batch_str) + f.close() + print("Created: %s" % batch_path) + except Exception: + e = sys.exc_info()[1] + print("ERROR: Unable to create %s: %s" % (batch_path, e)) + + def _quoted_path(self, path): + if ' ' in path: + return '"' + path + '"' + else: + return path + + def _win_batch_args(self): + from bzrlib.win32utils import winver + if winver == 'Windows NT': + return '%*' + else: + return '%1 %2 %3 %4 %5 %6 %7 %8 %9' +#/class my_install_scripts + + +class bzr_build(build): + """Customized build distutils action. + Generate bzr.1. + """ + + sub_commands = build.sub_commands + [ + ('build_mo', lambda _: True), + ] + + def run(self): + build.run(self) + + from tools import generate_docs + generate_docs.main(argv=["bzr", "man"]) + + +######################## +## Setup +######################## + +from bzrlib.bzr_distutils import build_mo + +command_classes = {'install_scripts': my_install_scripts, + 'build': bzr_build, + 'build_mo': build_mo, + } +from distutils import log +from distutils.errors import CCompilerError, DistutilsPlatformError +from distutils.extension import Extension +ext_modules = [] +try: + try: + from Cython.Distutils import build_ext + from Cython.Compiler.Version import version as pyrex_version + except ImportError: + print("No Cython, trying Pyrex...") + from Pyrex.Distutils import build_ext + from Pyrex.Compiler.Version import version as pyrex_version +except ImportError: + have_pyrex = False + # try to build the extension from the prior generated source. + print("") + print("The python package 'Pyrex' is not available." + " If the .c files are available,") + print("they will be built," + " but modifying the .pyx files will not rebuild them.") + print("") + from distutils.command.build_ext import build_ext +else: + have_pyrex = True + pyrex_version_info = tuple(map(int, pyrex_version.rstrip("+").split('.'))) + + +class build_ext_if_possible(build_ext): + + user_options = build_ext.user_options + [ + ('allow-python-fallback', None, + "When an extension cannot be built, allow falling" + " back to the pure-python implementation.") + ] + + def initialize_options(self): + build_ext.initialize_options(self) + self.allow_python_fallback = False + + def run(self): + try: + build_ext.run(self) + except DistutilsPlatformError: + e = sys.exc_info()[1] + if not self.allow_python_fallback: + log.warn('\n Cannot build extensions.\n' + ' Use "build_ext --allow-python-fallback" to use' + ' slower python implementations instead.\n') + raise + log.warn(str(e)) + log.warn('\n Extensions cannot be built.\n' + ' Using the slower Python implementations instead.\n') + + def build_extension(self, ext): + try: + build_ext.build_extension(self, ext) + except CCompilerError: + if not self.allow_python_fallback: + log.warn('\n Cannot build extension "%s".\n' + ' Use "build_ext --allow-python-fallback" to use' + ' slower python implementations instead.\n' + % (ext.name,)) + raise + log.warn('\n Building of "%s" extension failed.\n' + ' Using the slower Python implementation instead.' + % (ext.name,)) + + +# Override the build_ext if we have Pyrex available +command_classes['build_ext'] = build_ext_if_possible +unavailable_files = [] + + +def add_pyrex_extension(module_name, libraries=None, extra_source=[]): + """Add a pyrex module to build. + + This will use Pyrex to auto-generate the .c file if it is available. + Otherwise it will fall back on the .c file. If the .c file is not + available, it will warn, and not add anything. + + You can pass any extra options to Extension through kwargs. One example is + 'libraries = []'. + + :param module_name: The python path to the module. This will be used to + determine the .pyx and .c files to use. + """ + path = module_name.replace('.', '/') + pyrex_name = path + '.pyx' + c_name = path + '.c' + define_macros = [] + if sys.platform == 'win32': + # pyrex uses the macro WIN32 to detect the platform, even though it + # should be using something like _WIN32 or MS_WINDOWS, oh well, we can + # give it the right value. + define_macros.append(('WIN32', None)) + if have_pyrex: + source = [pyrex_name] + else: + if not os.path.isfile(c_name): + unavailable_files.append(c_name) + return + else: + source = [c_name] + source.extend(extra_source) + ext_modules.append(Extension(module_name, source, + define_macros=define_macros, libraries=libraries)) + + +add_pyrex_extension('bzrlib._annotator_pyx') +add_pyrex_extension('bzrlib._bencode_pyx') +add_pyrex_extension('bzrlib._chunks_to_lines_pyx') +add_pyrex_extension('bzrlib._groupcompress_pyx', + extra_source=['bzrlib/diff-delta.c']) +add_pyrex_extension('bzrlib._knit_load_data_pyx') +add_pyrex_extension('bzrlib._known_graph_pyx') +add_pyrex_extension('bzrlib._rio_pyx') +if sys.platform == 'win32': + add_pyrex_extension('bzrlib._dirstate_helpers_pyx', + libraries=['Ws2_32']) + add_pyrex_extension('bzrlib._walkdirs_win32') +else: + if have_pyrex and pyrex_version_info[:3] == (0,9,4): + # Pyrex 0.9.4.1 fails to compile this extension correctly + # The code it generates re-uses a "local" pointer and + # calls "PY_DECREF" after having set it to NULL. (It mixes PY_XDECREF + # which is NULL safe with PY_DECREF which is not.) + # + # + print('Cannot build extension "bzrlib._dirstate_helpers_pyx" using') + print('your version of pyrex "%s". Please upgrade your pyrex' + % (pyrex_version,)) + print('install. For now, the non-compiled (python) version will') + print('be used instead.') + else: + add_pyrex_extension('bzrlib._dirstate_helpers_pyx') + add_pyrex_extension('bzrlib._readdir_pyx') +add_pyrex_extension('bzrlib._chk_map_pyx') +ext_modules.append(Extension('bzrlib._patiencediff_c', + ['bzrlib/_patiencediff_c.c'])) +if have_pyrex and pyrex_version_info < (0, 9, 6, 3): + print("") + print('Your Pyrex/Cython version %s is too old to build the simple_set' % ( + pyrex_version)) + print('and static_tuple extensions.') + print('Please upgrade to at least Pyrex 0.9.6.3') + print("") + # TODO: Should this be a fatal error? +else: + # We only need 0.9.6.3 to build _simple_set_pyx, but static_tuple depends + # on simple_set + add_pyrex_extension('bzrlib._simple_set_pyx') + ext_modules.append(Extension('bzrlib._static_tuple_c', + ['bzrlib/_static_tuple_c.c'])) +add_pyrex_extension('bzrlib._btree_serializer_pyx') + + +if unavailable_files: + print('C extension(s) not found:') + print(' %s' % ('\n '.join(unavailable_files),)) + print('The python versions will be used instead.') + print("") + + +def get_tbzr_py2exe_info(includes, excludes, packages, console_targets, + gui_targets, data_files): + packages.append('tbzrcommands') + + # ModuleFinder can't handle runtime changes to __path__, but + # win32com uses them. Hook this in so win32com.shell is found. + import modulefinder + import win32com + import cPickle as pickle + for p in win32com.__path__[1:]: + modulefinder.AddPackagePath("win32com", p) + for extra in ["win32com.shell"]: + __import__(extra) + m = sys.modules[extra] + for p in m.__path__[1:]: + modulefinder.AddPackagePath(extra, p) + + # TBZR points to the TBZR directory + tbzr_root = os.environ["TBZR"] + + # Ensure tbzrlib itself is on sys.path + sys.path.append(tbzr_root) + + packages.append("tbzrlib") + + # collect up our icons. + cwd = os.getcwd() + ico_root = os.path.join(tbzr_root, 'tbzrlib', 'resources') + icos = [] # list of (path_root, relative_ico_path) + # First always bzr's icon and its in the root of the bzr tree. + icos.append(('', 'bzr.ico')) + for root, dirs, files in os.walk(ico_root): + icos.extend([(ico_root, os.path.join(root, f)[len(ico_root)+1:]) + for f in files if f.endswith('.ico')]) + # allocate an icon ID for each file and the full path to the ico + icon_resources = [(rid, os.path.join(ico_dir, ico_name)) + for rid, (ico_dir, ico_name) in enumerate(icos)] + # create a string resource with the mapping. Might as well save the + # runtime some effort and write a pickle. + # Runtime expects unicode objects with forward-slash seps. + fse = sys.getfilesystemencoding() + map_items = [(f.replace('\\', '/').decode(fse), rid) + for rid, (_, f) in enumerate(icos)] + ico_map = dict(map_items) + # Create a new resource type of 'ICON_MAP', and use ID=1 + other_resources = [ ("ICON_MAP", 1, pickle.dumps(ico_map))] + + excludes.extend("""pywin pywin.dialogs pywin.dialogs.list + win32ui crawler.Crawler""".split()) + + # tbzrcache executables - a "console" version for debugging and a + # GUI version that is generally used. + tbzrcache = dict( + script = os.path.join(tbzr_root, "scripts", "tbzrcache.py"), + icon_resources = icon_resources, + other_resources = other_resources, + ) + console_targets.append(tbzrcache) + + # Make a windows version which is the same except for the base name. + tbzrcachew = tbzrcache.copy() + tbzrcachew["dest_base"]="tbzrcachew" + gui_targets.append(tbzrcachew) + + # ditto for the tbzrcommand tool + tbzrcommand = dict( + script = os.path.join(tbzr_root, "scripts", "tbzrcommand.py"), + icon_resources = icon_resources, + other_resources = other_resources, + ) + console_targets.append(tbzrcommand) + tbzrcommandw = tbzrcommand.copy() + tbzrcommandw["dest_base"]="tbzrcommandw" + gui_targets.append(tbzrcommandw) + + # A utility to see python output from both C++ and Python based shell + # extensions + tracer = dict(script=os.path.join(tbzr_root, "scripts", "tbzrtrace.py")) + console_targets.append(tracer) + + # The C++ implemented shell extensions. + dist_dir = os.path.join(tbzr_root, "shellext", "build") + data_files.append(('', [os.path.join(dist_dir, 'tbzrshellext_x86.dll')])) + data_files.append(('', [os.path.join(dist_dir, 'tbzrshellext_x64.dll')])) + + +def get_qbzr_py2exe_info(includes, excludes, packages, data_files): + # PyQt4 itself still escapes the plugin detection code for some reason... + includes.append('PyQt4.QtCore') + includes.append('PyQt4.QtGui') + includes.append('PyQt4.QtTest') + includes.append('sip') # extension module required for Qt. + packages.append('pygments') # colorizer for qbzr + packages.append('docutils') # html formatting + includes.append('win32event') # for qsubprocess stuff + # the qt binaries might not be on PATH... + # They seem to install to a place like C:\Python25\PyQt4\* + # Which is not the same as C:\Python25\Lib\site-packages\PyQt4 + pyqt_dir = os.path.join(sys.prefix, "PyQt4") + pyqt_bin_dir = os.path.join(pyqt_dir, "bin") + if os.path.isdir(pyqt_bin_dir): + path = os.environ.get("PATH", "") + if pyqt_bin_dir.lower() not in [p.lower() for p in path.split(os.pathsep)]: + os.environ["PATH"] = path + os.pathsep + pyqt_bin_dir + # also add all imageformat plugins to distribution + # We will look in 2 places, dirname(PyQt4.__file__) and pyqt_dir + base_dirs_to_check = [] + if os.path.isdir(pyqt_dir): + base_dirs_to_check.append(pyqt_dir) + try: + import PyQt4 + except ImportError: + pass + else: + pyqt4_base_dir = os.path.dirname(PyQt4.__file__) + if pyqt4_base_dir != pyqt_dir: + base_dirs_to_check.append(pyqt4_base_dir) + if not base_dirs_to_check: + log.warn("Can't find PyQt4 installation -> not including imageformat" + " plugins") + else: + files = [] + for base_dir in base_dirs_to_check: + plug_dir = os.path.join(base_dir, 'plugins', 'imageformats') + if os.path.isdir(plug_dir): + for fname in os.listdir(plug_dir): + # Include plugin dlls, but not debugging dlls + fullpath = os.path.join(plug_dir, fname) + if fname.endswith('.dll') and not fname.endswith('d4.dll'): + files.append(fullpath) + if files: + data_files.append(('imageformats', files)) + else: + log.warn('PyQt4 was found, but we could not find any imageformat' + ' plugins. Are you sure your configuration is correct?') + + +def get_svn_py2exe_info(includes, excludes, packages): + packages.append('subvertpy') + packages.append('sqlite3') + + +def get_git_py2exe_info(includes, excludes, packages): + packages.append('dulwich') + + +def get_fastimport_py2exe_info(includes, excludes, packages): + # This is the python-fastimport package, not to be confused with the + # bzr-fastimport plugin. + packages.append('fastimport') + + +if 'bdist_wininst' in sys.argv: + def find_docs(): + docs = [] + for root, dirs, files in os.walk('doc'): + r = [] + for f in files: + if (os.path.splitext(f)[1] in ('.html','.css','.png','.pdf') + or f == 'quick-start-summary.svg'): + r.append(os.path.join(root, f)) + if r: + relative = root[4:] + if relative: + target = os.path.join('Doc\\Bazaar', relative) + else: + target = 'Doc\\Bazaar' + docs.append((target, r)) + return docs + + # python's distutils-based win32 installer + ARGS = {'scripts': ['bzr', 'tools/win32/bzr-win32-bdist-postinstall.py'], + 'ext_modules': ext_modules, + # help pages + 'data_files': find_docs(), + # for building pyrex extensions + 'cmdclass': command_classes, + } + + ARGS.update(META_INFO) + ARGS.update(BZRLIB) + PKG_DATA['package_data']['bzrlib'].append('locale/*/LC_MESSAGES/*.mo') + ARGS.update(PKG_DATA) + + setup(**ARGS) + +elif 'py2exe' in sys.argv: + # py2exe setup + import py2exe + + # pick real bzr version + import bzrlib + + version_number = [] + for i in bzrlib.version_info[:4]: + try: + i = int(i) + except ValueError: + i = 0 + version_number.append(str(i)) + version_str = '.'.join(version_number) + + # An override to install_data used only by py2exe builds, which arranges + # to byte-compile any .py files in data_files (eg, our plugins) + # Necessary as we can't rely on the user having the relevant permissions + # to the "Program Files" directory to generate them on the fly. + class install_data_with_bytecompile(install_data): + def run(self): + from distutils.util import byte_compile + + install_data.run(self) + + py2exe = self.distribution.get_command_obj('py2exe', False) + # GZ 2010-04-19: Setup has py2exe.optimize as 2, but give plugins + # time before living with docstring stripping + optimize = 1 + compile_names = [f for f in self.outfiles if f.endswith('.py')] + # Round mtime to nearest even second so that installing on a FAT + # filesystem bytecode internal and script timestamps will match + for f in compile_names: + mtime = os.stat(f).st_mtime + remainder = mtime % 2 + if remainder: + mtime -= remainder + os.utime(f, (mtime, mtime)) + byte_compile(compile_names, + optimize=optimize, + force=self.force, prefix=self.install_dir, + dry_run=self.dry_run) + self.outfiles.extend([f + 'o' for f in compile_names]) + # end of class install_data_with_bytecompile + + target = py2exe.build_exe.Target(script = "bzr", + dest_base = "bzr", + icon_resources = [(0,'bzr.ico')], + name = META_INFO['name'], + version = version_str, + description = META_INFO['description'], + author = META_INFO['author'], + copyright = "(c) Canonical Ltd, 2005-2010", + company_name = "Canonical Ltd.", + comments = META_INFO['description'], + ) + gui_target = copy.copy(target) + gui_target.dest_base = "bzrw" + + packages = BZRLIB['packages'] + packages.remove('bzrlib') + packages = [i for i in packages if not i.startswith('bzrlib.plugins')] + includes = [] + for i in glob.glob('bzrlib\\*.py'): + module = i[:-3].replace('\\', '.') + if module.endswith('__init__'): + module = module[:-len('__init__')] + includes.append(module) + + additional_packages = set() + if sys.version.startswith('2.4'): + # adding elementtree package + additional_packages.add('elementtree') + elif sys.version.startswith('2.6') or sys.version.startswith('2.5'): + additional_packages.add('xml.etree') + else: + import warnings + warnings.warn('Unknown Python version.\n' + 'Please check setup.py script for compatibility.') + + # Although we currently can't enforce it, we consider it an error for + # py2exe to report any files are "missing". Such modules we know aren't + # used should be listed here. + excludes = """Tkinter psyco ElementPath r_hmac + ImaginaryModule cElementTree elementtree.ElementTree + Crypto.PublicKey._fastmath + medusa medusa.filesys medusa.ftp_server + tools + resource validate""".split() + dll_excludes = [] + + # email package from std python library use lazy import, + # so we need to explicitly add all package + additional_packages.add('email') + # And it uses funky mappings to conver to 'Oldname' to 'newname'. As + # a result, packages like 'email.Parser' show as missing. Tell py2exe + # to exclude them. + import email + for oldname in getattr(email, '_LOWERNAMES', []): + excludes.append("email." + oldname) + for oldname in getattr(email, '_MIMENAMES', []): + excludes.append("email.MIME" + oldname) + + # text files for help topis + text_topics = glob.glob('bzrlib/help_topics/en/*.txt') + topics_files = [('lib/help_topics/en', text_topics)] + + # built-in plugins + plugins_files = [] + # XXX - should we consider having the concept of an 'official' build, + # which hard-codes the list of plugins, gets more upset if modules are + # missing, etc? + plugins = None # will be a set after plugin sniffing... + for root, dirs, files in os.walk('bzrlib/plugins'): + if root == 'bzrlib/plugins': + plugins = set(dirs) + # We ship plugins as normal files on the file-system - however, + # the build process can cause *some* of these plugin files to end + # up in library.zip. Thus, we saw (eg) "plugins/svn/test" in + # library.zip, and then saw import errors related to that as the + # rest of the svn plugin wasn't. So we tell py2exe to leave the + # plugins out of the .zip file + excludes.extend(["bzrlib.plugins." + d for d in dirs]) + x = [] + for i in files: + # Throw away files we don't want packaged. Note that plugins may + # have data files with all sorts of extensions so we need to + # be conservative here about what we ditch. + ext = os.path.splitext(i)[1] + if ext.endswith('~') or ext in [".pyc", ".swp"]: + continue + if i == '__init__.py' and root == 'bzrlib/plugins': + continue + x.append(os.path.join(root, i)) + if x: + target_dir = root[len('bzrlib/'):] # install to 'plugins/...' + plugins_files.append((target_dir, x)) + # find modules for built-in plugins + import tools.package_mf + mf = tools.package_mf.CustomModuleFinder() + mf.run_package('bzrlib/plugins') + packs, mods = mf.get_result() + additional_packages.update(packs) + includes.extend(mods) + + console_targets = [target, + 'tools/win32/bzr_postinstall.py', + ] + gui_targets = [gui_target] + data_files = topics_files + plugins_files + I18N_FILES + + if 'qbzr' in plugins: + get_qbzr_py2exe_info(includes, excludes, packages, data_files) + + if 'svn' in plugins: + get_svn_py2exe_info(includes, excludes, packages) + + if 'git' in plugins: + get_git_py2exe_info(includes, excludes, packages) + + if 'fastimport' in plugins: + get_fastimport_py2exe_info(includes, excludes, packages) + + if "TBZR" in os.environ: + # TORTOISE_OVERLAYS_MSI_WIN32 must be set to the location of the + # TortoiseOverlays MSI installer file. It is in the TSVN svn repo and + # can be downloaded from (username=guest, blank password): + # http://tortoisesvn.tigris.org/svn/tortoisesvn/TortoiseOverlays + # look for: version-1.0.4/bin/TortoiseOverlays-1.0.4.11886-win32.msi + # Ditto for TORTOISE_OVERLAYS_MSI_X64, pointing at *-x64.msi. + for needed in ('TORTOISE_OVERLAYS_MSI_WIN32', + 'TORTOISE_OVERLAYS_MSI_X64'): + url = ('http://guest:@tortoisesvn.tigris.org/svn/tortoisesvn' + '/TortoiseOverlays') + if not os.path.isfile(os.environ.get(needed, '')): + raise RuntimeError( + "\nPlease set %s to the location of the relevant" + "\nTortoiseOverlays .msi installer file." + " The installers can be found at" + "\n %s" + "\ncheck in the version-X.Y.Z/bin/ subdir" % (needed, url)) + get_tbzr_py2exe_info(includes, excludes, packages, console_targets, + gui_targets, data_files) + else: + # print this warning to stderr as output is redirected, so it is seen + # at build time. Also to stdout so it appears in the log + for f in (sys.stderr, sys.stdout): + f.write("Skipping TBZR binaries - " + "please set TBZR to a directory to enable\n") + + # MSWSOCK.dll is a system-specific library, which py2exe accidentally pulls + # in on Vista. + dll_excludes.extend(["MSWSOCK.dll", + "MSVCP60.dll", + "MSVCP90.dll", + "powrprof.dll", + "SHFOLDER.dll"]) + options_list = {"py2exe": {"packages": packages + list(additional_packages), + "includes": includes, + "excludes": excludes, + "dll_excludes": dll_excludes, + "dist_dir": "win32_bzr.exe", + "optimize": 2, + "custom_boot_script": + "tools/win32/py2exe_boot_common.py", + }, + } + + # We want the libaray.zip to have optimize = 2, but the exe to have + # optimize = 1, so that .py files that get compilied at run time + # (e.g. user installed plugins) dont have their doc strings removed. + class py2exe_no_oo_exe(py2exe.build_exe.py2exe): + def build_executable(self, *args, **kwargs): + self.optimize = 1 + py2exe.build_exe.py2exe.build_executable(self, *args, **kwargs) + self.optimize = 2 + + if __name__ == '__main__': + command_classes['install_data'] = install_data_with_bytecompile + command_classes['py2exe'] = py2exe_no_oo_exe + setup(options=options_list, + console=console_targets, + windows=gui_targets, + zipfile='lib/library.zip', + data_files=data_files, + cmdclass=command_classes, + ) + +else: + # ad-hoc for easy_install + DATA_FILES = [] + if not 'bdist_egg' in sys.argv: + # generate and install bzr.1 only with plain install, not the + # easy_install one + DATA_FILES = [('man/man1', ['bzr.1'])] + + DATA_FILES = DATA_FILES + I18N_FILES + # std setup + ARGS = {'scripts': ['bzr'], + 'data_files': DATA_FILES, + 'cmdclass': command_classes, + 'ext_modules': ext_modules, + } + + ARGS.update(META_INFO) + ARGS.update(BZRLIB) + ARGS.update(PKG_DATA) + + if __name__ == '__main__': + setup(**ARGS) -- cgit v1.2.1