# -*- coding: utf-8 -*-
#
# Copyright © 2009-2011 CEA
# Pierre Raybaut
# Licensed under the terms of the CECILL License
# (see guidata/__init__.py for details)

# pylint: disable=W0613

"""
disthelpers
-----------

The ``guidata.disthelpers`` module provides helper functions for Python 
package distribution on Microsoft Windows platforms with ``py2exe`` or on 
all platforms thanks to ``cx_Freeze``.
"""

from __future__ import print_function

import sys
import os
import os.path as osp
import shutil
import traceback
import atexit
import imp
from subprocess import Popen, PIPE
import warnings

# ==============================================================================
# Module, scripts, programs
# ==============================================================================
def get_module_path(modname):
    """Return module *modname* base path"""
    module = sys.modules.get(modname, __import__(modname))
    return osp.abspath(osp.dirname(module.__file__))


# ==============================================================================
# Dependency management
# ==============================================================================
def get_changeset(path, rev=None):
    """Return Mercurial repository *path* revision number"""
    args = ['hg', 'parent']
    if rev is not None:
        args += ['--rev', str(rev)]
    process = Popen(
        args, stdout=PIPE, stderr=PIPE, cwd=path, shell=True
    )
    try:
        return (
            process.stdout.read().splitlines()[0].split()[1]
        )
    except IndexError:
        raise RuntimeError(process.stderr.read())


def prepend_module_to_path(module_path):
    """
    Prepend to sys.path module located in *module_path*
    Return string with module infos: name, revision, changeset
    
    Use this function:
    1) In your application to import local frozen copies of internal libraries
    2) In your py2exe distributed package to add a text file containing the returned string
    """
    if not osp.isdir(module_path):
        # Assuming py2exe distribution
        return
    sys.path.insert(0, osp.abspath(module_path))
    changeset = get_changeset(module_path)
    name = osp.basename(module_path)
    prefix = "Prepending module to sys.path"
    message = prefix + (
        "%s [revision %s]" % (name, changeset)
    ).rjust(80 - len(prefix), ".")
    print(message, file=sys.stderr)
    if name in sys.modules:
        sys.modules.pop(name)
        nbsp = 0
        for modname in sys.modules.keys():
            if modname.startswith(name + '.'):
                sys.modules.pop(modname)
                nbsp += 1
        warning = '(removed %s from sys.modules' % name
        if nbsp:
            warning += ' and %d subpackages' % nbsp
        warning += ')'
        print(warning.rjust(80), file=sys.stderr)
    return message


def prepend_modules_to_path(module_base_path):
    """Prepend to sys.path all modules located in *module_base_path*"""
    if not osp.isdir(module_base_path):
        # Assuming py2exe distribution
        return
    fnames = [
        osp.join(module_base_path, name)
        for name in os.listdir(module_base_path)
    ]
    messages = [
        prepend_module_to_path(dirname)
        for dirname in fnames
        if osp.isdir(dirname)
    ]
    return os.linesep.join(messages)


# ==============================================================================
# Distribution helpers
# ==============================================================================
def _remove_later(fname):
    """Try to remove file later (at exit)"""

    def try_to_remove(fname):
        if osp.exists(fname):
            os.remove(fname)

    atexit.register(try_to_remove, osp.abspath(fname))


def get_msvc_version(python_version):
    """Return Microsoft Visual C++ version used to build this Python version"""
    if python_version is None:
        python_version = '2.7'
        warnings.warn("assuming Python 2.7 target")
    if python_version in (
        '2.6',
        '2.7',
        '3.0',
        '3.1',
        '3.2',
    ):
        # Python 2.6-2.7, 3.0-3.2 were built with Visual Studio 9.0.21022.8
        # (i.e. Visual C++ 2008, not Visual C++ 2008 SP1!)
        return "9.0.21022.8"
    elif python_version in ('3.3', '3.4'):
        # Python 3.3+ were built with Visual Studio 10.0.30319.1
        # (i.e. Visual C++ 2010)
        return '10.0'
    elif python_version in ('3.5', '3.6'):
        return '15.0'
    elif python_version in ('3.7', '3.8'):
        return '15.0'
    else:
        raise RuntimeError(
            "Unsupported Python version %s" % python_version
        )


def get_msvc_dlls(msvc_version, architecture=None):
    """Get the list of Microsoft Visual C++ DLLs associated to 
    architecture and Python version, create the manifest file.
    
    architecture: integer (32 or 64) -- if None, take the Python build arch
    python_version: X.Y"""
    current_architecture = (
        64 if sys.maxsize > 2 ** 32 else 32
    )
    if architecture is None:
        architecture = current_architecture
    filelist = []

    # simple vs2015 situation: nothing (system dll)
    if msvc_version == '14.0':
        return filelist
    msvc_major = msvc_version.split('.')[0]
    msvc_minor = msvc_version.split('.')[1]

    if msvc_major == '9':
        key = "1fc8b3b9a1e18e3b"
        atype = "" if architecture == 64 else "win32"
        arch = "amd64" if architecture == 64 else "x86"

        groups = {
            'CRT': (
                'msvcr90.dll',
                'msvcp90.dll',
                'msvcm90.dll',
            ),
            #                  'OPENMP': ('vcomp90.dll',)
        }

        for group, dll_list in groups.items():
            dlls = ''
            for dll in dll_list:
                dlls += '    <file name="%s" />%s' % (
                    dll,
                    os.linesep,
                )
            manifest = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!-- Copyright (c) Microsoft Corporation.  All rights reserved. -->
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
    <noInheritable/>
    <assemblyIdentity
        type="%(atype)s"
        name="Microsoft.VC90.%(group)s"
        version="%(version)s"
        processorArchitecture="%(arch)s"
        publicKeyToken="%(key)s"
    />
%(dlls)s</assembly>
""" % dict(
                version=msvc_version,
                key=key,
                atype=atype,
                arch=arch,
                group=group,
                dlls=dlls,
            )

            vc90man = "Microsoft.VC90.%s.manifest" % group
            open(vc90man, 'w').write(manifest)
            _remove_later(vc90man)
            filelist += [vc90man]

            winsxs = osp.join(
                os.environ['windir'], 'WinSxS'
            )
            vcstr = '%s_Microsoft.VC90.%s_%s_%s' % (
                arch,
                group,
                key,
                msvc_version,
            )
            for fname in os.listdir(winsxs):
                path = osp.join(winsxs, fname)
                if osp.isdir(
                    path
                ) and fname.lower().startswith(
                    vcstr.lower()
                ):
                    for dllname in os.listdir(path):
                        filelist.append(
                            osp.join(path, dllname)
                        )
                    break
            else:
                raise RuntimeError(
                    "Microsoft Visual C++ %s DLLs version %s "
                    "were not found" % (group, msvc_version)
                )
    elif (
        msvc_major == '10' or msvc_major == '15'
    ):  # 15 for vs 2015
        namelist = [
            name % (msvc_major + msvc_minor)
            for name in (
                'msvcp%s.dll',
                'msvcr%s.dll',
                'vcomp%s.dll',
            )
        ]
        if msvc_major == '15':
            namelist = [
                name % ('14' + msvc_minor)
                for name in (
                    'vcruntime%s.dll',
                    'msvcp%s.dll',
                    'vccorlib%s.dll',
                    'concrt%s.dll',
                    'vcomp%s.dll',
                )
            ]
        windir = os.environ['windir']
        is_64bit_windows = osp.isdir(
            osp.join(windir, "SysWOW64")
        )

        # Reminder: WoW64 (*W*indows 32-bit *o*n *W*indows *64*-bit) is a
        # subsystem of the Windows operating system capable of running 32-bit
        # applications and is included on all 64-bit versions of Windows
        # (source: http://en.wikipedia.org/wiki/WoW64)
        #
        # In other words, "SysWOW64" contains 64-bit DLL and applications,
        # whereas "System32" contains 64-bit DLL and applications on a 64-bit
        # system.
        sysdir = "System32"
        if not is_64bit_windows and architecture == 64:
            raise RuntimeError(
                "Can't find 64-bit MSVC DLLs on a 32-bit OS"
            )
        if is_64bit_windows and architecture == 32:
            sysdir = "SysWOW64"
        for dllname in namelist:
            fname = osp.join(windir, sysdir, dllname)
            print('searching', fname)
            if osp.exists(fname):
                filelist.append(fname)
            else:
                raise RuntimeError(
                    "Microsoft Visual C++ DLLs version %s "
                    "were not found" % msvc_version
                )
    else:
        raise RuntimeError(
            "Unsupported MSVC version %s" % msvc_version
        )
    return filelist


def create_msvc_data_files(
    architecture=None, python_version=None, verbose=False
):
    """Including Microsoft Visual C++ DLLs"""
    msvc_version = get_msvc_version(python_version)
    filelist = get_msvc_dlls(
        msvc_version, architecture=architecture
    )
    print(create_msvc_data_files.__doc__)
    if verbose:
        for name in filelist:
            print("  ", name)
    msvc_major = msvc_version.split('.')[0]
    if msvc_major == '9':
        return [("Microsoft.VC90.CRT", filelist)]
    else:
        return [("", filelist)]


def to_include_files(data_files):
    """Convert data_files list to include_files list
    
    data_files:
      * this is the ``py2exe`` data files format
      * list of tuples (dest_dirname, (src_fname1, src_fname2, ...))
    
    include_files:
      * this is the ``cx_Freeze`` data files format
      * list of tuples ((src_fname1, dst_fname1),
                        (src_fname2, dst_fname2), ...))
    """
    include_files = []
    for dest_dir, fnames in data_files:
        for source_fname in fnames:
            dest_fname = osp.join(
                dest_dir, osp.basename(source_fname)
            )
            include_files.append((source_fname, dest_fname))
    return include_files


def strip_version(version):
    """Return version number with digits only
    (Windows does not support strings in version numbers)"""
    return (
        version.split('beta')[0]
        .split('alpha')[0]
        .split('rc')[0]
        .split('dev')[0]
    )


def remove_dir(dirname):
    """Remove directory *dirname* and all its contents
    Print details about the operation (progress, success/failure)"""
    print("Removing directory '%s'..." % dirname, end=' ')
    try:
        shutil.rmtree(dirname, ignore_errors=True)
        print("OK")
    except Exception:
        print("Failed!")
        traceback.print_exc()


class Distribution(object):
    """Distribution object
    
    Help creating an executable using ``py2exe`` or ``cx_Freeze``
    """

    DEFAULT_EXCLUDES = [
        'Tkconstants',
        'Tkinter',
        'tcl',
        'tk',
        'wx',
        '_imagingtk',
        'curses',
        'PIL._imagingtk',
        'ImageTk',
        'PIL.ImageTk',
        'FixTk',
        'bsddb',
        'email',
        'pywin.debugger',
        'pywin.debugger.dbgcon',
        'matplotlib',
    ]
    DEFAULT_INCLUDES = []
    DEFAULT_BIN_EXCLUDES = [
        'MSVCP100.dll',
        'MSVCP90.dll',
        'w9xpopen.exe',
        'MSVCP80.dll',
        'MSVCR80.dll',
    ]
    DEFAULT_BIN_INCLUDES = []
    DEFAULT_BIN_PATH_INCLUDES = []
    DEFAULT_BIN_PATH_EXCLUDES = []

    def __init__(self):
        self.name = None
        self.version = None
        self.description = None
        self.target_name = None
        self._target_dir = None
        self.icon = None
        self.data_files = []
        self.includes = self.DEFAULT_INCLUDES
        self.excludes = self.DEFAULT_EXCLUDES
        self.bin_includes = self.DEFAULT_BIN_INCLUDES
        self.bin_excludes = self.DEFAULT_BIN_EXCLUDES
        self.bin_path_includes = (
            self.DEFAULT_BIN_PATH_INCLUDES
        )
        self.bin_path_excludes = (
            self.DEFAULT_BIN_PATH_EXCLUDES
        )
        self.msvc = os.name == 'nt'
        self._py2exe_is_loaded = False
        self._pyqt4_added = False
        self._pyside_added = False
        # Attributes relative to cx_Freeze:
        self.executables = []

    @property
    def target_dir(self):
        """Return target directory (default: 'dist')"""
        dirname = self._target_dir
        if dirname is None:
            return 'dist'
        else:
            return dirname

    @target_dir.setter  # analysis:ignore
    def target_dir(self, value):
        self._target_dir = value

    def setup(
        self,
        name,
        version,
        description,
        script,
        target_name=None,
        target_dir=None,
        icon=None,
        data_files=None,
        includes=None,
        excludes=None,
        bin_includes=None,
        bin_excludes=None,
        bin_path_includes=None,
        bin_path_excludes=None,
        msvc=None,
    ):
        """Setup distribution object
        
        Notes:
          * bin_path_excludes is specific to cx_Freeze (ignored if it's None)
          * if msvc is None, it's set to True by default on Windows 
            platforms, False on non-Windows platforms
        """
        self.name = name
        self.version = (
            strip_version(version)
            if os.name == 'nt'
            else version
        )
        self.description = description
        assert osp.isfile(script)
        self.script = script
        self.target_name = target_name
        self.target_dir = target_dir
        self.icon = icon
        if data_files is not None:
            self.data_files += data_files
        if includes is not None:
            self.includes += includes
        if excludes is not None:
            self.excludes += excludes
        if bin_includes is not None:
            self.bin_includes += bin_includes
        if bin_excludes is not None:
            self.bin_excludes += bin_excludes
        if bin_path_includes is not None:
            self.bin_path_includes += bin_path_includes
        if bin_path_excludes is not None:
            self.bin_path_excludes += bin_path_excludes
        if msvc is not None:
            self.msvc = msvc
        if self.msvc:
            try:
                self.data_files += create_msvc_data_files()
            except IOError:
                print(
                    "Setting the msvc option to False "
                    "will avoid this error",
                    file=sys.stderr,
                )
                raise
        # cx_Freeze:
        self.add_executable(
            self.script, self.target_name, icon=self.icon
        )

    def add_text_data_file(self, filename, contents):
        """Create temporary data file *filename* with *contents*
        and add it to *data_files*"""
        open(filename, 'wb').write(contents)
        self.data_files += [("", (filename,))]
        _remove_later(filename)

    def add_data_file(self, filename, destdir=''):
        self.data_files += [(destdir, (filename,))]

    # ------ Adding packages
    def add_pyqt4(self):
        """Include module PyQt4 to the distribution"""
        if self._pyqt4_added:
            return
        self._pyqt4_added = True

        self.includes += [
            'sip',
            'PyQt4.Qt',
            'PyQt4.QtSvg',
            'PyQt4.QtNetwork',
        ]

        import PyQt4

        pyqt_path = osp.dirname(PyQt4.__file__)

        # Configuring PyQt4
        conf = os.linesep.join(
            ["[Paths]", "Prefix = .", "Binaries = ."]
        )
        self.add_text_data_file('qt.conf', conf)

        # Including plugins (.svg icons support, QtDesigner support, ...)
        if self.msvc:
            vc90man = "Microsoft.VC90.CRT.manifest"
            pyqt_tmp = 'pyqt_tmp'
            if osp.isdir(pyqt_tmp):
                shutil.rmtree(pyqt_tmp)
            os.mkdir(pyqt_tmp)
            vc90man_pyqt = osp.join(pyqt_tmp, vc90man)
            man = (
                open(vc90man, "r")
                .read()
                .replace(
                    '<file name="',
                    '<file name="Microsoft.VC90.CRT\\',
                )
            )
            open(vc90man_pyqt, 'w').write(man)
        for dirpath, _, filenames in os.walk(
            osp.join(pyqt_path, "plugins")
        ):
            filelist = [
                osp.join(dirpath, f)
                for f in filenames
                if osp.splitext(f)[1] in ('.dll', '.py')
            ]
            if self.msvc and [
                f
                for f in filelist
                if osp.splitext(f)[1] == '.dll'
            ]:
                # Where there is a DLL build with Microsoft Visual C++ 2008,
                # there must be a manifest file as well...
                # ...congrats to Microsoft for this great simplification!
                filelist.append(vc90man_pyqt)
            self.data_files.append(
                (
                    dirpath[
                        len(pyqt_path) + len(os.pathsep) :
                    ],
                    filelist,
                )
            )
        if self.msvc:
            atexit.register(remove_dir, pyqt_tmp)
        # Including french translation
        fr_trans = osp.join(
            pyqt_path, "translations", "qt_fr.qm"
        )
        if osp.exists(fr_trans):
            self.data_files.append(
                ('translations', (fr_trans,))
            )

    def add_pyside(self):
        """Include module PySide to the distribution"""
        if self._pyside_added:
            return
        self._pyside_added = True

        self.includes += [
            'PySide.QtDeclarative',
            'PySide.QtHelp',
            'PySide.QtMultimedia',
            'PySide.QtNetwork',
            'PySide.QtOpenGL',
            'PySide.QtScript',
            'PySide.QtScriptTools',
            'PySide.QtSql',
            'PySide.QtSvg',
            'PySide.QtTest',
            'PySide.QtUiTools',
            'PySide.QtWebKit',
            'PySide.QtXml',
            'PySide.QtXmlPatterns',
        ]

        import PySide

        pyside_path = osp.dirname(PySide.__file__)

        # Configuring PySide
        conf = os.linesep.join(
            ["[Paths]", "Prefix = .", "Binaries = ."]
        )
        self.add_text_data_file('qt.conf', conf)

        # Including plugins (.svg icons support, QtDesigner support, ...)
        if self.msvc:
            vc90man = "Microsoft.VC90.CRT.manifest"
            os.mkdir('pyside_tmp')
            vc90man_pyside = osp.join('pyside_tmp', vc90man)
            man = (
                open(vc90man, "r")
                .read()
                .replace(
                    '<file name="',
                    '<file name="Microsoft.VC90.CRT\\',
                )
            )
            open(vc90man_pyside, 'w').write(man)
        for dirpath, _, filenames in os.walk(
            osp.join(pyside_path, "plugins")
        ):
            filelist = [
                osp.join(dirpath, f)
                for f in filenames
                if osp.splitext(f)[1] in ('.dll', '.py')
            ]
            if self.msvc and [
                f
                for f in filelist
                if osp.splitext(f)[1] == '.dll'
            ]:
                # Where there is a DLL build with Microsoft Visual C++ 2008,
                # there must be a manifest file as well...
                # ...congrats to Microsoft for this great simplification!
                filelist.append(vc90man_pyside)
            self.data_files.append(
                (
                    dirpath[
                        len(pyside_path) + len(os.pathsep) :
                    ],
                    filelist,
                )
            )
        # Replacing dlls found by cx_Freeze by the real PySide Qt dlls:
        # (http://qt-project.org/wiki/Packaging_PySide_applications_on_Windows)
        dlls = [
            osp.join(pyside_path, fname)
            for fname in os.listdir(pyside_path)
            if osp.splitext(fname)[1] == '.dll'
        ]
        self.data_files.append(('', dlls))

        if self.msvc:
            atexit.register(remove_dir, 'pyside_tmp')
        # Including french translation
        fr_trans = osp.join(
            pyside_path, "translations", "qt_fr.qm"
        )
        if osp.exists(fr_trans):
            self.data_files.append(
                ('translations', (fr_trans,))
            )

    def add_qt_bindings(self):
        """Include Qt bindings, i.e. PyQt4 or PySide"""
        try:
            imp.find_module('PyQt4')
            self.add_modules('PyQt4')
        except ImportError:
            self.add_modules('PySide')

    def add_matplotlib(self):
        """Include module Matplotlib to the distribution"""
        if 'matplotlib' in self.excludes:
            self.excludes.pop(
                self.excludes.index('matplotlib')
            )
        try:
            import matplotlib.numerix  # analysis:ignore

            self.includes += [
                'matplotlib.numerix.ma',
                'matplotlib.numerix.fft',
                'matplotlib.numerix.linear_algebra',
                'matplotlib.numerix.mlab',
                'matplotlib.numerix.random_array',
            ]
        except ImportError:
            pass
        self.add_module_data_files(
            'matplotlib',
            ('mpl-data',),
            (
                '.conf',
                '.glade',
                '',
                '.png',
                '.svg',
                '.xpm',
                '.ppm',
                '.npy',
                '.afm',
                '.ttf',
            ),
        )

    def add_modules(self, *module_names):
        """Include module *module_name*"""
        for module_name in module_names:
            print("Configuring module '%s'" % module_name)
            if module_name == 'PyQt4':
                self.add_pyqt4()
            elif module_name == 'PySide':
                self.add_pyside()
            elif module_name == 'scipy.io':
                self.includes += ['scipy.io.matlab.streams']
            elif module_name == 'matplotlib':
                self.add_matplotlib()
            elif module_name == 'h5py':
                import h5py

                for attr in [
                    '_stub',
                    '_sync',
                    'utils',
                    '_conv',
                    '_proxy',
                    'defs',
                ]:
                    if hasattr(h5py, attr):
                        self.includes.append(
                            'h5py.%s' % attr
                        )
                if (
                    self.bin_path_excludes is not None
                    and os.name == 'nt'
                ):
                    # Specific to cx_Freeze on Windows: avoid including a zlib dll
                    # built with another version of Microsoft Visual Studio
                    self.bin_path_excludes += [
                        r'C:\Program Files',
                        r'C:\Program Files (x86)',
                    ]
                    self.data_files.append(  # necessary for cx_Freeze only
                        (
                            '',
                            (
                                osp.join(
                                    get_module_path('h5py'),
                                    'zlib1.dll',
                                ),
                            ),
                        )
                    )
            elif module_name in (
                'docutils',
                'rst2pdf',
                'sphinx',
            ):
                self.includes += [
                    'docutils.writers.null',
                    'docutils.languages.en',
                    'docutils.languages.fr',
                ]
                if module_name == 'rst2pdf':
                    self.add_module_data_files(
                        "rst2pdf",
                        ("styles",),
                        ('.json', '.style'),
                        copy_to_root=True,
                    )
                if module_name == 'sphinx':
                    import sphinx.ext

                    for fname in os.listdir(
                        osp.dirname(sphinx.ext.__file__)
                    ):
                        if osp.splitext(fname)[1] == '.py':
                            modname = (
                                'sphinx.ext.%s'
                                % osp.splitext(fname)[0]
                            )
                            self.includes.append(modname)
            elif module_name == 'pygments':
                self.includes += [
                    'pygments',
                    'pygments.formatters',
                    'pygments.lexers',
                    'pygments.lexers.agile',
                ]
            elif module_name == 'zmq':
                # FIXME: this is not working, yet... (missing DLL)
                self.includes += [
                    'zmq',
                    'zmq.core._poll',
                    'zmq.core._version',
                    'zmq.core.constants',
                    'zmq.core.context',
                    'zmq.core.device',
                    'zmq.core.error',
                    'zmq.core.message',
                    'zmq.core.socket',
                    'zmq.core.stopwatch',
                ]
                if os.name == 'nt':
                    self.bin_includes += ['libzmq.dll']
            elif module_name == 'guidata':
                self.add_module_data_files(
                    'guidata',
                    ("images",),
                    ('.png', '.svg'),
                    copy_to_root=False,
                )
                try:
                    imp.find_module('PyQt4')
                    self.add_pyqt4()
                except ImportError:
                    self.add_pyside()
            elif module_name == 'guiqwt':
                self.add_module_data_files(
                    'guiqwt',
                    ("images",),
                    ('.png', '.svg'),
                    copy_to_root=False,
                )
                if os.name == 'nt':
                    # Specific to cx_Freeze: including manually MinGW DLLs
                    self.bin_includes += [
                        'libgcc_s_dw2-1.dll',
                        'libstdc++-6.dll',
                    ]
            else:
                try:
                    # Modules based on the same scheme as guidata and guiqwt
                    self.add_module_data_files(
                        module_name,
                        ("images",),
                        ('.png', '.svg'),
                        copy_to_root=False,
                    )
                except IOError:
                    raise RuntimeError(
                        "Module not supported: %s"
                        % module_name
                    )

    def add_module_data_dir(
        self,
        module_name,
        data_dir_name,
        extensions,
        copy_to_root=True,
        verbose=False,
        exclude_dirs=[],
    ):
        """
        Collect data files in *data_dir_name* for module *module_name*
        and add them to *data_files*
        *extensions*: list of file extensions, e.g. ('.png', '.svg')
        """
        module_dir = get_module_path(module_name)
        nstrip = len(module_dir) + len(osp.sep)
        data_dir = osp.join(module_dir, data_dir_name)
        if not osp.isdir(data_dir):
            raise IOError(
                "Directory not found: %s" % data_dir
            )
        for dirpath, _dirnames, filenames in os.walk(
            data_dir
        ):
            dirname = dirpath[nstrip:]
            if osp.basename(dirpath) in exclude_dirs:
                continue
            if not copy_to_root:
                dirname = osp.join(module_name, dirname)
            pathlist = [
                osp.join(dirpath, f)
                for f in filenames
                if osp.splitext(f)[1].lower() in extensions
            ]
            self.data_files.append((dirname, pathlist))
            if verbose:
                for name in pathlist:
                    print("  ", name)

    def add_module_data_files(
        self,
        module_name,
        data_dir_names,
        extensions,
        copy_to_root=True,
        verbose=False,
        exclude_dirs=[],
    ):
        """
        Collect data files for module *module_name* and add them to *data_files*
        *data_dir_names*: list of dirnames, e.g. ('images', )
        *extensions*: list of file extensions, e.g. ('.png', '.svg')
        """
        print(
            "Adding module '%s' data files in %s (%s)"
            % (
                module_name,
                ", ".join(data_dir_names),
                ", ".join(extensions),
            )
        )
        module_dir = get_module_path(module_name)
        for data_dir_name in data_dir_names:
            self.add_module_data_dir(
                module_name,
                data_dir_name,
                extensions,
                copy_to_root,
                verbose,
                exclude_dirs,
            )
        translation_file = osp.join(
            module_dir,
            "locale",
            "fr",
            "LC_MESSAGES",
            "%s.mo" % module_name,
        )
        if osp.isfile(translation_file):
            self.data_files.append(
                (
                    osp.join(
                        module_name,
                        "locale",
                        "fr",
                        "LC_MESSAGES",
                    ),
                    (translation_file,),
                )
            )
            print(
                "Adding module '%s' translation file: %s"
                % (
                    module_name,
                    osp.basename(translation_file),
                )
            )

    def build(
        self, library, cleanup=True, create_archive=None
    ):
        """Build executable with given library.

        library:
            * 'py2exe': deploy using the `py2exe` library
            * 'cx_Freeze': deploy using the `cx_Freeze` library

        cleanup: remove 'build/dist' directories before building distribution

        create_archive (requires the executable `zip`):
            * None or False: do nothing
            * 'add': add target directory to a ZIP archive
            * 'move': move target directory to a ZIP archive
        """
        if library == 'py2exe':
            self.build_py2exe(
                cleanup=cleanup,
                create_archive=create_archive,
            )
        elif library == 'cx_Freeze':
            self.build_cx_freeze(
                cleanup=cleanup,
                create_archive=create_archive,
            )
        else:
            raise RuntimeError(
                "Unsupported library %s" % library
            )

    def __cleanup(self):
        """Remove old build and dist directories"""
        remove_dir("build")
        if osp.isdir("dist"):
            remove_dir("dist")
        remove_dir(self.target_dir)

    def __create_archive(self, option):
        """Create a ZIP archive

        option:
            * 'add': add target directory to a ZIP archive
            * 'move': move target directory to a ZIP archive
        """
        name = self.target_dir
        os.system('zip "%s.zip" -r "%s"' % (name, name))
        if option == 'move':
            shutil.rmtree(name)

    def build_py2exe(
        self,
        cleanup=True,
        compressed=2,
        optimize=2,
        company_name=None,
        copyright=None,
        create_archive=None,
    ):
        """Build executable with py2exe

        cleanup: remove 'build/dist' directories before building distribution

        create_archive (requires the executable `zip`):
            * None or False: do nothing
            * 'add': add target directory to a ZIP archive
            * 'move': move target directory to a ZIP archive
        """
        from distutils.core import setup
        import py2exe  # Patching distutils -- analysis:ignore

        self._py2exe_is_loaded = True
        if cleanup:
            self.__cleanup()
        sys.argv += ["py2exe"]
        options = dict(
            compressed=compressed,
            optimize=optimize,
            includes=self.includes,
            excludes=self.excludes,
            dll_excludes=self.bin_excludes,
            dist_dir=self.target_dir,
        )
        windows = dict(
            name=self.name,
            description=self.description,
            script=self.script,
            icon_resources=[(0, self.icon)],
            bitmap_resources=[],
            other_resources=[],
            dest_base=osp.splitext(self.target_name)[0],
            version=self.version,
            company_name=company_name,
            copyright=copyright,
        )
        setup(
            data_files=self.data_files,
            windows=[windows],
            options=dict(py2exe=options),
        )
        if create_archive:
            self.__create_archive(create_archive)

    def add_executable(
        self, script, target_name, icon=None
    ):
        """Add executable to the cx_Freeze distribution
        Not supported for py2exe"""
        from cx_Freeze import Executable

        base = None
        if script.endswith('.pyw') and os.name == 'nt':
            base = 'win32gui'
        self.executables += [
            Executable(
                self.script,
                base=base,
                icon=self.icon,
                targetName=self.target_name,
            )
        ]

    def build_cx_freeze(
        self, cleanup=True, create_archive=None
    ):
        """Build executable with cx_Freeze

        cleanup: remove 'build/dist' directories before building distribution

        create_archive (requires the executable `zip`):
            * None or False: do nothing
            * 'add': add target directory to a ZIP archive
            * 'move': move target directory to a ZIP archive
        """
        assert (
            not self._py2exe_is_loaded
        ), "cx_Freeze can't be executed after py2exe"
        from cx_Freeze import setup

        if cleanup:
            self.__cleanup()
        sys.argv += ["build"]
        build_exe = dict(
            include_files=to_include_files(self.data_files),
            includes=self.includes,
            excludes=self.excludes,
            bin_excludes=self.bin_excludes,
            bin_includes=self.bin_includes,
            bin_path_includes=self.bin_path_includes,
            bin_path_excludes=self.bin_path_excludes,
            build_exe=self.target_dir,
        )
        setup(
            name=self.name,
            version=self.version,
            description=self.description,
            executables=self.executables,
            options=dict(build_exe=build_exe),
        )
        if create_archive:
            self.__create_archive(create_archive)
