gpgme/lang/python/setup.py.in

#!/usr/bin/env python

# Copyright (C) 2016-2018 g10 Code GmbH
# Copyright (C) 2004,2008 Igor Belyi <belyi@users.sourceforge.net>
# Copyright (C) 2002 John Goerzen <jgoerzen@complete.org>
#
#    This library is free software; you can redistribute it and/or
#    modify it under the terms of the GNU Lesser General Public
#    License as published by the Free Software Foundation; either
#    version 2.1 of the License, or (at your option) any later version.
#
#    This library is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
#    Lesser General Public License for more details.
#
#    You should have received a copy of the GNU Lesser General Public
#    License along with this library; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

from distutils.core import setup, Extension
from distutils.command.build import build

import glob
import os
import os.path
import re
import shutil
import subprocess
import sys

# Out-of-tree build of the gpg bindings.
gpg_error_config = ['gpg-error-config']
gpgme_config_flags = ['--thread=pthread']
gpgme_config = ['gpgme-config'] + gpgme_config_flags
gpgme_h = ''
include_dirs = [os.getcwd()]
library_dirs = []
in_tree = False
extra_swig_opts = []
extra_macros = dict()

top_builddir = os.environ.get('top_builddir')
if top_builddir:
    # In-tree build.
    in_tree = True
    gpgme_config = [os.path.join(top_builddir, 'src/gpgme-config')
                    ] + gpgme_config_flags
    gpgme_h = os.path.join(top_builddir, 'src/gpgme.h')
    library_dirs = [os.path.join(top_builddir,
                                 'src/.libs')]  # XXX uses libtool internals
    extra_macros.update(
        HAVE_CONFIG_H=1,
        HAVE_DATA_H=1,
        IN_TREE_BUILD=1,
    )

if hasattr(subprocess, 'DEVNULL'):
    devnull = subprocess.DEVNULL
else:
    devnull = open(os.devnull, 'w')

try:
    subprocess.check_call(gpgme_config + ['--version'], stdout=devnull)
except:
    sys.exit('Could not find gpgme-config.  ' +
             'Please install the libgpgme development package.')


def getconfig(what, config=gpgme_config):
    confdata = subprocess.Popen(
        config + ['--%s' % what], stdout=subprocess.PIPE).communicate()[0]
    return [x for x in confdata.decode('utf-8').split() if x != '']


version = version_raw = getconfig('version')[0]
if '-' in version:
    version = version.split('-')[0]
major, minor, patch = map(int, version.split('.'))

if not (major > 1 or (major == 1 and minor >= 7)):
    sys.exit('Need at least GPGME version 1.7, found {}.'.format(version_raw))

if not gpgme_h:
    gpgme_h = os.path.join(getconfig('prefix')[0], 'include', 'gpgme.h')

define_macros = []
libs = getconfig('libs')

# Define extra_macros for both the SWIG and C code
for k, v in extra_macros.items():
    extra_swig_opts.append('-D{0}={1}'.format(k, v))
    define_macros.append((k, str(v)))

for item in getconfig('cflags'):
    if item.startswith('-I'):
        include_dirs.append(item[2:])
    elif item.startswith('-D'):
        defitem = item[2:].split('=', 1)
        if len(defitem) == 2:
            define_macros.append((defitem[0], defitem[1]))
        else:
            define_macros.append((defitem[0], None))

# Adjust include and library locations in case of win32
uname_s = os.popen('uname -s').read()
if uname_s.startswith('MINGW32'):
    mnts = [
        x.split()[0:3:2] for x in os.popen('mount').read().split('\n') if x
    ]
    tmplist = sorted([(len(x[1]), x[1], x[0]) for x in mnts])
    tmplist.reverse()
    extra_dirs = []
    for item in include_dirs:
        for ln, mnt, tgt in tmplist:
            if item.startswith(mnt):
                item = os.path.normpath(item[ln:])
                while item[0] == os.path.sep:
                    item = item[1:]
                extra_dirs.append(os.path.join(tgt, item))
                break
    include_dirs += extra_dirs
    for item in [x[2:] for x in libs if x.startswith('-L')]:
        for ln, mnt, tgt in tmplist:
            if item.startswith(mnt):
                item = os.path.normpath(item[ln:])
                while item[0] == os.path.sep:
                    item = item[1:]
                library_dirs.append(os.path.join(tgt, item))
                break


def in_srcdir(name):
    return os.path.join(os.environ.get('srcdir', ''), name)


def up_to_date(source, target):
    return (os.path.exists(target) and
            os.path.getmtime(source) <= os.path.getmtime(target))


# We build an Extension using SWIG, which generates a Python module.
# By default, the 'build_py' step is run before 'build_ext', and
# therefore the generated Python module is not copied into the build
# directory.
# Bugs: https://bugs.python.org/issue1016626
#       https://bugs.python.org/issue2624
# Workaround:
# https://stackoverflow.com/questions/12491328/python-distutils-not-include-the-swig-generated-module
#
# To install to multiple Python installations or to alternate ones run the
# following three commands (yes, run the build one twice):
#
# /path/to/pythonX.Y setup.py build
# /path/to/pythonX.Y setup.py build
# /path/to/pythonX.Y setup.py install
#
# It is highly likely that this will need to be run as root or with sudo (or
# sudo -H).  It may or may not work with venv. and outside a virtualenv

class BuildExtFirstHack(build):
    def _read_header(self, header, cflags):
        tmp_include = self._in_build_base('include1.h')
        with open(tmp_include, 'w') as f:
            f.write('#include <%s>' % header)
        return subprocess.check_output(
            os.environ.get('CPP', 'cc -E').split() + cflags +
            [tmp_include]).decode('utf-8')

    def _write_if_unchanged(self, target, content):
        if os.path.exists(target):
            with open(target) as f:
                if f.read() == content:
                    return

        with open(target, 'w') as sink:
            sink.write(content)

    def _generate_gpgme_h(self, source_name, sink_name):
        print('Using gpgme.h from {}'.format(source_name))
        shutil.copy2(source_name, sink_name)

    def _generate_errors_i(self):

        try:
            subprocess.check_call(
                gpg_error_config + ['--version'], stdout=devnull)
        except:
            sys.exit('Could not find gpg-error-config.  ' +
                     'Please install the libgpg-error development package.')

        gpg_error_content = self._read_header(
            'gpg-error.h', getconfig('cflags', config=gpg_error_config))

        filter_re = re.compile(r'GPG_ERR_[^ ]* =')
        rewrite_re = re.compile(r' *(.*) = .*')

        errors_i_content = ''
        for line in gpg_error_content.splitlines():
            if not filter_re.search(line):
                continue
            errors_i_content += rewrite_re.sub(
                r'%constant long \1 = \1;' + '\n', line.strip())

        self._write_if_unchanged(
            self._in_build_base('errors.i'), errors_i_content)

    def _in_build_base(self, name):
        return os.path.join(self.build_base, name)

    def _generate(self):
        # Cleanup gpgme.h from deprecated functions and typedefs.
        if not os.path.exists(self.build_base):
            os.makedirs(self.build_base)

        self._generate_gpgme_h(gpgme_h, self._in_build_base('gpgme.h'))
        self._generate_errors_i()

        # Copy due to https://bugs.python.org/issue2624
        # Avoid creating in srcdir
        for source, target in ((in_srcdir(n), self._in_build_base(n))
                               for n in ('gpgme.i', 'helpers.c', 'private.h',
                                         'helpers.h')):
            if not up_to_date(source, target):
                shutil.copy2(source, target)

        # Append generated files via build_base
        if not os.path.exists(os.path.join(self.build_lib, 'gpg')):
            os.makedirs(os.path.join(self.build_lib, 'gpg'))
        shutil.copy2('version.py', os.path.join(self.build_lib, 'gpg'))

    def run(self):
        self._generate()

        swig_sources.extend((self._in_build_base('gpgme.i'),
                             self._in_build_base('helpers.c')))
        swig_opts.extend([
            '-I' + self.build_base, '-outdir',
            os.path.join(self.build_lib, 'gpg')
        ])
        include_dirs.insert(0, self.build_base)

        self.run_command('build_ext')
        build.run(self)


py3 = [] if sys.version_info.major < 3 else ['-py3']
swig_sources = []
swig_opts = ['-threads'] + py3 + extra_swig_opts
swige = Extension(
    'gpg._gpgme',
    sources=swig_sources,
    swig_opts=swig_opts,
    include_dirs=include_dirs,
    define_macros=define_macros,
    library_dirs=library_dirs,
    extra_link_args=libs)

setup(
    name='gpg',
    cmdclass={'build': BuildExtFirstHack},
    version='@VERSION@',
    # Note: description appears as Summary in egg-info file.
    description='Python bindings to the GPGME API of the GnuPG cryptography library.',
    # Note: long-description appears as Description in egg-info file.
    long_description='''Dynamically generated bindings to the C API of the GNU Privacy Guard.

The GPG Made Easy (GPGME) library provides a high-level API in C to all the
component software and libraries in the GnuPG Project, including GPG itself
(the GnuPG OpenPGP implementation), libgcrypt, libgpg-error, libassuan and
more.

The official CPython bindings to GPGME are generated during the compiling
process of GPGME itself and built for the specific C header and include files
produced when GPGME is compiled using SWIG.  This provides access to over two
thousand functions, methods and values via both the lower level dynamically
generated bindings and a more intuitively pythonic higher level layer.

While the lower level, dynamically generated bindings provide access to
everything which GPGME itself provides; the higher level layer is easier to use
by Python developers, provides access to the vast majority of functionality
developers would want from GnuPG and is extensively documented.

GPGME and these bindings is available here:

    https://gnupg.org/software/gpgme/index.html
''',
    author='The GnuPG hackers',
    author_email='gnupg-devel@gnupg.org',
    url='https://www.gnupg.org',
    ext_modules=[swige],
    packages=[
        'gpg', 'gpg.constants', 'gpg.constants.data', 'gpg.constants.keylist',
        'gpg.constants.sig', 'gpg.constants.tofu'
    ],
    license='LGPL2.1+ (the library), GPL2+ (tests and examples)',
    classifiers=[
        'Development Status :: 4 - Beta',
        'Intended Audience :: Developers',
        'License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)',
        'Programming Language :: Python :: 2',
        'Programming Language :: Python :: 2.7',
        'Programming Language :: Python :: 3',
        'Programming Language :: Python :: 3.4',
        'Programming Language :: Python :: 3.5',
        'Programming Language :: Python :: 3.6',
        'Programming Language :: Python :: 3.7',
        'Operating System :: POSIX',
        'Operating System :: Microsoft :: Windows',
        'Topic :: Communications :: Email',
        'Topic :: Security :: Cryptography',
    ],
)