setup.py

#!/usr/bin/env python
"""Welcome to PyNE's setup.py script. This is a little non-standard because pyne
is a multilanguage project.  Still this script follows a predictable ordering:

1. Parse command line arguments,
2. Call cmake from the 'build' directory
3. Call make from the 'build' directory
4. Use distutils/setuptools from the 'build' directory

This gives us the best of both worlds. Compiled code is installed with cmake/make
and Cython/Python code is installed with normal Python tools. The only trick here is
how the various command line arguments are handed off to the three sub-processes.

To accomplish this we use argparser groups to group command line arguments based on
whether they go to:

1. the setup() function,
2. cmake,
3. make, or
4. other - typically used for args that apply to multiple other groups or
   modify the environment in some way.

To add a new command line argument, first add it to the appropriate group in the
``parse_args()`` function.  Then, modify the logic in the corresponding
``parse_setup()``, ``parse_cmake()``, ``parse_make()``, or ``parse_others()``
functions to consume your new command line argument.  It is OK for more than
one of the parser functions to consume the argument. Where appropriate,
ensure that the argument is appended to the argument list that is returned by these
functions.
"""

from __future__ import print_function
import numpy as np
import io
import os
import re
import sys
import imp
import ssl
import shutil
import tarfile
import argparse
import platform
import warnings
import subprocess
from glob import glob
from distutils import core, dir_util, sysconfig
from contextlib import contextmanager

if sys.version_info[0] < 3:
    from urllib import urlopen
else:
    from urllib.request import urlopen


# import src into pythonpath - needed to actually run decaygen/atomicgen
if "." not in sys.path:
    sys.path.append(os.getcwd() + "/src")


def absexpanduser(x):
    return os.path.abspath(os.path.expanduser(x))


IS_NT = os.name == "nt"
LOCALDIR = absexpanduser("~/.local")
CMAKE_BUILD_TYPES = {
    "none": "None",
    "debug": "Debug",
    "release": "Release",
    "relwithdebinfo": "RelWithDebInfo",
    "minsizerel": "MinSizeRel",
}
ON_DARWIN = platform.system() == "Darwin"
LIBEXT = ".dylib" if ON_DARWIN else ".so"

SKIP_OPTION = "SKIP"


@contextmanager
def indir(path):
    orig = os.getcwd()
    os.chdir(path)
    yield
    os.chdir(orig)


@contextmanager
def cleanpypath(path):
    orig = sys.path
    sys.path = [p for p in sys.path if p != path]
    yield
    sys.path = orig


def assert_np_version():
    low = (1, 8)
    v = np.version.short_version
    cur = tuple(map(int, v.split(".")[:2]))
    if cur < low:
        msg = "numpy version too low! {0} (have) < 1.8.0 (min)".format(v)
        raise ValueError(msg)


def assert_ubuntu_version():
    v = platform.uname()
    for itm in v:
        if "precise" in itm:
            msg = (
                "ubuntu 12/precise packages may be outdated, it is highly "
                "recommended to update to ubuntu 14 LTS."
            )
            warnings.warn(msg, Warning)


def assert_dep_versions():
    assert_np_version()
    assert_ubuntu_version()


def ssl_context():
    # this is compitble for both Python 2 & 3
    # on Python 3, you can do just ssl.SSLContext()
    ctx = ssl.create_default_context()
    ctx.check_hostname = False
    ctx.verify_mode = ssl.CERT_NONE
    return ctx


DECAY_H = os.path.join("src", "decay.h")
DECAY_CPP = os.path.join("src", "decay.cpp")
DECAY_S = glob("src/decay*.s")
DECAY_H_REP = os.path.join("src", "_decay.h")
DECAY_CPP_REP = os.path.join("src", "_decay.cpp")
DECAY_URL = "http://raw.githubusercontent.com/pyne/data/master/decay.tar.gz"


CRAM_H = os.path.join("src", "cram.h")
CRAM_C = os.path.join("src", "cram.c")
CRAM_S = glob("src/cram*.s")
CRAM_URL = "http://raw.githubusercontent.com/pyne/data/master/cram.tar.gz"


local_ensdf_evaluators = [
    "alphad",
    "delta",
    "gtol",
    "bldhst",
    "hsicc",
    "hsmrg",
    "seqhst",
    "logft",
    "radd",
    "ruler",
]
local_ensdf_tools = [
    ["ensdf_processing/RADD/98AK04.in", "98AK04.in"],
    ["ensdf_processing/RADD/ELE.in", "ELE.in"],
]


def copy_ensdf_executables(exe_dest):
    print("Copying ENSDF Executables to install directory")
    # Hack for copying the executables the first time PyNE is installed, before
    # pyne has been added to the python path.
    if exe_dest[-4:] != "pyne":
        exe_dest = sysconfig.get_python_lib()
        for f in os.listdir(sysconfig.get_python_lib()):
            if re.match("pyne", f):
                exe_dest = exe_dest + "/" + f
        exe_dest = exe_dest + "/pyne"
    for tool in local_ensdf_evaluators:
        try:
            local_path = os.path.join("build", os.path.join("src", tool))
            dest_path = os.path.join(exe_dest, tool)
            shutil.copy(local_path, dest_path)
        except Exception:
            print(
                "Some ENSDF processing executables were unable to be copied to the \
                   install directory."
            )
    for tool in local_ensdf_tools:
        try:
            local_path = os.path.join("src", tool[0])
            dest_path = os.path.join(exe_dest, tool[1])
            shutil.copy(local_path, dest_path)
        except Exception:
            print(
                "Some ENSDF processing executables were unable to be copied to the \
                   install directory."
            )


ATOMIC_H = os.path.join("src", "atomic_data.h")
ATOMIC_CPP = os.path.join("src", "atomic_data.cpp")
ATOMIC_H_UNDER = os.path.join("src", "_atomic_data.h")
ATOMIC_CPP_UNDER = os.path.join("src", "_atomic_data.cpp")


def generate_atomic():
    with indir("src"):
        try:
            import atomicgen
        except ImportError:
            return False
        try:
            atomicgen.main()
        except Exception:
            return False
    return True


def ensure_atomic():
    # generate the data
    generated = generate_atomic()
    if generated:
        return
    # last resort - if generate atomic failed, use the backup
    if not os.path.isfile(ATOMIC_H) and not os.path.isfile(ATOMIC_CPP):
        print("!!! Could not generate atomic data, using backup.")
        shutil.copy(ATOMIC_H_UNDER, ATOMIC_H)
        shutil.copy(ATOMIC_CPP_UNDER, ATOMIC_CPP)


def ensure_nuc_data():
    import tempfile

    tdir = tempfile.gettempdir()
    with cleanpypath("."), cleanpypath(os.getcwd()), indir(tdir):
        from pyne.dbgen import nuc_data_make
        from pyne.dbgen.api import build_dir

        bdir = os.path.join(os.getcwd(), "build", build_dir)
        nuc_data_make.main(args=["-b", bdir])


def update_setup_args(ns):
    if ns.user and ns.prefix is None:
        ns.prefix = LOCALDIR
    elif ns.prefix is not None:
        pass
    else:
        ns.prefix = sys.prefix

    files = [DECAY_H, DECAY_CPP, CRAM_H, CRAM_C] + DECAY_S + CRAM_S
    if ns.cmd == "clean":
        if os.path.exists(ns.build_dir):
            dir_util.remove_tree(ns.build_dir)
        for f in files:
            if os.path.isfile(f):
                print("deleting " + f)
                os.remove(f)
        print("build directory cleaned ... exiting")
        sys.exit()
    if ns.clean:
        if os.path.exists(ns.build_dir):
            dir_util.remove_tree(ns.build_dir)
        for f in files:
            if os.path.isfile(f):
                print("deleting " + f)
                os.remove(f)


def update_cmake_args(ns):
    ns.cmake_args = ["-DCMAKE_INSTALL_PREFIX=" + ns.prefix]
    if ns.D is not None:
        ns.cmake_args += ["-D" + x for x in ns.D]
    if ns.build_type is not None:
        bt = CMAKE_BUILD_TYPES[ns.build_type.lower()]
        ns.cmake_args.append("-DCMAKE_BUILD_TYPE=" + bt)
    if ns.hdf5 is not None:
        h5root = absexpanduser(ns.hdf5)
        ns.cmake_args += [
            "-DHDF5_ROOT=" + h5root,
            "-DHDF5_LIBRARIES={0}/lib/libhdf5{1};{0}/lib/libhdf5_hl{1}".format(
                h5root, LIBEXT
            ),
            "-DHDF5_LIBRARY_DIRS=" + h5root + "/lib",
            "-DHDF5_INCLUDE_DIRS=" + h5root + "/include",
        ]
    if ns.moab is not SKIP_OPTION:
        ns.cmake_args.append("-DWITH_MOAB=ON")
        if ns.moab is not None:
            ns.cmake_args.append("-DMOAB_ROOT=" + absexpanduser(ns.moab))

    if ns.dagmc is not SKIP_OPTION:
        assert ns.moab is not SKIP_OPTION, (
            "If the --dagmc option is present," " --moab must be as well"
        )
        ns.cmake_args.append("-DWITH_DAGMC=ON")
        if ns.dagmc is not None:
            ns.cmake_args.append("-DDAGMC_ROOT=" + absexpanduser(ns.dagmc))

    if ns.deps_root:
        ns.cmake_args.append("-DDEPS_ROOT_DIR=" + absexpanduser(ns.deps_root))
    if ns.fast is not None:
        fast = "TRUE" if ns.fast else "FALSE"
        ns.cmake_args.append("-DPYNE_FAST_COMPILE=" + fast)
    if ns.spatial_solvers is not None:
        spatial_solvers = "ON" if ns.spatial_solvers else "OFF"
        ns.cmake_args.append("-DENABLE_SPATIAL_SOLVERS=" + spatial_solvers)


def update_make_args(ns):
    ns.make_args = []
    if ns.j is not None:
        ns.make_args.append("-j" + ns.j)


def update_other_args(ns):
    if ns.hdf5 is not None:
        os.environ["HDF5_ROOT"] = ns.hdf5
    if ns.moab is not None:
        os.environ["MOAB_ROOT"] = ns.moab
    if ns.dagmc is not None:
        os.environ["DAGMC_ROOT"] = ns.dagmc


def parse_args():
    # needed for backwards compat.
    argv = [a for a in sys.argv[1:] if a != "--"]
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--clean",
        nargs="?",
        const=True,
        default=False,
        help="removes the build directory before continuing.",
    )
    parser.add_argument(
        "--user", nargs="?", const=True, default=False, help="Installs into ~/.local"
    )

    setup = parser.add_argument_group("setup", "Normal setup.py arguments")
    setup.add_argument(
        "cmd", help="command to send to normal setup, e.g. " "install or build."
    )
    setup.add_argument("--egg-base", help="does nothing, for compatability")

    cmake = parser.add_argument_group("cmake", "CMake arguments.")
    cmake.add_argument(
        "-D", metavar="VAR", action="append", help="Set environment variable."
    )
    cmake.add_argument(
        "--build-type",
        metavar="BT",
        help="Set build type via CMAKE_BUILD_TYPE, " "e.g. Release or Debug.",
    )
    cmake.add_argument(
        "--deps-root",
        default=None,
        dest="deps_root",
        help="the path to the directory containing " "all dependencies",
    )
    cmake.add_argument(
        "--fast",
        default=None,
        dest="fast",
        action="store_true",
        help="Will try to compile "
        "from assembly, if possible. This is faster than "
        "compiling from source (default).",
    )
    cmake.add_argument(
        "--slow",
        dest="fast",
        action="store_false",
        help="Will NOT try to compile "
        "from assembly, if possible. This is slower as it "
        "must compile from source.",
    )

    make = parser.add_argument_group("make", "Make arguments.")
    make.add_argument("-j", help="Degree of parallelism for build.")

    other = parser.add_argument_group("other", "Miscellaneous arguments.")
    other.add_argument("--hdf5", help="Path to HDF5 root directory.")
    other.add_argument(
        "--moab", help="Path to MOAB root directory.", nargs="?", default=SKIP_OPTION
    )
    other.add_argument(
        "--dagmc", help="Path to DAGMC root directory.", nargs="?", default=SKIP_OPTION
    )
    other.add_argument("--prefix", help="Prefix for install location.", default=None)
    other.add_argument(
        "--build-dir",
        default="build",
        dest="build_dir",
        help="where to place the build directory",
    )
    other.add_argument(
        "--bootstrap",
        default=False,
        action="store_true",
        help="Bootstraps the PyNE installation, including "
        "nuc_data_make and possibly decaygen.",
    )
    other.add_argument(
        "--spatial_solvers",
        default=True,
        action="store_true",
        help="Build spatial solvers (Default)",
    )
    other.add_argument(
        "--no_spatial_solvers",
        action="store_false",
        dest="spatial_solvers",
        help="Do NOT build spatial solvers",
    )

    ns = parser.parse_args(argv)
    update_setup_args(ns)
    update_cmake_args(ns)
    update_make_args(ns)
    update_other_args(ns)
    return ns


def cmake_cli(cmake_args):
    if not IS_NT:
        rtn = subprocess.call(["which", "cmake"])
        if rtn != 0:
            sys.exit("CMake is not installed, aborting PyNE build.")
    cmake_cmd = ["cmake", ".."] + cmake_args
    cmake_cmd += ["-DPYTHON_EXECUTABLE=" + sys.executable]
    cmake_cmdstr = cmake_cmd if isinstance(cmake_cmd, str) else " ".join(cmake_cmd)
    print("CMake command is\n", cmake_cmdstr, sep="")
    return cmake_cmd


def main_body(ns):
    assert_dep_versions()
    ensure_atomic()
    if not os.path.exists(ns.build_dir):
        os.mkdir(ns.build_dir)
    cmake_cmd = cmake_cli(ns.cmake_args)
    rtn = subprocess.check_call(cmake_cmd, cwd=ns.build_dir, shell=IS_NT)
    rtn = subprocess.check_call(["make"] + ns.make_args, cwd=ns.build_dir)
    if ns.cmd == "install":
        rtn = subprocess.check_call(["make", "install"], cwd=ns.build_dir)


def final_message(success=True):
    if success:
        return
    msg = (
        "\n\nIf you are having issues building pyne, please report your problem "
        "to pyne-dev@googlegroups.com or look for help at http://pyne.io\n\n"
    )
    print("\n" + "-" * 20 + msg + "-" * 20)


def main_safe(ns):
    success = False
    try:
        main_body(ns)
        success = True
    finally:
        final_message(success)


def main():
    ns = parse_args()
    main_safe(ns)
    if ns.bootstrap:
        ensure_nuc_data()
        main_safe(ns)
    binpath = ns.prefix + "/bin"
    msg = (
        "\nNOTE: If you have not done so already, please be sure that your "
        "PATH has been appropriately set to the install prefix of pyne. "
        "For this install of pyne you may add the following lines to your "
        "'~/.bashrc' file or equivalent:\n\n"
        "  # PyNE Environment Settings\n\n"
        '  export PATH="{binpath}:${{PATH}}"'
    ).format(binpath=binpath)
    print(msg, file=sys.stderr)


if __name__ == "__main__":
    main()