setup.py

#! python

project = dict(
    name = 'python-poppler-qt5',
    version = '0.75.0',
    description = 'A Python binding to Poppler-Qt5',
    long_description = (
        'A Python binding to Poppler-Qt5 that aims for '
        'completeness and for being actively maintained. '
        'Using this module you can access the contents of PDF files '
        'inside PyQt5 applications.'
    ),
    maintainer = 'Wilbert Berendsen',
    maintainer_email = 'wbsoft@xs4all.nl',
    url = 'https://github.com/frescobaldi/python-poppler-qt5',
    license = 'LGPL',
    classifiers = [
        'Development Status :: 5 - Production/Stable',
        'Intended Audience :: Developers',
        'License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)',
        'Operating System :: MacOS :: MacOS X',
        'Operating System :: Microsoft :: Windows',
        'Operating System :: POSIX',
        'Programming Language :: Python :: 3',
        'Topic :: Multimedia :: Graphics :: Viewers',
    ],
    cmdclass={}
)

import os
import re
import shlex
import subprocess
import sys
import platform

try:
   from setuptools import setup, Extension
except ImportError:
   from distutils.core import setup, Extension
   
import sipdistutils

### this circumvents a bug in sip < 4.14.2, where the file() builtin is used
### instead of open()
try:
    import builtins
    try:
        builtins.file
    except AttributeError:
        builtins.file = open
except ImportError:
    pass
### end


def check_qtxml():
    """Return True if PyQt5.QtXml can be imported.
    
    in some early releases of PyQt5, QtXml was missing because it was
    thought QtXml was deprecated.
    
    """
    import PyQt5
    try:
        import PyQt5.QtXml
    except ImportError:
        return False
    return True


def pkg_config(package, attrs=None, include_only=False):
    """parse the output of pkg-config for a package.
    
    returns the given or a new dictionary with one or more of these keys
    'include_dirs', 'library_dirs', 'libraries'. Every key is a list of paths,
    so that it can be used with distutils Extension objects.
    
    """
    if attrs is None:
        attrs = {}
    cmd = ['pkg-config']
    if include_only:
        cmd += ['--cflags-only-I']
    else:
        cmd += ['--cflags', '--libs']
    cmd.append(package)
    try:
        output = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[0]
    except OSError:
        return attrs
    flag_map = {'-I': 'include_dirs', '-L': 'library_dirs', '-l': 'libraries'}
    # for python3 turn bytes back to string
    if sys.version_info[0] > 2:
        output = output.decode('utf-8')
    for flag in shlex.split(output):
        option, path = flag[:2], flag[2:]
        if option in flag_map:
            l = attrs.setdefault(flag_map[option], [])
            if path not in l:
                l.append(path)
    return attrs

def pkg_config_version(package):
    """Returns the version of the given package as a tuple of ints."""
    cmd = ['pkg-config', '--modversion', package]
    try:
        output = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[0]
        # for python3 turn bytes back to string
        if sys.version_info[0] > 2:
            output = output.decode('utf-8')
        return tuple(map(int, re.findall(r'\d+', output)))
    except OSError:
        sys.stderr.write("Can't determine version of %s\n" % package)

ext_args = {}
ext_args['extra_compile_args'] = ['-std=c++11']
pkg_config('poppler-qt5', ext_args)

if 'libraries' not in ext_args:
    ext_args['libraries'] = ['poppler-qt5']

# hack to provide our options to sip on its invocation:
build_ext_base = sipdistutils.build_ext
class build_ext(build_ext_base):
    
    description = "Builds the popplerqt5 module."
    
    user_options = build_ext_base.user_options + [
        ('poppler-version=', None, "version of the poppler library"),
        ('qmake-bin=', None, "Path to qmake binary"),
        ('sip-bin=', None, "Path to sip binary"),
        ('qt-include-dir=', None, "Path to Qt headers"),
        ('pyqt-sip-dir=', None, "Path to PyQt's SIP files"),
        ('pyqt-sip-flags=', None, "SIP flags used to generate PyQt bindings")
    ]
    
    def initialize_options (self):
        build_ext_base.initialize_options(self)
        self.poppler_version = None
        self.qmake_bin = 'qmake'
        self.sip_bin = None
        self.qt_include_dir = None
        self.pyqt_sip_dir = None
        self.pyqt_sip_flags = None

    def finalize_options (self):
        build_ext_base.finalize_options(self)

        if not self.qt_include_dir:
            self.qt_include_dir = self.__find_qt_include_dir()

        if not self.pyqt_sip_dir:
            self.pyqt_sip_dir = self.__find_pyqt_sip_dir()

        if not self.pyqt_sip_flags:
            self.pyqt_sip_flags = self.__find_pyqt_sip_flags()

        if not self.qt_include_dir:
            raise SystemExit('Could not find Qt5 headers. '
                             'Please specify via --qt-include-dir=')

        if not self.pyqt_sip_dir:
            raise SystemExit('Could not find PyQt SIP files. '
                             'Please specify containing directory via '
                             '--pyqt-sip-dir=')

        if not self.pyqt_sip_flags:
            raise SystemExit('Could not find PyQt SIP flags. '
                             'Please specify via --pyqt-sip-flags=')

        self.include_dirs += (self.qt_include_dir,
                              os.path.join(self.qt_include_dir, 'QtCore'),
                              os.path.join(self.qt_include_dir, 'QtGui'),
                              os.path.join(self.qt_include_dir, 'QtXml'))

        if self.poppler_version is not None:
            self.poppler_version = tuple(map(int, re.findall(r'\d+', self.poppler_version)))

    def __find_qt_include_dir(self):
        if self.pyqtconfig:
            return self.pyqtconfig.qt_inc_dir

        try:
            qt_version = subprocess.check_output([self.qmake_bin,
                                                  '-query',
                                                  'QT_VERSION'])
            qt_version = qt_version.strip().decode("ascii")
        except (OSError, subprocess.CalledProcessError) as e:
            raise SystemExit('Failed to determine Qt version (%s).' % e)

        if not qt_version.startswith("5."):
            raise SystemExit('Unsupported Qt version (%s). '
                             'Try specifying the path to qmake manually via '
                             '--qmake-bin=' % qt_version)

        try:
            result =  subprocess.check_output([self.qmake_bin,
                                               '-query',
                                               'QT_INSTALL_HEADERS'])
            return result.strip().decode(sys.getfilesystemencoding())
        except (OSError, subprocess.CalledProcessError) as e:
            raise SystemExit('Failed to determine location of Qt headers (%s).' % e)

    def __find_pyqt_sip_dir(self):
        if self.pyqtconfig:
            return self.pyqtconfig.pyqt_sip_dir

        import sipconfig

        return os.path.join(sipconfig.Configuration().default_sip_dir, 'PyQt5')

    def __find_pyqt_sip_flags(self):
        if self.pyqtconfig:
            return self.pyqtconfig.pyqt_sip_flags

        from PyQt5 import QtCore

        return QtCore.PYQT_CONFIGURATION.get('sip_flags', '')

    @property
    def pyqtconfig(self):
        if not hasattr(self, '_pyqtconfig'):
            try:
                from PyQt5 import pyqtconfig

                self._pyqtconfig = pyqtconfig.Configuration()
            except ImportError:
                self._pyqtconfig = None

        return self._pyqtconfig

    def write_version_sip(self, poppler_qt5_version, python_poppler_qt5_version):
        """Write a version.sip file.
        
        The file contains code to make version information accessible from
        the popplerqt5 Python module.
        
        """
        with open('version.sip', 'w') as f:
            f.write(version_sip_template.format(
                vlen = 'i' * len(python_poppler_qt5_version),
                vargs = ', '.join(map(format, python_poppler_qt5_version)),
                pvlen = 'i' * len(poppler_qt5_version),
                pvargs = ', '.join(map(format, poppler_qt5_version))))
        
    def _find_sip(self):
        """override _find_sip to allow for manually speficied sip path."""
        return self.sip_bin or build_ext_base._find_sip(self)
    
    def _sip_compile(self, sip_bin, source, sbf):
        
        # First check manually specified poppler version
        ver = self.poppler_version or pkg_config_version('poppler-qt5') or ()
        
        # our own version:
        version = tuple(map(int, re.findall(r'\d+', project['version'])))
        
        # make those accessible from the popplerqt5 module:
        self.write_version_sip(ver, version)
        
        # Disable features if older poppler-qt5 version is found.
        # See the defined tags in %Timeline{} in timeline.sip.
        tag = 'POPPLER_V0_20_0'
        if ver:
            with open("timeline.sip", "r") as f:
                for m in re.finditer(r'POPPLER_V(\d+)_(\d+)_(\d+)', f.read()):
                    if ver < tuple(map(int, m.group(1, 2, 3))):
                        break
                    tag = m.group()
        
        cmd = [sip_bin]
        if hasattr(self, 'sip_opts'):
            cmd += self.sip_opts
        if hasattr(self, '_sip_sipfiles_dir'):
            cmd += ['-I', self._sip_sipfiles_dir()]
        if tag:
            cmd += ['-t', tag]
        if not check_qtxml():
            cmd += ["-x", "QTXML_AVAILABLE"]     # mark QtXml not supported
        cmd += [
            "-c", self.build_temp,
            "-b", sbf,
            "-I", self.pyqt_sip_dir]             # find the PyQt5 stuff
        cmd += shlex.split(self.pyqt_sip_flags)  # use same SIP flags as for PyQt5
        cmd.append(source)
        self.spawn(cmd)

if platform.system() == 'Windows':
   # Enforce libraries to link against on Windows
   ext_args['libraries'] = ['poppler-qt5', 'Qt5Core', 'Qt5Gui', 'Qt5Xml']
   
   class bdist_support():
       def __find_poppler_dll(self):
           paths = os.environ['PATH'].split(";")
           poppler_dll = None
           
           for path in paths:
               dll_path_candidate = os.path.join(path, "poppler-qt5.dll")
               if os.path.exists(dll_path_candidate):
                   return dll_path_candidate
           
           return None
       
       def _copy_poppler_dll(self):
           poppler_dll = self.__find_poppler_dll()
           if poppler_dll is None:
               self.warn("Could not find poppler-qt5.dll in any of the folders listed in the PATH environment variable.")
               return False
               
           self.mkpath(self.bdist_dir)
           self.copy_file(poppler_dll, os.path.join(self.bdist_dir, "python-poppler5.dll"))
           
           return True
   
   import distutils.command.bdist_msi
   class bdist_msi(distutils.command.bdist_msi.bdist_msi, bdist_support):
       def run(self):
           if not self._copy_poppler_dll():
               return
           distutils.command.bdist_msi.bdist_msi.run(self)
   
   project['cmdclass']['bdist_msi'] = bdist_msi
   
   import distutils.command.bdist_wininst
   class bdist_wininst(distutils.command.bdist_wininst.bdist_wininst, bdist_support):
       def run(self):
           if not self._copy_poppler_dll():
               return
           distutils.command.bdist_wininst.bdist_wininst.run(self)
   project['cmdclass']['bdist_wininst'] = bdist_wininst
   
   import distutils.command.bdist_dumb
   class bdist_dumb(distutils.command.bdist_dumb.bdist_dumb, bdist_support):
       def run(self):
           if not self._copy_poppler_dll():
               return
           distutils.command.bdist_dumb.bdist_dumb.run(self)
   project['cmdclass']['bdist_dumb'] = bdist_dumb
   
   try:
       # Attempt to patch bdist_egg if the setuptools/distribute extension is installed
       import setuptools.command.bdist_egg
       class bdist_egg(setuptools.command.bdist_egg.bdist_egg, bdist_support):
           def run(self):
               if not self._copy_poppler_dll():
                   return
               setuptools.command.bdist_egg.bdist_egg.run(self)
       project['cmdclass']['bdist_egg'] = bdist_egg
   except ImportError:
       pass


version_sip_template = r"""// Generated by setup.py -- Do not edit

PyObject *version();
%Docstring
The version of the popplerqt5 python module.
%End

PyObject *poppler_version();
%Docstring
The version of the Poppler library.
%End

%ModuleCode

PyObject *version()
{{ return Py_BuildValue("({vlen})", {vargs}); }};

PyObject *poppler_version()
{{ return Py_BuildValue("({pvlen})", {pvargs}); }};

%End
"""

### use full README.rst as long description
with open('README.rst', 'rb') as f:
    project["long_description"] = f.read().decode('utf-8')


   
project['cmdclass']['build_ext'] = build_ext
setup(
    ext_modules = [Extension("popplerqt5", ["poppler-qt5.sip"], **ext_args)],
    **project
)