DEP: Remove scons related files and code.

This removes files and code supporting scons builds. After this change
numpy will only support builds using distutils or bento. The removal of
scons has been discussed on the list several times and a decision has been
made that scons support is no longer needed. This was originally discussed
for numpy 1.7 and because the distutils and bento methods are still
available we are skipping the usual deprecation period.

1 files changed, 0 insertions, 589 deletions

diff --git a/numpy/distutils/command/scons.py b/numpy/distutils/command/scons.py
deleted file mode 100644
index d7bbec35e..000000000
--- a/numpy/distutils/command/scons.py
+++ /dev/null
@@ -1,589 +0,0 @@
-import os
-import sys
-import os.path
-from os.path import join as pjoin, dirname as pdirname
-
-from distutils.errors import DistutilsPlatformError
-from distutils.errors import DistutilsExecError, DistutilsSetupError
-
-from numpy.distutils.command.build_ext import build_ext as old_build_ext
-from numpy.distutils.ccompiler import CCompiler, new_compiler
-from numpy.distutils.fcompiler import FCompiler, new_fcompiler
-from numpy.distutils.exec_command import find_executable
-from numpy.distutils import log
-from numpy.distutils.misc_util import is_bootstrapping, get_cmd
-from numpy.distutils.misc_util import get_numpy_include_dirs as _incdir
-from numpy.distutils.compat import get_exception
-
-# A few notes:
-#   - numscons is not mandatory to build numpy, so we cannot import it here.
-#   Any numscons import has to happen once we check numscons is available and
-#   is required for the build (call through setupscons.py or native numscons
-#   build).
-def get_scons_build_dir():
-    """Return the top path where everything produced by scons will be put.
-
-    The path is relative to the top setup.py"""
-    from numscons import get_scons_build_dir
-    return get_scons_build_dir()
-
-def get_scons_pkg_build_dir(pkg):
-    """Return the build directory for the given package (foo.bar).
-
-    The path is relative to the top setup.py"""
-    from numscons.core.utils import pkg_to_path
-    return pjoin(get_scons_build_dir(), pkg_to_path(pkg))
-
-def get_scons_configres_dir():
-    """Return the top path where everything produced by scons will be put.
-
-    The path is relative to the top setup.py"""
-    from numscons import get_scons_configres_dir
-    return get_scons_configres_dir()
-
-def get_scons_configres_filename():
-    """Return the top path where everything produced by scons will be put.
-
-    The path is relative to the top setup.py"""
-    from numscons import get_scons_configres_filename
-    return get_scons_configres_filename()
-
-def get_scons_local_path():
-    """This returns the full path where scons.py for scons-local is located."""
-    from numscons import get_scons_path
-    return get_scons_path()
-
-def _get_top_dir(pkg):
-    # XXX: this mess is necessary because scons is launched per package, and
-    # has no knowledge outside its build dir, which is package dependent. If
-    # one day numscons does not launch one process/package, this will be
-    # unnecessary.
-    from numscons import get_scons_build_dir
-    from numscons.core.utils import pkg_to_path
-    scdir = pjoin(get_scons_build_dir(), pkg_to_path(pkg))
-    n = scdir.count(os.sep)
-    return os.sep.join([os.pardir for i in range(n+1)])
-
-def get_distutils_libdir(cmd, pkg):
-    """Returns the path where distutils install libraries, relatively to the
-    scons build directory."""
-    return pjoin(_get_top_dir(pkg), cmd.build_lib)
-
-def get_distutils_clibdir(cmd, pkg):
-    """Returns the path where distutils put pure C libraries."""
-    return pjoin(_get_top_dir(pkg), cmd.build_clib)
-
-def get_distutils_install_prefix(pkg, inplace):
-    """Returns the installation path for the current package."""
-    from numscons.core.utils import pkg_to_path
-    if inplace == 1:
-        return pkg_to_path(pkg)
-    else:
-        install_cmd = get_cmd('install').get_finalized_command('install')
-        return pjoin(install_cmd.install_libbase, pkg_to_path(pkg))
-
-def get_python_exec_invoc():
-    """This returns the python executable from which this file is invocated."""
-    # Do we  need to take into account the PYTHONPATH, in a cross platform way,
-    # that is the string returned can be executed directly on supported
-    # platforms, and the sys.path of the executed python should be the same
-    # than the caller ? This may not be necessary, since os.system is said to
-    # take into accound os.environ. This actually also works for my way of
-    # using "local python", using the alias facility of bash.
-    return sys.executable
-
-def get_numpy_include_dirs(sconscript_path):
-    """Return include dirs for numpy.
-
-    The paths are relatively to the setup.py script path."""
-    from numscons import get_scons_build_dir
-    scdir = pjoin(get_scons_build_dir(), pdirname(sconscript_path))
-    n = scdir.count(os.sep)
-
-    dirs = _incdir()
-    rdirs = []
-    for d in dirs:
-        rdirs.append(pjoin(os.sep.join([os.pardir for i in range(n+1)]), d))
-    return rdirs
-
-def dirl_to_str(dirlist):
-    """Given a list of directories, returns a string where the paths are
-    concatenated by the path separator.
-
-    example: ['foo/bar', 'bar/foo'] will return 'foo/bar:bar/foo'."""
-    return os.pathsep.join(dirlist)
-
-def dist2sconscc(compiler):
-    """This converts the name passed to distutils to scons name convention (C
-    compiler). compiler should be a CCompiler instance.
-
-    Example:
-        --compiler=intel -> intelc"""
-    compiler_type = compiler.compiler_type
-    if compiler_type == 'msvc':
-        return 'msvc'
-    elif compiler_type == 'intel':
-        return 'intelc'
-    else:
-        return compiler.compiler[0]
-
-def dist2sconsfc(compiler):
-    """This converts the name passed to distutils to scons name convention
-    (Fortran compiler). The argument should be a FCompiler instance.
-
-    Example:
-        --fcompiler=intel -> ifort on linux, ifl on windows"""
-    if compiler.compiler_type == 'intel':
-        #raise NotImplementedError('FIXME: intel fortran compiler name ?')
-        return 'ifort'
-    elif compiler.compiler_type == 'gnu':
-        return 'g77'
-    elif compiler.compiler_type == 'gnu95':
-        return 'gfortran'
-    elif compiler.compiler_type == 'sun':
-        return 'sunf77'
-    else:
-        # XXX: Just give up for now, and use generic fortran compiler
-        return 'fortran'
-
-def dist2sconscxx(compiler):
-    """This converts the name passed to distutils to scons name convention
-    (C++ compiler). The argument should be a Compiler instance."""
-    if compiler.compiler_type == 'msvc':
-        return compiler.compiler_type
-
-    return compiler.compiler_cxx[0]
-
-def get_compiler_executable(compiler):
-    """For any give CCompiler instance, this gives us the name of C compiler
-    (the actual executable).
-
-    NOTE: does NOT work with FCompiler instances."""
-    # Geez, why does distutils has no common way to get the compiler name...
-    if compiler.compiler_type == 'msvc':
-        # this is harcoded in distutils... A bit cleaner way would be to
-        # initialize the compiler instance and then get compiler.cc, but this
-        # may be costly: we really just want a string.
-        # XXX: we need to initialize the compiler anyway, so do not use
-        # hardcoded string
-        #compiler.initialize()
-        #print compiler.cc
-        return 'cl.exe'
-    else:
-        return compiler.compiler[0]
-
-def get_f77_compiler_executable(compiler):
-    """For any give FCompiler instance, this gives us the name of F77 compiler
-    (the actual executable)."""
-    return compiler.compiler_f77[0]
-
-def get_cxxcompiler_executable(compiler):
-    """For any give CCompiler instance, this gives us the name of CXX compiler
-    (the actual executable).
-
-    NOTE: does NOT work with FCompiler instances."""
-    # Geez, why does distutils has no common way to get the compiler name...
-    if compiler.compiler_type == 'msvc':
-        # this is harcoded in distutils... A bit cleaner way would be to
-        # initialize the compiler instance and then get compiler.cc, but this
-        # may be costly: we really just want a string.
-        # XXX: we need to initialize the compiler anyway, so do not use
-        # hardcoded string
-        #compiler.initialize()
-        #print compiler.cc
-        return 'cl.exe'
-    else:
-        return compiler.compiler_cxx[0]
-
-def get_tool_path(compiler):
-    """Given a distutils.ccompiler.CCompiler class, returns the path of the
-    toolset related to C compilation."""
-    fullpath_exec = find_executable(get_compiler_executable(compiler))
-    if fullpath_exec:
-        fullpath = pdirname(fullpath_exec)
-    else:
-        raise DistutilsSetupError("Could not find compiler executable info for scons")
-    return fullpath
-
-def get_f77_tool_path(compiler):
-    """Given a distutils.ccompiler.FCompiler class, returns the path of the
-    toolset related to F77 compilation."""
-    fullpath_exec = find_executable(get_f77_compiler_executable(compiler))
-    if fullpath_exec:
-        fullpath = pdirname(fullpath_exec)
-    else:
-        raise DistutilsSetupError("Could not find F77 compiler executable "\
-                "info for scons")
-    return fullpath
-
-def get_cxx_tool_path(compiler):
-    """Given a distutils.ccompiler.CCompiler class, returns the path of the
-    toolset related to C compilation."""
-    fullpath_exec = find_executable(get_cxxcompiler_executable(compiler))
-    if fullpath_exec:
-        fullpath = pdirname(fullpath_exec)
-    else:
-        raise DistutilsSetupError("Could not find compiler executable info for scons")
-    return fullpath
-
-def protect_path(path):
-    """Convert path (given as a string) to something the shell will have no
-    problem to understand (space, etc... problems)."""
-    if path:
-        # XXX: to this correctly, this is totally bogus for now (does not check for
-        # already quoted path, for example).
-        return '"' + path + '"'
-    else:
-        return '""'
-
-def parse_package_list(pkglist):
-    return pkglist.split(",")
-
-def find_common(seq1, seq2):
-    """Given two list, return the index of the common items.
-
-    The index are relative to seq1.
-
-    Note: do not handle duplicate items."""
-    dict2 = dict([(i, None) for i in seq2])
-
-    return [i for i in range(len(seq1)) if dict2.has_key(seq1[i])]
-
-def select_packages(sconspkg, pkglist):
-    """Given a list of packages in pkglist, return the list of packages which
-    match this list."""
-    common = find_common(sconspkg, pkglist)
-    if not len(common) == len(pkglist):
-        msg = "the package list contains a package not found in "\
-              "the current list. The current list is %s" % sconspkg
-        raise ValueError(msg)
-    return common
-
-def check_numscons(minver):
-    """Check that we can use numscons.
-
-    minver is a 3 integers tuple which defines the min version."""
-    try:
-        import numscons
-    except ImportError:
-        e = get_exception()
-        raise RuntimeError("importing numscons failed (error was %s), using " \
-                           "scons within distutils is not possible without "
-                           "this package " % str(e))
-
-    try:
-        # version_info was added in 0.10.0
-        from numscons import version_info
-        # Stupid me used string instead of numbers in version_info in
-        # dev versions of 0.10.0
-        if isinstance(version_info[0], str):
-            raise ValueError("Numscons %s or above expected " \
-                             "(detected 0.10.0)" % str(minver))
-        # Stupid me used list instead of tuple in numscons
-        version_info = tuple(version_info)
-        if version_info[:3] < minver:
-            raise ValueError("Numscons %s or above expected (got %s) "
-                             % (str(minver), str(version_info[:3])))
-    except ImportError:
-        raise RuntimeError("You need numscons >= %s to build numpy "\
-                           "with numscons (imported numscons path " \
-                           "is %s)." % (minver, numscons.__file__))
-
-# XXX: this is a giantic mess. Refactor this at some point.
-class scons(old_build_ext):
-    # XXX: add an option to the scons command for configuration (auto/force/cache).
-    description = "Scons builder"
-
-    library_options = [
-        ('with-perflib=', None,
-         'Specify which performance library to use for BLAS/LAPACK/etc...' \
-         'Examples: mkl/atlas/sunper/accelerate'),
-        ('with-mkl-lib=', None, 'TODO'),
-        ('with-mkl-include=', None, 'TODO'),
-        ('with-mkl-libraries=', None, 'TODO'),
-        ('with-atlas-lib=', None, 'TODO'),
-        ('with-atlas-include=', None, 'TODO'),
-        ('with-atlas-libraries=', None, 'TODO')
-        ]
-    user_options = [
-        ('jobs=', 'j', "specify number of worker threads when executing" \
-                       "scons"),
-        ('inplace', 'i', 'If specified, build in place.'),
-        ('import-env', 'e', 'If specified, import user environment into scons env["ENV"].'),
-        ('bypass', 'b', 'Bypass distutils compiler detection (experimental).'),
-        ('scons-tool-path=', None, 'specify additional path '\
-        '(absolute) to look for scons tools'),
-        ('silent=', None, 'specify whether scons output should less verbose'\
-        '(1), silent (2), super silent (3) or not (0, default)'),
-        ('log-level=', None, 'specify log level for numscons. Any value ' \
-                             'valid for the logging python module is valid'),
-        ('package-list=', None,
-         'If specified, only run scons on the given '\
-         'packages (example: --package-list=scipy.cluster). If empty, '\
-         'no package is built'),
-        ('fcompiler=', None, "specify the Fortran compiler type"),
-        ('compiler=', None, "specify the C compiler type"),
-        ('cxxcompiler=', None,
-         "specify the C++ compiler type (same as C by default)"),
-        ('debug', 'g',
-         "compile/link with debugging information"),
-         ] + library_options
-
-    def initialize_options(self):
-        old_build_ext.initialize_options(self)
-        self.build_clib = None
-
-        self.debug = 0
-
-        self.compiler = None
-        self.cxxcompiler = None
-        self.fcompiler = None
-
-        self.jobs = None
-        self.silent = 0
-        self.import_env = 0
-        self.scons_tool_path = ''
-        # If true, we bypass distutils to find the c compiler altogether. This
-        # is to be used in desperate cases (like incompatible visual studio
-        # version).
-        self._bypass_distutils_cc = False
-
-        # scons compilers
-        self.scons_compiler = None
-        self.scons_compiler_path = None
-        self.scons_fcompiler = None
-        self.scons_fcompiler_path = None
-        self.scons_cxxcompiler = None
-        self.scons_cxxcompiler_path = None
-
-        self.package_list = None
-        self.inplace = 0
-        self.bypass = 0
-
-        # Only critical things
-        self.log_level = 50
-
-        # library options
-        self.with_perflib = []
-        self.with_mkl_lib = []
-        self.with_mkl_include = []
-        self.with_mkl_libraries = []
-        self.with_atlas_lib = []
-        self.with_atlas_include = []
-        self.with_atlas_libraries = []
-
-    def _init_ccompiler(self, compiler_type):
-        # XXX: The logic to bypass distutils is ... not so logic.
-        if compiler_type == 'msvc':
-            self._bypass_distutils_cc = True
-        try:
-            distutils_compiler = new_compiler(compiler=compiler_type,
-                          verbose=self.verbose,
-                          dry_run=self.dry_run,
-                          force=self.force)
-            distutils_compiler.customize(self.distribution)
-            # This initialization seems necessary, sometimes, for find_executable to work...
-            if hasattr(distutils_compiler, 'initialize'):
-                distutils_compiler.initialize()
-            self.scons_compiler = dist2sconscc(distutils_compiler)
-            self.scons_compiler_path = protect_path(get_tool_path(distutils_compiler))
-        except DistutilsPlatformError:
-            e = get_exception()
-            if not self._bypass_distutils_cc:
-                raise e
-            else:
-                self.scons_compiler = compiler_type
-
-    def _init_fcompiler(self, compiler_type):
-        self.fcompiler = new_fcompiler(compiler = compiler_type,
-                                       verbose = self.verbose,
-                                       dry_run = self.dry_run,
-                                       force = self.force)
-
-        if self.fcompiler is not None:
-            self.fcompiler.customize(self.distribution)
-            self.scons_fcompiler = dist2sconsfc(self.fcompiler)
-            self.scons_fcompiler_path = protect_path(get_f77_tool_path(self.fcompiler))
-
-    def _init_cxxcompiler(self, compiler_type):
-        cxxcompiler = new_compiler(compiler = compiler_type,
-                                   verbose = self.verbose,
-                                   dry_run = self.dry_run,
-                                   force = self.force)
-        if cxxcompiler is not None:
-            cxxcompiler.customize(self.distribution, need_cxx = 1)
-            cxxcompiler.customize_cmd(self)
-            self.cxxcompiler = cxxcompiler.cxx_compiler()
-            try:
-                get_cxx_tool_path(self.cxxcompiler)
-            except DistutilsSetupError:
-                self.cxxcompiler = None
-
-            if self.cxxcompiler:
-                self.scons_cxxcompiler = dist2sconscxx(self.cxxcompiler)
-                self.scons_cxxcompiler_path = protect_path(get_cxx_tool_path(self.cxxcompiler))
-
-    def finalize_options(self):
-        old_build_ext.finalize_options(self)
-
-        self.sconscripts = []
-        self.pre_hooks = []
-        self.post_hooks = []
-        self.pkg_names = []
-        self.pkg_paths = []
-
-        if self.distribution.has_scons_scripts():
-            for i in self.distribution.scons_data:
-                self.sconscripts.append(i.scons_path)
-                self.pre_hooks.append(i.pre_hook)
-                self.post_hooks.append(i.post_hook)
-                self.pkg_names.append(i.parent_name)
-                self.pkg_paths.append(i.pkg_path)
-            # This crap is needed to get the build_clib
-            # directory
-            build_clib_cmd = get_cmd("build_clib").get_finalized_command("build_clib")
-            self.build_clib = build_clib_cmd.build_clib
-
-        if not self.cxxcompiler:
-            self.cxxcompiler = self.compiler
-
-        # To avoid trouble, just don't do anything if no sconscripts are used.
-        # This is  useful when for example f2py uses numpy.distutils, because
-        # f2py does not pass compiler information to scons command, and the
-        # compilation setup below can crash in some situation.
-        if len(self.sconscripts) > 0:
-            if self.bypass:
-                self.scons_compiler = self.compiler
-                self.scons_fcompiler = self.fcompiler
-                self.scons_cxxcompiler = self.cxxcompiler
-            else:
-                # Try to get the same compiler than the ones used by distutils: this is
-                # non trivial because distutils and scons have totally different
-                # conventions on this one (distutils uses PATH from user's environment,
-                # whereas scons uses standard locations). The way we do it is once we
-                # got the c compiler used, we use numpy.distutils function to get the
-                # full path, and add the path to the env['PATH'] variable in env
-                # instance (this is done in numpy.distutils.scons module).
-
-                self._init_ccompiler(self.compiler)
-                self._init_fcompiler(self.fcompiler)
-                self._init_cxxcompiler(self.cxxcompiler)
-
-        if self.package_list:
-            self.package_list = parse_package_list(self.package_list)
-
-    def _call_scons(self, scons_exec, sconscript, pkg_name, pkg_path, bootstrapping):
-        # XXX: when a scons script is missing, scons only prints warnings, and
-        # does not return a failure (status is 0). We have to detect this from
-        # distutils (this cannot work for recursive scons builds...)
-
-        # XXX: passing everything at command line may cause some trouble where
-        # there is a size limitation ? What is the standard solution in thise
-        # case ?
-
-        cmd = [scons_exec, "-f", sconscript, '-I.']
-        if self.jobs:
-            cmd.append(" --jobs=%d" % int(self.jobs))
-        if self.inplace:
-            cmd.append("inplace=1")
-        cmd.append('scons_tool_path="%s"' % self.scons_tool_path)
-        cmd.append('src_dir="%s"' % pdirname(sconscript))
-        cmd.append('pkg_path="%s"' % pkg_path)
-        cmd.append('pkg_name="%s"' % pkg_name)
-        cmd.append('log_level=%s' % self.log_level)
-        #cmd.append('distutils_libdir=%s' % protect_path(pjoin(self.build_lib,
-        #                                                    pdirname(sconscript))))
-        cmd.append('distutils_libdir=%s' %
-                     protect_path(get_distutils_libdir(self, pkg_name)))
-        cmd.append('distutils_clibdir=%s' %
-                     protect_path(get_distutils_clibdir(self, pkg_name)))
-        prefix = get_distutils_install_prefix(pkg_name, self.inplace)
-        cmd.append('distutils_install_prefix=%s' % protect_path(prefix))
-
-        if not self._bypass_distutils_cc:
-            cmd.append('cc_opt=%s' % self.scons_compiler)
-        if self.scons_compiler_path:
-            cmd.append('cc_opt_path=%s' % self.scons_compiler_path)
-        else:
-            cmd.append('cc_opt=%s' % self.scons_compiler)
-
-        cmd.append('debug=%s' % self.debug)
-
-        if self.scons_fcompiler:
-            cmd.append('f77_opt=%s' % self.scons_fcompiler)
-        if self.scons_fcompiler_path:
-            cmd.append('f77_opt_path=%s' % self.scons_fcompiler_path)
-
-        if self.scons_cxxcompiler:
-            cmd.append('cxx_opt=%s' % self.scons_cxxcompiler)
-        if self.scons_cxxcompiler_path:
-            cmd.append('cxx_opt_path=%s' % self.scons_cxxcompiler_path)
-
-        cmd.append('include_bootstrap=%s' % dirl_to_str(get_numpy_include_dirs(sconscript)))
-        cmd.append('bypass=%s' % self.bypass)
-        cmd.append('import_env=%s' % self.import_env)
-        if self.silent:
-            if int(self.silent) == 2:
-                cmd.append('-Q')
-            elif int(self.silent) == 3:
-                cmd.append('-s')
-        cmd.append('silent=%d' % int(self.silent))
-        cmd.append('bootstrapping=%d' % bootstrapping)
-        cmdstr = ' '.join(cmd)
-        if int(self.silent) < 1:
-            log.info("Executing scons command (pkg is %s): %s ", pkg_name, cmdstr)
-        else:
-            log.info("======== Executing scons command for pkg %s =========", pkg_name)
-        st = os.system(cmdstr)
-        if st:
-            #print "status is %d" % st
-            msg = "Error while executing scons command."
-            msg += " See above for more information.\n"
-            msg += """\
-If you think it is a problem in numscons, you can also try executing the scons
-command with --log-level option for more detailed output of what numscons is
-doing, for example --log-level=0; the lowest the level is, the more detailed
-the output it."""
-            raise DistutilsExecError(msg)
-
-    def run(self):
-        if len(self.sconscripts) < 1:
-            # nothing to do, just leave it here.
-            return
-
-        check_numscons(minver=(0, 11, 0))
-
-        if self.package_list is not None:
-            id = select_packages(self.pkg_names, self.package_list)
-            sconscripts = [self.sconscripts[i] for i in id]
-            pre_hooks = [self.pre_hooks[i] for i in id]
-            post_hooks = [self.post_hooks[i] for i in id]
-            pkg_names = [self.pkg_names[i] for i in id]
-            pkg_paths = [self.pkg_paths[i] for i in id]
-        else:
-            sconscripts = self.sconscripts
-            pre_hooks = self.pre_hooks
-            post_hooks = self.post_hooks
-            pkg_names = self.pkg_names
-            pkg_paths = self.pkg_paths
-
-        if is_bootstrapping():
-            bootstrapping = 1
-        else:
-            bootstrapping = 0
-
-        scons_exec = get_python_exec_invoc()
-        scons_exec += ' ' + protect_path(pjoin(get_scons_local_path(), 'scons.py'))
-
-        for sconscript, pre_hook, post_hook, pkg_name, pkg_path in zip(sconscripts,
-                                                   pre_hooks, post_hooks,
-                                                   pkg_names, pkg_paths):
-            if pre_hook:
-                pre_hook()
-
-            if sconscript:
-                self._call_scons(scons_exec, sconscript, pkg_name, pkg_path, bootstrapping)
-
-            if post_hook:
-                post_hook(**{'pkg_name': pkg_name, 'scons_cmd' : self})
-