~bzr-pqm/bzr/bzr.dev

from distutils.command.install_data import install_data

add_pyrex_extension('bzrlib._btree_serializer_c')

add_pyrex_extension('bzrlib._readdir_pyx')

def get_tbzr_py2exe_info(includes, excludes, packages, console_targets,

                         gui_targets):

    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

    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)

 

    # Ensure our COM "entry-point" is on sys.path

    sys.path.append(os.path.join(tbzr_root, "shellext", "python"))

 

    packages.append("tbzrlib")

    excludes.extend("""pywin pywin.dialogs pywin.dialogs.list

                       win32ui crawler.Crawler""".split())

 

    tbzr = dict(

        modules=["tbzr"],

        create_exe = False, # we only want a .dll

    )

    com_targets.append(tbzr)

 

    # 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 = [(0,'bzr.ico')],

    )

    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 = [(0,'bzr.ico')],

    )

    console_targets.append(tbzrcommand)

    tbzrcommandw = tbzrcommand.copy()

    tbzrcommandw["dest_base"]="tbzrcommandw"

    gui_targets.append(tbzrcommandw)

    

    # tbzr tests

    tbzrtest = dict(

        script = os.path.join(tbzr_root, "Scripts", "tbzrtest.py"),

    )

    console_targets.append(tbzrtest)

 

    # A utility to see python output from the shell extension - this will

    # die when we get a c++ extension

    # any .py file from pywin32's win32 lib will do (other than

    # win32traceutil itself that is)

    import winerror

    win32_lib_dir = os.path.dirname(winerror.__file__)

    tracer = dict(script = os.path.join(win32_lib_dir, "win32traceutil.py"),

                  dest_base="tbzr_tracer")

    console_targets.append(tracer)

 

 

def get_qbzr_py2exe_info(includes, excludes, packages):

    # PyQt4 itself still escapes the plugin detection code for some reason...

    packages.append('PyQt4')

    excludes.append('PyQt4.elementtree.ElementTree')

    includes.append('sip') # extension module required for Qt.

    packages.append('pygments') # colorizer for qbzr

    # but we can avoid many Qt4 Dlls.

    dll_excludes.extend(

        """QtAssistantClient4.dll QtCLucene4.dll QtDesigner4.dll

        QtHelp4.dll QtNetwork4.dll QtOpenGL4.dll QtScript4.dll

        QtSql4.dll QtTest4.dll QtWebKit4.dll QtXml4.dll

        qscintilla2.dll""".split())

    # the qt binaries might not be on PATH...

    qt_dir = os.path.join(sys.prefix, "PyQt4", "bin")

    path = os.environ.get("PATH","")

    if qt_dir.lower() not in [p.lower() for p in path.split(os.pathsep)]:

        os.environ["PATH"] = path + os.pathsep + qt_dir

 

 

    # 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)

            optimize = py2exe.optimize

            compile_names = [f for f in self.outfiles if f.endswith('.py')]

            byte_compile(compile_names,

                         optimize=optimize,

                         force=self.force, prefix=self.install_dir,

                         dry_run=self.dry_run)

            if optimize:

                suffix = 'o'

            else:

                suffix = 'c'

            self.outfiles.extend([f + suffix for f in compile_names])

    # end of class install_data_with_bytecompile

 

 

    # 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 tools.doc_generate

                  resource validate""".split()

    dll_excludes = []

 

    # 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)

    # 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...

        if root == 'bzrlib/plugins':

            plugins = set(dirs)

            if os.path.splitext(i)[1] not in [".py", ".pyd", ".dll"]:

    includes.extend(mods)

 

    console_targets = [target,

                       'tools/win32/bzr_postinstall.py',

                       ]

    gui_targets = []

    com_targets = []

 

    if 'qbzr' in plugins:

        get_qbzr_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/version-1.0.4/bin/TortoiseOverlays-1.0.4.11886-win32.msi

        if not os.path.isfile(os.environ.get('TORTOISE_OVERLAYS_MSI_WIN32',

                                             '<nofile>')):

            raise RuntimeError("Please set TORTOISE_OVERLAYS_MSI_WIN32 to the"

                               " location of the Win32 TortoiseOverlays .msi"

                               " installer file")

        get_tbzr_py2exe_info(includes, excludes, packages, console_targets,

                             gui_targets)

    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):

            print >> f, \

                "Skipping TBZR binaries - please set TBZR to a directory to enable"

    dll_excludes.append("MSWSOCK.dll")

                               "includes": includes,

                               "excludes": excludes,

                               "dll_excludes": dll_excludes,

                               "optimize": 1,

 

          console=console_targets,

          windows=gui_targets,

          com_server=com_targets,

          cmdclass={'install_data': install_data_with_bytecompile},