Bundle pyqt_distutils

akvo/thirdparty/pyqt_ditutils/__init__.py

@@ -0,0 +1,8 @@
+"""
+A set of PyQt distutils extensions for build qt ui files in a pythonic way:
+
+    - build_ui: build qt ui/qrc files
+
+"""
+
+__version__ = '0.7.3'

akvo/thirdparty/pyqt_ditutils/build_ui.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+"""
+Distutils extension for PyQt/PySide applications
+"""
+import glob
+import os
+import subprocess
+import sys
+
+from setuptools import Command
+
+from .config import Config
+from .hooks import load_hooks
+from .utils import build_args, write_message
+
+
+class build_ui(Command):
+    """
+    Builds the Qt ui files as described in pyuic.json (or pyuic.cfg).
+    """
+    user_options = [
+        ('force', None,
+         'Force flag, will force recompilation of every ui/qrc file'),
+    ]
+
+    def initialize_options(self):
+        self.force = False
+        self._hooks = load_hooks()
+
+    def finalize_options(self):
+        try:
+            self.cfg = Config()
+            self.cfg.load()
+        except (IOError, OSError):
+            write_message('cannot open pyuic.json (or pyuic.cfg)', 'red')
+            self.cfg = None
+
+    def is_outdated(self, src, dst, ui):
+        if src.endswith('.qrc') or self.force:
+            return True
+        outdated = (not os.path.exists(dst) or
+                    (os.path.getmtime(src) > os.path.getmtime(dst)))
+        if not outdated and not ui:
+            # for qrc files, we need to check each individual resources.
+            # If one of them is newer than the dst file, the qrc file must be
+            # considered as outdated
+            # file paths are relative to the qrc file path
+            qrc_dirname = os.path.dirname(src)
+            with open(src, 'r') as f:
+                lines = f.read().splitlines()
+                lines = [l for l in lines if '<file>' in l]
+            cwd = os.getcwd()
+            os.chdir(qrc_dirname)
+            for line in lines:
+                filename = line.replace('<file>', '').replace(
+                    '</file>', '').strip()
+                filename = os.path.abspath(filename)
+                if os.path.getmtime(filename) > os.path.getmtime(dst):
+                    outdated = True
+                    break
+            os.chdir(cwd)
+        return outdated
+
+    def run(self):
+        if not self.cfg:
+            return
+        for glob_exp, dest in self.cfg.files:
+            for src in glob.glob(glob_exp):
+                if not os.path.exists(src):
+                    write_message('skipping target %s, file not found' % src, 'yellow')
+                    continue
+                src = os.path.join(os.getcwd(), src)
+                dst = os.path.join(os.getcwd(), dest)
+                ui = True
+                if src.endswith('.ui'):
+                    ext = '_ui.py'
+                    cmd = self.cfg.uic_command()
+                elif src.endswith('.qrc'):
+                    ui = False
+                    ext = '_rc.py'
+                    cmd = self.cfg.rcc_command()
+                else:
+                    continue
+                filename = os.path.split(src)[1]
+                filename = os.path.splitext(filename)[0]
+                dst = os.path.join(dst, filename + ext)
+                try:
+                    os.makedirs(os.path.split(dst)[0])
+                except OSError:
+                    pass
+
+                if self.is_outdated(src, dst, ui):
+                    try:
+                        cmd = build_args(cmd, src, dst)
+                        subprocess.check_call(cmd)
+                        cmd = ' '.join(cmd)
+                    except subprocess.CalledProcessError as e:
+                        if e.output:
+                            write_message(cmd, 'yellow')
+                            write_message(e.output.decode(sys.stdout.encoding), 'red')
+                        else:
+                            write_message(cmd, 'red')
+                    except OSError as e:
+                        write_message(cmd, 'yellow')
+                        write_message(str(e), 'red')
+                    else:
+                        write_message(cmd, 'green')
+                    for hookname in self.cfg.hooks:
+                        try:
+                            hook = self._hooks[hookname]
+                        except KeyError:
+                            write_message('warning, unknonw hook: %r' % hookname, 'yellow')
+                        else:
+                            write_message('running hook %r' % hookname, 'blue')
+                            hook(dst)
+                else:
+                    write_message('skipping %s, up to date' % src)

akvo/thirdparty/pyqt_ditutils/config.py

@@ -0,0 +1,91 @@
+"""
+Contains the config class (pyuic.cfg or pyuic.json)
+
+"""
+import json
+
+from .utils import write_message
+
+class QtApi:
+    pyqt4 = 0
+    pyqt5 = 1
+    pyside = 2
+
+
+class Config:
+    def __init__(self):
+        self.files = []
+        self.pyuic = ''
+        self.pyuic_options = ''
+        self.pyrcc = ''
+        self.pyrcc_options = ''
+        self.hooks = []
+
+    def uic_command(self):
+        return self.pyuic + ' ' + self.pyuic_options + ' %s -o %s'
+
+    def rcc_command(self):
+        return self.pyrcc + ' ' + self.pyrcc_options + ' %s -o %s'
+
+    def load(self):
+        for ext in ['.cfg', '.json']:
+            try:
+                with open('pyuic' + ext, 'r') as f:
+                    self.__dict__ = json.load(f)
+            except (IOError, OSError):
+                pass
+            else:
+                break
+        else:
+            write_message('failed to open configuration file', 'yellow')
+        if not hasattr(self, 'hooks'):
+            self.hooks = []
+
+    def save(self):
+        with open('pyuic.json', 'w') as f:
+            json.dump(self.__dict__, f, indent=4, sort_keys=True)
+
+    def generate(self, api):
+        if api == QtApi.pyqt4:
+            self.pyrcc = 'pyrcc4'
+            self.pyrcc_options = '-py3'
+            self.pyuic = 'pyuic4'
+            self.pyuic_options = '--from-import'
+            self.files[:] = []
+        elif api == QtApi.pyqt5:
+            self.pyrcc = 'pyrcc5'
+            self.pyrcc_options = ''
+            self.pyuic = 'pyuic5'
+            self.pyuic_options = '--from-import'
+            self.files[:] = []
+        elif api == QtApi.pyside:
+            self.pyrcc = 'pyside-rcc'
+            self.pyrcc_options = '-py3'
+            self.pyuic = 'pyside-uic'
+            self.pyuic_options = '--from-import'
+            self.files[:] = []
+        self.save()
+        write_message('pyuic.json generated', 'green')
+
+    def add(self, src, dst):
+        self.load()
+        for fn, _ in self.files:
+            if fn == src:
+                write_message('ui file already added: %s' % src)
+                return
+        self.files.append((src, dst))
+        self.save()
+        write_message('file added to pyuic.json: %s -> %s' % (src, dst), 'green')
+
+    def remove(self, filename):
+        self.load()
+        to_remove = None
+        for i, files in enumerate(self.files):
+            src, dest = files
+            if filename == src:
+                to_remove = i
+                break
+        if to_remove is not None:
+            self.files.pop(to_remove)
+        self.save()
+        write_message('file removed from pyuic.json: %s' % filename, 'green')

akvo/thirdparty/pyqt_ditutils/hooks.py

@@ -0,0 +1,54 @@
+"""
+This module contains the hooks load and our builtin hooks.
+
+"""
+import re
+import pkg_resources
+
+from .utils import write_message
+
+
+#: Name of the entrypoint to use in setup.py
+ENTRYPOINT = 'pyqt_distutils_hooks'
+
+
+def load_hooks():
+    """
+    Load the exposed hooks.
+
+    Returns a dict of hooks where the keys are the name of the hook and the
+    values are the actual hook functions.
+    """
+    hooks = {}
+    for entrypoint in pkg_resources.iter_entry_points(ENTRYPOINT):
+        name = str(entrypoint).split('=')[0].strip()
+        try:
+            hook = entrypoint.load()
+        except Exception as e:
+            write_message('failed to load entry-point %r (error="%s")' % (name, e), 'yellow')
+        else:
+            hooks[name] = hook
+    return hooks
+
+
+def hook(ui_file_path):
+    """
+    This is the prototype of a hook function.
+    """
+    pass
+
+
+def gettext(ui_file_path):
+    """
+    Let you use gettext instead of the Qt tools for l18n
+    """
+    with open(ui_file_path, 'r') as fin:
+        content = fin.read()
+
+    # replace ``_translate("context", `` by ``_(``
+    content = re.sub(r'_translate\(".*",\s', '_(', content)
+    content = content.replace(
+        '        _translate = QtCore.QCoreApplication.translate', '')
+
+    with open(ui_file_path, 'w') as fout:
+        fout.write(content)

akvo/thirdparty/pyqt_ditutils/pyuicfg.py

@@ -0,0 +1,58 @@
+"""Help you manage your pyuic.json file (pyqt-distutils)
+
+Usage:
+    pyuicfg -g
+    pyuicfg -g --pyqt5
+    pyuicfg -g --pyside
+    pyuicfg -a SOURCE_FILE DESTINATION_PACKAGE
+    pyuicfg -r SOURCE_FILE
+    pyuicfg (-h | --help)
+    pyuicfg --version
+
+Options:
+    -h, --help                            Show help
+    --version                             Show version
+    -g                                    Generate pyuic.json
+    -a SOURCE_FILE DESTINATION_PACKAGE    Add file to pyuic.json
+    -r SOURCE_FILE                        Remove file from pyuic.json
+    --pyqt5                               Generate a pyuic.json file for PyQt5 instead of PyQt4
+    --pyside                              Generate a pyuic.json file for PySide instead of PyQt4
+
+"""
+import os
+from docopt import docopt
+from pyqt_distutils import __version__
+from pyqt_distutils.config import Config, QtApi
+
+
+def qt_api_from_args(arguments):
+    if arguments['--pyqt5']:
+        return QtApi.pyqt5
+    elif arguments['--pyside']:
+        return QtApi.pyside
+    return QtApi.pyqt4
+
+
+def main():
+    arguments = docopt(__doc__, version=__version__)
+    generate = arguments['-g']
+    file_to_add = arguments['-a']
+    destination_package = arguments['DESTINATION_PACKAGE']
+    file_to_remove = arguments['-r']
+    api = qt_api_from_args(arguments)
+    cfg = Config()
+    if generate:
+        if os.path.exists('pyuic.json'):
+            choice = input('pyuic.json already exists. Do you want to replace '
+                           'it? (y/N) ').lower()
+            if choice != 'y':
+                return
+        cfg.generate(api)
+    elif file_to_add:
+        cfg.add(file_to_add, destination_package)
+    elif file_to_remove:
+        cfg.remove(file_to_remove)
+
+
+if __name__ == '__main__':
+    main()

akvo/thirdparty/pyqt_ditutils/utils.py

@@ -0,0 +1,45 @@
+try:
+    import colorama
+except ImportError:
+    has_colorama = False
+else:
+    has_colorama = True
+
+import shlex
+try:
+    # Python 3
+    from shlex import quote
+except ImportError:
+    # Python 2
+    from pipes import quote
+
+
+def build_args(cmd, src, dst):
+    """
+        Build arguments list for passing to subprocess.call_check
+
+        :param cmd str: Command string to interpolate src and dst filepaths into.
+            Typically the output of `config.Config.uic_command` or `config.Config.rcc_command`.
+        :param src str: Source filepath.
+        :param dst str: Destination filepath.
+    """
+    cmd = cmd % (quote(src), quote(dst))
+    args = shlex.split(cmd)
+
+    return [arg for arg in args if arg]
+
+
+def write_message(text, color=None):
+    if has_colorama:
+        colors = {
+            'red': colorama.Fore.RED,
+            'green': colorama.Fore.GREEN,
+            'yellow': colorama.Fore.YELLOW,
+            'blue': colorama.Fore.BLUE
+        }
+        try:
+            print(colors[color] + text + colorama.Fore.RESET)
+        except KeyError:
+            print(text)
+    else:
+        print(text)