#!/usr/bin/env python3

 # Copyright 2011-2018 Kwant authors.

 #

 # This file is part of Kwant.  It is subject to the license terms in the file
 # LICENSE.rst found in the top-level directory of this distribution and at

 # http://kwant-project.org/license.  A list of Kwant authors can be found in

 # the file AUTHORS.rst at the top-level directory of this distribution and at

 # http://kwant-project.org/authors.
 

 from __future__ import print_function
 

 import sys

 import re

 import os

 import glob

 import importlib

 import subprocess

 import configparser

 import collections

 from setuptools import setup, find_packages, Extension, Command

 from distutils.errors import DistutilsError, CCompilerError

 from distutils.command.build import build as build_orig
 from setuptools.command.sdist import sdist as sdist_orig
 from setuptools.command.build_ext import build_ext as build_ext_orig

 from setuptools.command.test import test as test_orig

 STATIC_VERSION_PATH = ('kwant', '_kwant_version.py')

 distr_root = os.path.dirname(os.path.abspath(__file__))
 
 

 def configure_extensions(exts, aliases=(), build_summary=None):
     """Modify extension configuration according to the configuration file
 
     `exts` must be a dict of (name, kwargs) tuples that can be used like this:
     `Extension(name, **kwargs).  This function modifies the kwargs according to

     the configuration file.
 
     This function modifies `sys.argv`.

     """

     global config_file, config_file_present
 
     #### Determine the name of the configuration file.
     config_file_option = '--configfile'

     config_file_option_present = False

     # Handle command line option
     for i, opt in enumerate(sys.argv):
         if not opt.startswith(config_file_option):
             continue

         config_file_option_present = True

         l, _, config_file = opt.partition('=')
         if l != config_file_option or not config_file:

             print('Error: Expecting {}=PATH'.format(config_file_option),

                   file=sys.stderr)

             sys.exit(1)

         sys.argv.pop(i)
         break
     else:
         config_file = 'build.conf'

 
     #### Read build configuration file.
     configs = configparser.ConfigParser()
     try:

         with open(config_file) as f:

             configs.read_file(f)
     except IOError:
         config_file_present = False

         if config_file_option_present:
             print("Error: '{}' option was provided, but '{}' does not exist"
                   .format(config_file_option, config_file))
             sys.exit(1)

     else:
         config_file_present = True
 
     #### Handle section aliases.
     for short, long in aliases:
         if short in configs:
             if long in configs:
                 print('Error: both {} and {} sections present in {}.'.format(

                     short, long, config_file))

                 sys.exit(1)

             configs[long] = configs[short]
             del configs[short]
 
     #### Apply config from file.  Use [DEFAULT] section for missing sections.
     defaultconfig = configs.defaults()
     for name, kwargs in exts.items():
         config = configs[name] if name in configs else defaultconfig
         for key, value in config.items():
 
             # Most, but not all, keys are lists of strings
             if key == 'language':
                 pass
             elif key == 'optional':
                 value = bool(int(value))
             else:
                 value = value.split()
 
             if key == 'define_macros':
                 value = [tuple(entry.split('=', maxsplit=1))
                          for entry in value]
                 value = [(entry[0], None) if len(entry) == 1 else entry
                          for entry in value]
 
             if key in kwargs:
                 msg = 'Caution: user config in file {} shadows {}.{}.'
                 if build_summary is not None:

                     build_summary.append(msg.format(config_file, name, key))

             kwargs[key] = value
 

         kwargs.setdefault('depends', []).append(config_file)

         if config is not defaultconfig:
             del configs[name]
 
     unknown_sections = configs.sections()
     if unknown_sections:
         print('Error: Unknown sections in file {}: {}'.format(

             config_file, ', '.join(unknown_sections)))

         sys.exit(1)

 
     return exts
 
 

 def check_python_version(min_version):
     installed_version = sys.version_info[:3]
     if installed_version < min_version:
         print('Error: Python {} required, but {} is installed'.format(
               '.'.join(map(str, min_version)),
               '.'.join(map(str, installed_version)))
         )
         sys.exit(1)
 
 

 def check_versions():

     global version, version_is_from_git
 
     # Let Kwant itself determine its own version.  We cannot simply import
     # kwant, as it is not built yet.

     spec = importlib.util.spec_from_file_location('version', 'kwant/version.py')
     version_module = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(version_module)

     version_module.ensure_python()
     version = version_module.version
     version_is_from_git = version_module.version_is_from_git

 
 
 def init_cython():

     """Set the global variable `cythonize` (and other related globals).
 
     The variable `cythonize` can be in three states:
 
     * If Cython should be run and is ready, it contains the `cythonize()`
       function.
 
     * If Cython is not to be run, it contains `False`.
 
     * If Cython should, but cannot be run it contains `None`.  A help message
       on how to solve the problem is stored in `cython_help`.
 
     This function modifies `sys.argv`.
     """

     global cythonize, cython_help

     cython_option = '--cython'

     required_cython_version = (0, 24)

     try:

         sys.argv.remove(cython_option)

         cythonize = True

     except ValueError:

         cythonize = version_is_from_git

     if cythonize:

         try:
             import Cython
             from Cython.Build import cythonize
         except ImportError:

             cythonize = None

         else:

             #### Get Cython version.

             match = re.match('([0-9.]*)(.*)', Cython.__version__)
             cython_version = [int(n) for n in match.group(1).split('.')]
             # Decrease version if the version string contains a suffix.
             if match.group(2):
                 while cython_version[-1] == 0:
                     cython_version.pop()
                 cython_version[-1] -= 1
             cython_version = tuple(cython_version)

             if cython_version < required_cython_version:

                 cythonize = None
 

         if cythonize is None:
             msg = ("Install Cython >= {0} or use"
                     " a source distribution (tarball) of Kwant.")
             ver = '.'.join(str(e) for e in required_cython_version)
             cython_help = msg.format(ver)

     else:
         msg = "Run setup.py with the {} option to enable Cython."

         cython_help = msg.format(cython_option)

 def banner(title=''):
     starred = title.center(79, '*')
     return '\n' + starred if title else starred

 class build_ext(build_ext_orig):

     def run(self):

         if not config_file_present:
             # Create an empty config file if none is present so that the
             # extensions will not be rebuilt each time.  Only depending on the
             # config file if it is present would make it impossible to detect a
             # necessary rebuild due to a deleted config file.

             with open(config_file, 'w') as f:
                 f.write('# Build configuration created by setup.py '
                         '- feel free to modify.\n')

         try:

             super().run()

         except (DistutilsError, CCompilerError):

             error_msg = self.__error_msg.format(
                 header=banner(' Error '), sep=banner())

             print(error_msg.format(file=config_file, summary=build_summary),

                   file=sys.stderr)

             raise

         print(banner(' Build summary '), *build_summary, sep='\n')

         print(banner())

     __error_msg = """{header}
 The compilation of Kwant has failed.  Please examine the error message
 above and consult the installation instructions in README.rst.
 You might have to customize {{file}}.
 
 Build configuration was:
 
 {{summary}}
 {sep}
 """
 

 class build(build_orig):

     def run(self):

         super().run()

         write_version(os.path.join(self.build_lib, *STATIC_VERSION_PATH))
 

 
 def git_lsfiles():

     if not version_is_from_git:

         return
 

     try:

         p = subprocess.Popen(['git', 'ls-files'], cwd=distr_root,

                              stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     except OSError:
         return
 
     if p.wait() != 0:
         return

     return p.communicate()[0].decode().split('\n')[:-1]

 # Make the command "sdist" depend on "build".  This verifies that the
 # distribution in the current state actually builds.  It also makes sure that

 # the Cython-made C files will be up-to-date and included in the source.

 class sdist(sdist_orig):
     sub_commands = [('build', None)] + sdist_orig.sub_commands

 
     def run(self):

         """Create MANIFEST.in from git if possible, otherwise check that
         MANIFEST.in is present.

 
         Right now (2015) generating MANIFEST.in seems to be the only way to
         include files in the source distribution that setuptools does not think
         should be there.  Setting include_package_data to True makes setuptools
         include *.pyx and other source files in the binary distribution.
         """

         manifest_in_file = 'MANIFEST.in'
         manifest = os.path.join(distr_root, manifest_in_file)

         names = git_lsfiles()
         if names is None:

             if not (os.path.isfile(manifest) and os.access(manifest, os.R_OK)):

                 print("Error:", manifest_in_file,

                       "file is missing and Git is not available"
                       " to regenerate it.", file=sys.stderr)

                 sys.exit(1)

         else:

             with open(manifest, 'w') as f:

                 for name in names:
                     a, sep, b = name.rpartition('/')
                     if b == '.gitignore':
                         continue
                     stem, dot, extension = b.rpartition('.')

                     f.write('include {}'.format(name))

                     if extension == 'pyx':

                         f.write(''.join([' ', a, sep, stem, dot, 'c']))
                     f.write('\n')

         super().run()

 
         if names is None:

             msg = ("Git was not available to generate the list of files to be "
                    "included in the\nsource distribution. The old {} was used.")

             msg = msg.format(manifest_in_file)

             print(banner(' Caution '), msg, banner(), sep='\n', file=sys.stderr)

     def make_release_tree(self, base_dir, files):

         super().make_release_tree(base_dir, files)

         write_version(os.path.join(base_dir, *STATIC_VERSION_PATH))

 # The following class is based on a recipe in
 # http://doc.pytest.org/en/latest/goodpractices.html#manual-integration.

 class test(test_orig):

     user_options = [('pytest-args=', 'a', "Arguments to pass to pytest")]
 
     def initialize_options(self):
         super().initialize_options()
         self.pytest_args = ''
 
     def run_tests(self):
         import shlex

         try:

             import pytest
         except:
             print('The Python package "pytest" is required to run tests.',

                   file=sys.stderr)

             sys.exit(1)

         errno = pytest.main(shlex.split(self.pytest_args))
         sys.exit(errno)

 def write_version(fname):
     # This could be a hard link, so try to delete it first.  Is there any way
     # to do this atomically together with opening?

     try:

         os.remove(fname)
     except OSError:
         pass
     with open(fname, 'w') as f:
         f.write("# This file has been created by setup.py.\n")

         f.write("version = '{}'\n".format(version))

 def long_description():
     text = []
     try:

         with open('README.rst', encoding='utf8') as f:

             for line in f:

                 if line.startswith('See also in this directory:'):

                     break
                 text.append(line.rstrip())

             while text[-1] == "":
                 text.pop()

     except:
         return ''
     return '\n'.join(text)
 
 

 def search_libs(libs):

     cmd = ['gcc']
     cmd.extend(['-l' + lib for lib in libs])
     cmd.extend(['-o/dev/null', '-xc', '-'])

     try:

         p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stderr=subprocess.PIPE)

     except OSError:
         pass
     else:

         p.communicate(input=b'int main() {}\n')

         if p.wait() == 0:

             return libs
 
 
 def search_mumps():
     """Return the configuration for MUMPS if it is available in a known way.
 
     This is known to work with the MUMPS provided by the Debian package
     libmumps-scotch-dev and the MUMPS binaries in the conda-forge channel."""
     lib_sets = [
         # Debian

         ['zmumps_scotch', 'mumps_common_scotch', 'mpiseq_scotch',
          'pord', 'gfortran'],

         # Conda (via conda-forge).

         ['zmumps_seq', 'mumps_common_seq'],

     ]
     for libs in lib_sets:

         found_libs = search_libs(libs)

         if found_libs:
             return found_libs
     return []
 
 

 def configure_special_extensions(exts, build_summary):
     #### Special config for MUMPS.
     mumps = exts['kwant.linalg._mumps']
     if 'libraries' in mumps:

         build_summary.append('User-configured MUMPS')
     else:

         mumps_libs = search_mumps()
         if mumps_libs:
             mumps['libraries'] = mumps_libs

             build_summary.append('Auto-configured MUMPS')

         else:
             mumps = None

             del exts['kwant.linalg._mumps']

             build_summary.append('No MUMPS support')

     return exts

 
 def maybe_cythonize(exts):

     """Prepare a list of `Extension` instances, ready for `setup()`.

     The argument `exts` must be a mapping of names to kwargs to be passed
     on to `Extension`.

 
     If Cython is to be run, create the extensions and calls `cythonize()` on
     them.  If Cython is not to be run, replace .pyx file with .c or .cpp,
     check timestamps, and create the extensions.

     """

     if cythonize:

         return cythonize([Extension(name, **kwargs)
                           for name, kwargs in exts.items()],
                          language_level=3,

                          compiler_directives={'linetrace': True})

 
     # Cython is not going to be run: replace pyx extension by that of
     # the shipped translated file.
 

     result = []

     problematic_files = []

     for name, kwargs in exts.items():
         language = kwargs.get('language')

         if language is None:
             ext = '.c'
         elif language == 'c':
             ext = '.c'
         elif language == 'c++':
             ext = '.cpp'
         else:
             print('Unknown language: {}'.format(language), file=sys.stderr)

             sys.exit(1)

 
         pyx_files = []
         cythonized_files = []

         sources = []
         for f in kwargs['sources']:

             if f.endswith('.pyx'):
                 pyx_files.append(f)
                 f = f.rstrip('.pyx') + ext
                 cythonized_files.append(f)

             sources.append(f)
         kwargs['sources'] = sources

 
         # Complain if cythonized files are older than Cython source files.
         try:
             cythonized_oldest = min(os.stat(f).st_mtime
                                     for f in cythonized_files)
         except OSError:

             msg = "Cython-generated file {} is missing."
             print(banner(" Error "), msg.format(f), "",
                   cython_help, banner(), sep="\n", file=sys.stderr)

             sys.exit(1)

         for f in pyx_files + kwargs.get('depends', []):

             if f == config_file:

                 # The config file is only a dependency for the compilation
                 # of the cythonized file, not for the cythonization.
                 continue
             if os.stat(f).st_mtime > cythonized_oldest:
                 problematic_files.append(f)

         result.append(Extension(name, **kwargs))

     if problematic_files:

         msg = ("Some Cython source files are newer than files that have "
                "been derived from them:\n{}")
         msg = msg.format(", ".join(problematic_files))
 
         # Cython should be run but won't.  Signal an error if this is because
         # Cython *cannot* be run, warn otherwise.
         error = cythonize is None
         if cythonize is False:
             dontworry = ('(Do not worry about this if you are building Kwant '
                          'from unmodified sources,\n'
                          'e.g. with "pip install".)\n\n')
             msg = dontworry + msg
 
         print(banner(" Error " if error else " Caution "), msg, "",
               cython_help, banner(), sep="\n", file=sys.stderr)
         if error:

             sys.exit(1)

     return result
 

 def maybe_add_numpy_include(exts):
     # Add NumPy header path to include_dirs of all the extensions.
     try:
         import numpy
     except ImportError:
         print(banner(' Caution '), 'NumPy header directory cannot be determined'
               ' ("import numpy" failed).', banner(), sep='\n', file=sys.stderr)
     else:
         numpy_include = numpy.get_include()
         for ext in exts.values():
             ext.setdefault('include_dirs', []).append(numpy_include)
     return exts
 
 

 def main():

     check_python_version((3, 6))

     check_versions()
 

     exts = collections.OrderedDict([
         ('kwant._system',
          dict(sources=['kwant/_system.pyx'],
               include_dirs=['kwant/graph'])),
         ('kwant.operator',
          dict(sources=['kwant/operator.pyx'],
               include_dirs=['kwant/graph'])),
         ('kwant.graph.core',
          dict(sources=['kwant/graph/core.pyx'],
               depends=['kwant/graph/core.pxd', 'kwant/graph/defs.h',
                        'kwant/graph/defs.pxd'])),

         ('kwant.graph.dijkstra',
          dict(sources=['kwant/graph/dijkstra.pyx'])),

         ('kwant.linalg.lapack',

          dict(sources=['kwant/linalg/lapack.pyx'])),

         ('kwant.linalg._mumps',
          dict(sources=['kwant/linalg/_mumps.pyx'],
               depends=['kwant/linalg/cmumps.pxd']))])
 

     aliases = [('mumps', 'kwant.linalg._mumps')]

     init_cython()
 

     global build_summary

     build_summary = []

     exts = configure_extensions(exts, aliases, build_summary)

     exts = configure_special_extensions(exts, build_summary)

     exts = maybe_add_numpy_include(exts)

     exts = maybe_cythonize(exts)
 

     classifiers = """\
         Development Status :: 5 - Production/Stable
         Intended Audience :: Science/Research
         Intended Audience :: Developers
         Programming Language :: Python :: 3 :: Only
         Topic :: Software Development
         Topic :: Scientific/Engineering
         Operating System :: POSIX
         Operating System :: Unix
         Operating System :: MacOS :: MacOS X
         Operating System :: Microsoft :: Windows"""
 

     packages = find_packages('.')

     setup(name='kwant',

           version=version,

           author='C. W. Groth (CEA), M. Wimmer, '
                  'A. R. Akhmerov, X. Waintal (CEA), and others',

           author_email='authors@kwant-project.org',

           description=("Package for numerical quantum transport calculations "

                        "(Python 3 version)"),

           long_description=long_description(),
           platforms=["Unix", "Linux", "Mac OS-X", "Windows"],

           url="http://kwant-project.org/",
           license="BSD",

           packages=packages,
           package_data={p: ['*.pxd', '*.h'] for p in packages},

           cmdclass={'build': build,
                     'sdist': sdist,
                     'build_ext': build_ext,

                     'test': test},

           ext_modules=exts,

           install_requires=['numpy >= 1.13.3', 'scipy >= 0.19.1',

                             'tinyarray >= 1.2'],

           extras_require={

               # The oldest versions between: Debian stable, Ubuntu LTS

               'plotting': ['matplotlib >= 2.1.1',
                            'plotly >= 2.2.2'],

               'continuum': 'sympy >= 1.1.1',

               # qsymm is only packaged on PyPI

               'qsymm': 'qsymm >= 1.2.6',

           },

           classifiers=[c.strip() for c in classifiers.split('\n')])

 if __name__ == '__main__':
     main()