''' Distutils / setuptools helpers

'''

import os

import sys

from os.path import join as pjoin, split as psplit, splitext, dirname, exists

import tempfile

import shutil

from distutils.version import LooseVersion

from distutils.command.install_scripts import install_scripts

from distutils.errors import CompileError, LinkError

from distutils import log

BAT_TEMPLATE = \

r"""@echo off

REM wrapper to use shebang first line of {FNAME}

set mypath=%~dp0

set pyscript="%mypath%{FNAME}"

set /p line1=<%pyscript%

if "%line1:~0,2%" == "#!" (goto :goodstart)

echo First line of %pyscript% does not start with "#!"

exit /b 1

:goodstart

set py_exe=%line1:~2%

REM quote exe in case of spaces in path name

set py_exe="%py_exe%"

call %py_exe% %pyscript% %*

"""

# Path of file to which to write C conditional vars from build-time checks

CONFIG_H = pjoin('build', 'config.h')

# File name (no directory) to which to write Python vars from build-time checks

CONFIG_PY = '__config__.py'

# Directory to which to write libraries for building

LIB_DIR_TMP = pjoin('build', 'extra_libs')

class install_scripts_bat(install_scripts):

""" Make scripts executable on Windows

Scripts are bare file names without extension on Unix, fitting (for example)

Debian rules. They identify as python scripts with the usual ``#!`` first

line. Unix recognizes and uses this first "shebang" line, but Windows does

not. So, on Windows only we add a ``.bat`` wrapper of name

``bare_script_name.bat`` to call ``bare_script_name`` using the python

interpreter from the #! first line of the script.

Notes

-----

See discussion at

http://matthew-brett.github.com/pydagogue/installing_scripts.html and

example at git://github.com/matthew-brett/myscripter.git for more

background.

"""

def run(self):

install_scripts.run(self)

if not os.name == "nt":

return

for filepath in self.get_outputs():

# If we can find an executable name in the #! top line of the script

# file, make .bat wrapper for script.

with open(filepath, 'rt') as fobj:

first_line = fobj.readline()

if not (first_line.startswith('#!') and

'python' in first_line.lower()):

log.info("No #!python executable found, skipping .bat "

"wrapper")

continue

pth, fname = psplit(filepath)

froot, ext = splitext(fname)

bat_file = pjoin(pth, froot + '.bat')

bat_contents = BAT_TEMPLATE.replace('{FNAME}', fname)

log.info("Making %s wrapper for %s" % (bat_file, filepath))

if self.dry_run:

continue

with open(bat_file, 'wt') as fobj:

fobj.write(bat_contents)

def add_flag_checking(build_ext_class, flag_defines, top_package_dir=''):

""" Override input `build_ext_class` to check compiler `flag_defines`

Parameters

----------

build_ext_class : class

Class implementing ``distutils.command.build_ext.build_ext`` interface,

with a ``build_extensions`` method.

flag_defines : sequence

A sequence of elements, where the elements are sequences of length 4

consisting of (``compile_flags``, ``link_flags``, ``code``,

``defvar``). ``compile_flags`` is a sequence of compiler flags;

``link_flags`` is a sequence of linker flags. We

check ``compile_flags`` to see whether a C source string ``code`` will

compile, and ``link_flags`` to see whether the resulting object file

will link. If both compile and link works, we add ``compile_flags`` to

``extra_compile_args`` and ``link_flags`` to ``extra_link_args`` of

each extension when we build the extensions. If ``defvar`` is not

None, it is the name of C variable to be defined in ``build/config.h``

with 1 if the combination of (``compile_flags``, ``link_flags``,

``code``) will compile and link, 0 otherwise. If None, do not write

variable.

top_package_dir : str

String giving name of top-level package, for writing Python file

containing configuration variables. If empty, do not write this file.

Variables written are the same as the Cython variables generated via

the `flag_defines` setting.

Returns

-------

checker_class : class

A class with similar interface to

``distutils.command.build_ext.build_ext``, that adds all working

``compile_flags`` values to the ``extra_compile_args`` and working

``link_flags`` to ``extra_link_args`` attributes of extensions, before

compiling.

"""

class Checker(build_ext_class):

flag_defs = tuple(flag_defines)

def can_compile_link(self, compile_flags, link_flags, code):

cc = self.compiler

fname = 'test.c'

cwd = os.getcwd()

tmpdir = tempfile.mkdtemp()

try:

os.chdir(tmpdir)

with open(fname, 'wt') as fobj:

fobj.write(code)

try:

objects = cc.compile([fname],

extra_postargs=compile_flags)

except CompileError:

return False

try:

# Link shared lib rather then executable to avoid

# http://bugs.python.org/issue4431 with MSVC 10+

cc.link_shared_lib(objects, "testlib",

extra_postargs=link_flags)

except (LinkError, TypeError):

return False

finally:

os.chdir(cwd)

shutil.rmtree(tmpdir)

return True

def build_extensions(self):

""" Hook into extension building to check compiler flags """

def_vars = []

good_compile_flags = []

good_link_flags = []

config_dir = dirname(CONFIG_H)

for compile_flags, link_flags, code, def_var in self.flag_defs:

compile_flags = list(compile_flags)

link_flags = list(link_flags)

flags_good = self.can_compile_link(compile_flags,

link_flags,

code)

if def_var:

def_vars.append((def_var, flags_good))

if flags_good:

good_compile_flags += compile_flags

good_link_flags += link_flags

else:

log.warn("Flags {0} omitted because of compile or link "

"error".format(compile_flags + link_flags))

if def_vars: # write config.h file

if not exists(config_dir):

self.mkpath(config_dir)

with open(CONFIG_H, 'wt') as fobj:

fobj.write('/* Automatically generated; do not edit\n')

fobj.write(' C defines from build-time checks */\n')

for v_name, v_value in def_vars:

fobj.write('int {0} = {1};\n'.format(

v_name, 1 if v_value else 0))

if def_vars and top_package_dir: # write __config__.py file

config_py_dir = (top_package_dir if self.inplace else

pjoin(self.build_lib, top_package_dir))

if not exists(config_py_dir):

self.mkpath(config_py_dir)

config_py = pjoin(config_py_dir, CONFIG_PY)

with open(config_py, 'wt') as fobj:

fobj.write('# Automatically generated; do not edit\n')

fobj.write('# Variables from compile checks\n')

for v_name, v_value in def_vars:

fobj.write('{0} = {1}\n'.format(v_name, v_value))

if def_vars or good_compile_flags or good_link_flags:

for ext in self.extensions:

ext.extra_compile_args += good_compile_flags

ext.extra_link_args += good_link_flags

if def_vars:

ext.include_dirs.append(config_dir)

build_ext_class.build_extensions(self)

return Checker

def get_pkg_version(pkg_name):

""" Return package version for `pkg_name` if installed

Returns

-------

pkg_version : str or None

Return None if package not importable. Return 'unknown' if standard

``__version__`` string not present. Otherwise return version string.

"""

try:

pkg = __import__(pkg_name)

except ImportError:

return None

try:

return pkg.__version__

except AttributeError:

return 'unknown'

def version_error_msg(pkg_name, found_ver, min_ver):

""" Return informative error message for version or None

"""

if found_ver is None:

return 'We need package {0}, but not importable'.format(pkg_name)

if found_ver == 'unknown':

return 'We need {0} version {1}, but cannot get version'.format(

pkg_name, min_ver)

if LooseVersion(found_ver) >= LooseVersion(min_ver):

return None

return 'We need {0} version {1}, but found version {2}'.format(

pkg_name, found_ver, min_ver)

class SetupDependency(object):

""" SetupDependency class

Parameters

----------

import_name : str

Name with which required package should be ``import``ed.

min_ver : str

Distutils version string giving minimum version for package.

req_type : {'install_requires', 'setup_requires'}, optional

Setuptools dependency type.

heavy : {False, True}, optional

If True, and package is already installed (importable), then do not add

to the setuptools dependency lists. This prevents setuptools

reinstalling big packages when the package was installed without using

setuptools, or this is an upgrade, and we want to avoid the pip default

behavior of upgrading all dependencies.

install_name : str, optional

Name identifying package to install from pypi etc, if different from

`import_name`.

"""

def __init__(self, import_name,

min_ver,

req_type='install_requires',

heavy=False,

install_name=None):

self.import_name = import_name

self.min_ver = min_ver

self.req_type = req_type

self.heavy = heavy

self.install_name = (import_name if install_name is None

else install_name)

def check_fill(self, setuptools_kwargs):

""" Process this dependency, maybe filling `setuptools_kwargs`

Run checks on this dependency. If not using setuptools, then raise

error for unmet dependencies. If using setuptools, add missing or

not-heavy dependencies to `setuptools_kwargs`.

A heavy dependency is one that is inconvenient to install

automatically, such as numpy or (particularly) scipy, matplotlib.

Parameters

----------

setuptools_kwargs : dict

Dictionary of setuptools keyword arguments that may be modified

in-place while checking dependencies.

"""

found_ver = get_pkg_version(self.import_name)

ver_err_msg = version_error_msg(self.import_name,

found_ver,

self.min_ver)

if not 'setuptools' in sys.modules:

# Not using setuptools; raise error for any unmet dependencies

if ver_err_msg is not None:

raise RuntimeError(ver_err_msg)

return

# Using setuptools; add packages to given section of

# setup/install_requires, unless it's a heavy dependency for which we

# already have an acceptable importable version.

if self.heavy and ver_err_msg is None:

return

new_req = '{0}>={1}'.format(self.import_name, self.min_ver)

old_reqs = setuptools_kwargs.get(self.req_type, [])

setuptools_kwargs[self.req_type] = old_reqs + [new_req]

class Bunch(object):

def __init__(self, vars):

for key, name in vars.items():

if key.startswith('__'):

continue

self.__dict__[key] = name

def read_vars_from(ver_file):

""" Read variables from Python text file

Parameters

----------

ver_file : str

Filename of file to read

Returns

-------

info_vars : Bunch instance

Bunch object where variables read from `ver_file` appear as

attributes

"""

# Use exec for compabibility with Python 3

ns = {}

with open(ver_file, 'rt') as fobj:

exec(fobj.read(), ns)

return Bunch(ns)

def make_np_ext_builder(build_ext_class):

""" Override input `build_ext_class` to add numpy includes to extension

This is useful to delay call of ``np.get_include`` until the extension is

being built.

Parameters

----------

build_ext_class : class

Class implementing ``distutils.command.build_ext.build_ext`` interface,

with a ``build_extensions`` method.

Returns

-------

np_build_ext_class : class

A class with similar interface to

``distutils.command.build_ext.build_ext``, that adds libraries in

``np.get_include()`` to include directories of extension.

"""

class NpExtBuilder(build_ext_class):

def build_extensions(self):

""" Hook into extension building to add np include dirs

"""

# Delay numpy import until last moment

import numpy as np

for ext in self.extensions:

ext.include_dirs.append(np.get_include())

build_ext_class.build_extensions(self)

return NpExtBuilder