#!/bin/env python
"""
This file defines a set of system_info classes for getting
information about various resources (libraries, library directories,
include directories, etc.) in the system. Currently, the following
classes are available:
atlas_info
atlas_threads_info
atlas_blas_info
atlas_blas_threads_info
lapack_atlas_info
blas_info
lapack_info
blas_opt_info # usage recommended
lapack_opt_info # usage recommended
fftw_info,dfftw_info,sfftw_info
fftw_threads_info,dfftw_threads_info,sfftw_threads_info
djbfft_info
x11_info
lapack_src_info
blas_src_info
numpy_info
numarray_info
numpy_info
boost_python_info
agg2_info
wx_info
gdk_pixbuf_xlib_2_info
gdk_pixbuf_2_info
gdk_x11_2_info
gtkp_x11_2_info
gtkp_2_info
xft_info
freetype2_info
umfpack_info
Usage:
info_dict = get_info(<name>)
where <name> is a string 'atlas','x11','fftw','lapack','blas',
'lapack_src', 'blas_src', etc. For a complete list of allowed names,
see the definition of get_info() function below.
Returned info_dict is a dictionary which is compatible with
distutils.setup keyword arguments. If info_dict == {}, then the
asked resource is not available (system_info could not find it).
Several *_info classes specify an environment variable to specify
the locations of software. When setting the corresponding environment
variable to 'None' then the software will be ignored, even when it
is available in system.
Global parameters:
system_info.search_static_first - search static libraries (.a)
in precedence to shared ones (.so, .sl) if enabled.
system_info.verbosity - output the results to stdout if enabled.
The file 'site.cfg' is looked for in
1) Directory of main setup.py file being run.
2) Home directory of user running the setup.py file as ~/.numpy-site.cfg
3) System wide directory (location of this file...)
The first one found is used to get system configuration options The
format is that used by ConfigParser (i.e., Windows .INI style). The
section ALL has options that are the default for each section. The
available sections are fftw, atlas, and x11. Appropiate defaults are
used if nothing is specified.
The order of finding the locations of resources is the following:
1. environment variable
2. section in site.cfg
3. ALL section in site.cfg
Only the first complete match is returned.
Example:
----------
[ALL]
library_dirs = /usr/lib:/usr/local/lib:/opt/lib
include_dirs = /usr/include:/usr/local/include:/opt/include
src_dirs = /usr/local/src:/opt/src
# search static libraries (.a) in preference to shared ones (.so)
search_static_first = 0
[fftw]
fftw_libs = rfftw, fftw
fftw_opt_libs = rfftw_threaded, fftw_threaded
# if the above aren't found, look for {s,d}fftw_libs and {s,d}fftw_opt_libs
[atlas]
library_dirs = /usr/lib/3dnow:/usr/lib/3dnow/atlas
# for overriding the names of the atlas libraries
atlas_libs = lapack, f77blas, cblas, atlas
[x11]
library_dirs = /usr/X11R6/lib
include_dirs = /usr/X11R6/include
----------
Authors:
Pearu Peterson <pearu@cens.ioc.ee>, February 2002
David M. Cooke <cookedm@physics.mcmaster.ca>, April 2002
Copyright 2002 Pearu Peterson all rights reserved,
Pearu Peterson <pearu@cens.ioc.ee>
Permission to use, modify, and distribute this software is given under the
terms of the NumPy (BSD style) license. See LICENSE.txt that came with
this distribution for specifics.
NO WARRANTY IS EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
"""
import sys
import os
import re
import copy
import warnings
from glob import glob
import ConfigParser
from distutils.errors import DistutilsError
from distutils.dist import Distribution
import distutils.sysconfig
from distutils import log
from numpy.distutils.exec_command import \
find_executable, exec_command, get_pythonexe
from numpy.distutils.misc_util import is_sequence,is_string
from numpy.distutils.command.config import config
if sys.platform == 'win32':
default_lib_dirs = ['C:\\',
os.path.join(distutils.sysconfig.EXEC_PREFIX,
'libs')]
default_include_dirs = []
default_src_dirs = ['.']
default_x11_lib_dirs = []
default_x11_include_dirs = []
else:
default_lib_dirs = ['/usr/local/lib', '/opt/lib', '/usr/lib',
'/opt/local/lib', '/sw/lib']
default_include_dirs = ['/usr/local/include',
'/opt/include', '/usr/include',
'/opt/local/include', '/sw/include']
default_src_dirs = ['.','/usr/local/src', '/opt/src','/sw/src']
try:
platform = os.uname()
bit64 = platform[-1].endswith('64')
except:
bit64 = False
if bit64:
default_x11_lib_dirs = ['/usr/lib64']
else:
default_x11_lib_dirs = ['/usr/X11R6/lib','/usr/X11/lib','/usr/lib']
default_x11_include_dirs = ['/usr/X11R6/include','/usr/X11/include',
'/usr/include']
if os.path.join(sys.prefix, 'lib') not in default_lib_dirs:
default_lib_dirs.insert(0,os.path.join(sys.prefix, 'lib'))
default_include_dirs.append(os.path.join(sys.prefix, 'include'))
default_src_dirs.append(os.path.join(sys.prefix, 'src'))
default_lib_dirs = filter(os.path.isdir, default_lib_dirs)
default_include_dirs = filter(os.path.isdir, default_include_dirs)
default_src_dirs = filter(os.path.isdir, default_src_dirs)
so_ext = distutils.sysconfig.get_config_vars('SO')[0] or ''
def get_standard_file(fname):
"""Returns a list of files named 'fname' from
1) System-wide directory (directory-location of this module)
2) Users HOME directory (os.environ['HOME'])
3) Local directory
"""
# System-wide file
filenames = []
try:
f = __file__
except NameError:
f = sys.argv[0]
else:
sysfile = os.path.join(os.path.split(os.path.abspath(f))[0],
fname)
if os.path.isfile(sysfile):
filenames.append(sysfile)
# Home directory
# And look for the user config file
try:
f = os.environ['HOME']
except KeyError:
pass
else:
user_file = os.path.join(f, fname)
if os.path.isfile(user_file):
filenames.append(user_file)
# Local file
if os.path.isfile(fname):
filenames.append(os.path.abspath(fname))
return filenames
def get_info(name,notfound_action=0):
"""
notfound_action:
0 - do nothing
1 - display warning message
2 - raise error
"""
cl = {'atlas':atlas_info, # use lapack_opt or blas_opt instead
'atlas_threads':atlas_threads_info, # ditto
'atlas_blas':atlas_blas_info,
'atlas_blas_threads':atlas_blas_threads_info,
'lapack_atlas':lapack_atlas_info, # use lapack_opt instead
'lapack_atlas_threads':lapack_atlas_threads_info, # ditto
'mkl':mkl_info,
'lapack_mkl':lapack_mkl_info, # use lapack_opt instead
'blas_mkl':blas_mkl_info, # use blas_opt instead
'x11':x11_info,
'fft_opt':fft_opt_info,
'fftw':fftw_info,
'fftw2':fftw2_info,
'fftw3':fftw3_info,
'dfftw':dfftw_info,
'sfftw':sfftw_info,
'fftw_threads':fftw_threads_info,
'dfftw_threads':dfftw_threads_info,
'sfftw_threads':sfftw_threads_info,
'djbfft':djbfft_info,
'blas':blas_info, # use blas_opt instead
'lapack':lapack_info, # use lapack_opt instead
'lapack_src':lapack_src_info,
'blas_src':blas_src_info,
'numpy':numpy_info,
'f2py':f2py_info,
'Numeric':Numeric_info,
'numeric':Numeric_info,
'numarray':numarray_info,
'numerix':numerix_info,
'lapack_opt':lapack_opt_info,
'blas_opt':blas_opt_info,
'boost_python':boost_python_info,
'agg2':agg2_info,
'wx':wx_info,
'gdk_pixbuf_xlib_2':gdk_pixbuf_xlib_2_info,
'gdk-pixbuf-xlib-2.0':gdk_pixbuf_xlib_2_info,
'gdk_pixbuf_2':gdk_pixbuf_2_info,
'gdk-pixbuf-2.0':gdk_pixbuf_2_info,
'gdk':gdk_info,
'gdk_2':gdk_2_info,
'gdk-2.0':gdk_2_info,
'gdk_x11_2':gdk_x11_2_info,
'gdk-x11-2.0':gdk_x11_2_info,
'gtkp_x11_2':gtkp_x11_2_info,
'gtk+-x11-2.0':gtkp_x11_2_info,
'gtkp_2':gtkp_2_info,
'gtk+-2.0':gtkp_2_info,
'xft':xft_info,
'freetype2':freetype2_info,
'umfpack':umfpack_info,
'amd':amd_info,
}.get(name.lower(),system_info)
return cl().get_info(notfound_action)
class NotFoundError(DistutilsError):
"""Some third-party program or library is not found."""
class AtlasNotFoundError(NotFoundError):
"""
Atlas (http://math-atlas.sourceforge.net/) libraries not found.
Directories to search for the libraries can be specified in the
numpy/distutils/site.cfg file (section [atlas]) or by setting
the ATLAS environment variable."""
class LapackNotFoundError(NotFoundError):
"""
Lapack (http://www.netlib.org/lapack/) libraries not found.
Directories to search for the libraries can be specified in the
numpy/distutils/site.cfg file (section [lapack]) or by setting
the LAPACK environment variable."""
class LapackSrcNotFoundError(LapackNotFoundError):
"""
Lapack (http://www.netlib.org/lapack/) sources not found.
Directories to search for the sources can be specified in the
numpy/distutils/site.cfg file (section [lapack_src]) or by setting
the LAPACK_SRC environment variable."""
class BlasNotFoundError(NotFoundError):
"""
Blas (http://www.netlib.org/blas/) libraries not found.
Directories to search for the libraries can be specified in the
numpy/distutils/site.cfg file (section [blas]) or by setting
the BLAS environment variable."""
class BlasSrcNotFoundError(BlasNotFoundError):
"""
Blas (http://www.netlib.org/blas/) sources not found.
Directories to search for the sources can be specified in the
numpy/distutils/site.cfg file (section [blas_src]) or by setting
the BLAS_SRC environment variable."""
class FFTWNotFoundError(NotFoundError):
"""
FFTW (http://www.fftw.org/) libraries not found.
Directories to search for the libraries can be specified in the
numpy/distutils/site.cfg file (section [fftw]) or by setting
the FFTW environment variable."""
class DJBFFTNotFoundError(NotFoundError):
"""
DJBFFT (http://cr.yp.to/djbfft.html) libraries not found.
Directories to search for the libraries can be specified in the
numpy/distutils/site.cfg file (section [djbfft]) or by setting
the DJBFFT environment variable."""
class NumericNotFoundError(NotFoundError):
"""
Numeric (http://www.numpy.org/) module not found.
Get it from above location, install it, and retry setup.py."""
class X11NotFoundError(NotFoundError):
"""X11 libraries not found."""
class UmfpackNotFoundError(NotFoundError):
"""
UMFPACK sparse solver (http://www.cise.ufl.edu/research/sparse/umfpack/)
not found. Directories to search for the libraries can be specified in the
numpy/distutils/site.cfg file (section [umfpack]) or by setting
the UMFPACK environment variable."""
class system_info:
""" get_info() is the only public method. Don't use others.
"""
section = 'ALL'
dir_env_var = None
search_static_first = 0 # XXX: disabled by default, may disappear in
# future unless it is proved to be useful.
verbosity = 1
saved_results = {}
notfounderror = NotFoundError
def __init__ (self,
default_lib_dirs=default_lib_dirs,
default_include_dirs=default_include_dirs,
verbosity = 1,
):
self.__class__.info = {}
self.local_prefixes = []
defaults = {}
defaults['libraries'] = ''
defaults['library_dirs'] = os.pathsep.join(default_lib_dirs)
defaults['include_dirs'] = os.pathsep.join(default_include_dirs)
defaults['src_dirs'] = os.pathsep.join(default_src_dirs)
defaults['search_static_first'] = str(self.search_static_first)
self.cp = ConfigParser.ConfigParser(defaults)
self.files = []
self.files.extend(get_standard_file('.numpy-site.cfg'))
self.files.extend(get_standard_file('site.cfg'))
self.parse_config_files()
self.search_static_first = self.cp.getboolean(self.section,
'search_static_first')
assert isinstance(self.search_static_first, int)
def parse_config_files(self):
self.cp.read(self.files)
if not self.cp.has_section(self.section):
self.cp.add_section(self.section)
def calc_libraries_info(self):
libs = self.get_libraries()
dirs = self.get_lib_dirs()
info = {}
for lib in libs:
i = None
for d in dirs:
i = self.check_libs(d,[lib])
if i is not None:
break
if i is not None:
dict_append(info,**i)
else:
log.info('Library %s was not found. Ignoring' % (lib))
return info
def set_info(self,**info):
if info:
lib_info = self.calc_libraries_info()
dict_append(info,**lib_info)
self.saved_results[self.__class__.__name__] = info
def has_info(self):
return self.__class__.__name__ in self.saved_results
def get_info(self,notfound_action=0):
""" Return a dictonary with items that are compatible
with numpy.distutils.setup keyword arguments.
"""
flag = 0
if not self.has_info():
flag = 1
log.info(self.__class__.__name__ + ':')
if hasattr(self, 'calc_info'):
self.calc_info()
if notfound_action:
if not self.has_info():
if notfound_action==1:
warnings.warn(self.notfounderror.__doc__)
elif notfound_action==2:
raise self.notfounderror,self.notfounderror.__doc__
else:
raise ValueError(repr(notfound_action))
if not self.has_info():
log.info(' NOT AVAILABLE')
self.set_info()
else:
log.info(' FOUND:')
res = self.saved_results.get(self.__class__.__name__)
if self.verbosity>0 and flag:
for k,v in res.items():
v = str(v)
if k in ['sources','libraries'] and len(v)>270:
v = v[:120]+'...\n...\n...'+v[-120:]
log.info(' %s = %s', k, v)
log.info('')
return copy.deepcopy(res)
def get_paths(self, section, key):
dirs = self.cp.get(section, key).split(os.pathsep)
env_var = self.dir_env_var
if env_var:
if is_sequence(env_var):
e0 = env_var[-1]
for e in env_var:
if e in os.environ:
e0 = e
break
if not env_var[0]==e0:
log.info('Setting %s=%s' % (env_var[0],e0))
env_var = e0
if env_var and env_var in os.environ:
d = os.environ[env_var]
if d=='None':
log.info('Disabled %s: %s',self.__class__.__name__,'(%s is None)' \
% (env_var,))
return []
if os.path.isfile(d):
dirs = [os.path.dirname(d)] + dirs
l = getattr(self,'_lib_names',[])
if len(l)==1:
b = os.path.basename(d)
b = os.path.splitext(b)[0]
if b[:3]=='lib':
log.info('Replacing _lib_names[0]==%r with %r' \
% (self._lib_names[0], b[3:]))
self._lib_names[0] = b[3:]
else:
ds = d.split(os.pathsep)
ds2 = []
for d in ds:
if os.path.isdir(d):
ds2.append(d)
for dd in ['include','lib']:
d1 = os.path.join(d,dd)
if os.path.isdir(d1):
ds2.append(d1)
dirs = ds2 + dirs
default_dirs = self.cp.get(self.section, key).split(os.pathsep)
dirs.extend(default_dirs)
ret = []
for d in dirs:
if os.path.isdir(d) and d not in ret:
ret.append(d)
log.debug('( %s = %s )', key, ':'.join(ret))
return ret
def get_lib_dirs(self, key='library_dirs'):
return self.get_paths(self.section, key)
def get_include_dirs(self, key='include_dirs'):
return self.get_paths(self.section, key)
def get_src_dirs(self, key='src_dirs'):
return self.get_paths(self.section, key)
def get_libs(self, key, default):
try:
libs = self.cp.get(self.section, key)
except ConfigParser.NoOptionError:
if not default:
return []
if is_string(default):
return [default]
return default
return [b for b in [a.strip() for a in libs.split(',')] if b]
def get_libraries(self, key='libraries'):
return self.get_libs(key,'')
def library_extensions(self):
static_exts = ['.a']
if sys.platform == 'win32':
static_exts.append('.lib') # .lib is used by MSVC
if self.search_static_first:
exts = static_exts + [so_ext]
else:
exts = [so_ext] + static_exts
if sys.platform == 'cygwin':
exts.append('.dll.a')
if sys.platform == 'darwin':
exts.append('.dylib')
return exts
def check_libs(self,lib_dir,libs,opt_libs =[]):
"""If static or shared libraries are available then return
their info dictionary.
Checks for all libraries as shared libraries first, then
static (or vice versa if self.search_static_first is True).
"""
exts = self.library_extensions()
info = None
for ext in exts:
info = self._check_libs(lib_dir,libs,opt_libs,[ext])
if info is not None:
break
if not info:
log.info(' libraries %s not found in %s', ','.join(libs), lib_dir)
return info
def check_libs2(self, lib_dir, libs, opt_libs =[]):
"""If static or shared libraries are available then return
their info dictionary.
Checks each library for shared or static.
"""
exts = self.library_extensions()
info = self._check_libs(lib_dir,libs,opt_libs,exts)
if not info:
log.info(' libraries %s not found in %s', ','.join(libs), lib_dir)
return info
def _lib_list(self, lib_dir, libs, exts):
assert is_string(lib_dir)
liblist = []
# under windows first try without 'lib' prefix
if sys.platform == 'win32':
lib_prefixes = ['', 'lib']
else:
lib_prefixes = ['lib']
# for each library name, see if we can find a file for it.
for l in libs:
for ext in exts:
for prefix in lib_prefixes:
p = self.combine_paths(lib_dir, prefix+l+ext)
if p:
break
if p:
assert len(p)==1
# ??? splitext on p[0] would do this for cygwin
# doesn't seem correct
if ext == '.dll.a':
l += '.dll'
liblist.append(l)
break
return liblist
def _check_libs(self, lib_dir, libs, opt_libs, exts):
found_libs = self._lib_list(lib_dir, libs, exts)
if len(found_libs) == len(libs):
info = {'libraries' : found_libs, 'library_dirs' : [lib_dir]}
opt_found_libs = self._lib_list(lib_dir, opt_libs, exts)
if len(opt_found_libs) == len(opt_libs):
info['libraries'].extend(opt_found_libs)
return info
else:
return None
def combine_paths(self,*args):
"""Return a list of existing paths composed by all combinations
of items from the arguments.
"""
return combine_paths(*args,**{'verbosity':self.verbosity})
class fft_opt_info(system_info):
def calc_info(self):
info = {}
fftw_info = get_info('fftw3') or get_info('fftw2') or get_info('dfftw')
djbfft_info = get_info('djbfft')
if fftw_info:
dict_append(info,**fftw_info)
if djbfft_info:
dict_append(info,**djbfft_info)
self.set_info(**info)
return
class fftw_info(system_info):
#variables to override
section = 'fftw'
dir_env_var = 'FFTW'
notfounderror = FFTWNotFoundError
ver_info = [ { 'name':'fftw3',
'libs':['fftw3'],
'includes':['fftw3.h'],
'macros':[('SCIPY_FFTW3_H',None)]},
{ 'name':'fftw2',
'libs':['rfftw', 'fftw'],
'includes':['fftw.h','rfftw.h'],
'macros':[('SCIPY_FFTW_H',None)]}]
def __init__(self):
system_info.__init__(self)
def calc_ver_info(self,ver_param):
"""Returns True on successful version detection, else False"""
lib_dirs = self.get_lib_dirs()
incl_dirs = self.get_include_dirs()
incl_dir = None
libs = self.get_libs(self.section+'_libs', ver_param['libs'])
info = None
for d in lib_dirs:
r = self.check_libs(d,libs)
if r is not None:
info = r
break
if info is not None:
flag = 0
for d in incl_dirs:
if len(self.combine_paths(d,ver_param['includes']))==len(ver_param['includes']):
dict_append(info,include_dirs=[d])
flag = 1
incl_dirs = [d]
incl_dir = d
break
if flag:
dict_append(info,define_macros=ver_param['macros'])
else:
info = None
if info is not None:
self.set_info(**info)
return True
else:
log.info(' %s not found' % (ver_param['name']))
return False
def calc_info(self):
for i in self.ver_info:
if self.calc_ver_info(i):
break
class fftw2_info(fftw_info):
#variables to override
section = 'fftw'
dir_env_var = 'FFTW'
notfounderror = FFTWNotFoundError
ver_info = [ { 'name':'fftw2',
'libs':['rfftw', 'fftw'],
'includes':['fftw.h','rfftw.h'],
'macros':[('SCIPY_FFTW_H',None)]}
]
class fftw3_info(fftw_info):
#variables to override
section = 'fftw3'
dir_env_var = 'FFTW3'
notfounderror = FFTWNotFoundError
ver_info = [ { 'name':'fftw3',
'libs':['fftw3'],
'includes':['fftw3.h'],
'macros':[('SCIPY_FFTW3_H',None)]},
]
class dfftw_info(fftw_info):
section = 'fftw'
dir_env_var = 'FFTW'
ver_info = [ { 'name':'dfftw',
'libs':['drfftw','dfftw'],
'includes':['dfftw.h','drfftw.h'],
'macros':[('SCIPY_DFFTW_H',None)]} ]
class sfftw_info(fftw_info):
section = 'fftw'
dir_env_var = 'FFTW'
ver_info = [ { 'name':'sfftw',
'libs':['srfftw','sfftw'],
'includes':['sfftw.h','srfftw.h'],
'macros':[('SCIPY_SFFTW_H',None)]} ]
class fftw_threads_info(fftw_info):
section = 'fftw'
dir_env_var = 'FFTW'
ver_info = [ { 'name':'fftw threads',
'libs':['rfftw_threads','fftw_threads'],
'includes':['fftw_threads.h','rfftw_threads.h'],
'macros':[('SCIPY_FFTW_THREADS_H',None)]} ]
class dfftw_threads_info(fftw_info):
section = 'fftw'
dir_env_var = 'FFTW'
ver_info = [ { 'name':'dfftw threads',
'libs':['drfftw_threads','dfftw_threads'],
'includes':['dfftw_threads.h','drfftw_threads.h'],
'macros':[('SCIPY_DFFTW_THREADS_H',None)]} ]
class sfftw_threads_info(fftw_info):
section = 'fftw'
dir_env_var = 'FFTW'
ver_info = [ { 'name':'sfftw threads',
'libs':['srfftw_threads','sfftw_threads'],
'includes':['sfftw_threads.h','srfftw_threads.h'],
'macros':[('SCIPY_SFFTW_THREADS_H',None)]} ]
class djbfft_info(system_info):
section = 'djbfft'
dir_env_var = 'DJBFFT'
notfounderror = DJBFFTNotFoundError
def get_paths(self, section, key):
pre_dirs = system_info.get_paths(self, section, key)
dirs = []
for d in pre_dirs:
dirs.extend(self.combine_paths(d,['djbfft'])+[d])
return [ d for d in dirs if os.path.isdir(d) ]
def calc_info(self):
lib_dirs = self.get_lib_dirs()
incl_dirs = self.get_include_dirs()
info = None
for d in lib_dirs:
p = self.combine_paths (d,['djbfft.a'])
if p:
info = {'extra_objects':p}
break
p = self.combine_paths (d,['libdjbfft.a','libdjbfft'+so_ext])
if p:
info = {'libraries':['djbfft'],'library_dirs':[d]}
break
if info is None:
return
for d in incl_dirs:
if len(self.combine_paths(d,['fftc8.h','fftfreq.h']))==2:
dict_append(info,include_dirs=[d],
define_macros=[('SCIPY_DJBFFT_H',None)])
self.set_info(**info)
return
return
class mkl_info(system_info):
section = 'mkl'
dir_env_var = 'MKL'
_lib_mkl = ['mkl','vml','guide']
def get_mkl_rootdir(self):
mklroot = os.environ.get('MKLROOT',None)
if mklroot is not None:
return mklroot
paths = os.environ.get('LD_LIBRARY_PATH','').split(os.pathsep)
ld_so_conf = '/etc/ld.so.conf'
if os.path.isfile(ld_so_conf):
for d in open(ld_so_conf,'r').readlines():
d = d.strip()
if d: paths.append(d)
intel_mkl_dirs = []
for path in paths:
path_atoms = path.split(os.sep)
for m in path_atoms:
if m.startswith('mkl'):
d = os.sep.join(path_atoms[:path_atoms.index(m)+2])
intel_mkl_dirs.append(d)
break
for d in paths:
dirs = glob(os.path.join(d,'mkl','*')) + glob(os.path.join(d,'mkl*'))
for d in dirs:
if os.path.isdir(os.path.join(d,'lib')):
return d
return None
def __init__(self):
mklroot = self.get_mkl_rootdir()
if mklroot is None:
system_info.__init__(self)
else:
from cpuinfo import cpu
l = 'mkl' # use shared library
if cpu.is_Itanium():
plt = '64'
#l = 'mkl_ipf'
elif cpu.is_Xeon():
plt = 'em64t'
#l = 'mkl_em64t'
else:
plt = '32'
#l = 'mkl_ia32'
if l not in self._lib_mkl:
self._lib_mkl.insert(0,l)
system_info.__init__(self,
default_lib_dirs=[os.path.join(mklroot,'lib',plt)],
default_include_dirs=[os.path.join(mklroot,'include')])
def calc_info(self):
lib_dirs = self.get_lib_dirs()
incl_dirs = self.get_include_dirs()
mkl_libs = self.get_libs('mkl_libs',self._lib_mkl)
mkl = None
for d in lib_dirs:
mkl = self.check_libs2(d,mkl_libs)
if mkl is not None:
break
if mkl is None:
return
info = {}
dict_append(info,**mkl)
dict_append(info,
define_macros=[('SCIPY_MKL_H',None)],
include_dirs = incl_dirs)
if sys.platform == 'win32':
pass # win32 has no pthread library
else:
dict_append(info, libraries=['pthread'])
self.set_info(**info)
class lapack_mkl_info(mkl_info):
def calc_info(self):
mkl = get_info('mkl')
if not mkl:
return
if sys.platform == 'win32':
lapack_libs = self.get_libs('lapack_libs',['mkl_lapack'])
else:
lapack_libs = self.get_libs('lapack_libs',['mkl_lapack32','mkl_lapack64'])
info = {'libraries': lapack_libs}
dict_append(info,**mkl)
self.set_info(**info)
class blas_mkl_info(mkl_info):
pass
class atlas_info(system_info):
section = 'atlas'
dir_env_var = 'ATLAS'
_lib_names = ['f77blas','cblas']
if sys.platform[:7]=='freebsd':
_lib_atlas = ['atlas_r']
_lib_lapack = ['alapack_r']
else:
_lib_atlas = ['atlas']
_lib_lapack = ['lapack']
notfounderror = AtlasNotFoundError
def get_paths(self, section, key):
pre_dirs = system_info.get_paths(self, section, key)
dirs = []
for d in pre_dirs:
dirs.extend(self.combine_paths(d,['atlas*','ATLAS*',
'sse','3dnow','sse2'])+[d])
return [ d for d in dirs if os.path.isdir(d) ]
def calc_info(self):
lib_dirs = self.get_lib_dirs()
info = {}
atlas_libs = self.get_libs('atlas_libs',
self._lib_names + self._lib_atlas)
lapack_libs = self.get_libs('lapack_libs',self._lib_lapack)
atlas = None
lapack = None
atlas_1 = None
for d in lib_dirs:
atlas = self.check_libs2(d,atlas_libs,[])
lapack_atlas = self.check_libs2(d,['lapack_atlas'],[])
if atlas is not None:
lib_dirs2 = [d] + self.combine_paths(d,['atlas*','ATLAS*'])
for d2 in lib_dirs2:
lapack = self.check_libs2(d2,lapack_libs,[])
if lapack is not None:
break
else:
lapack = None
if lapack is not None:
break
if atlas:
atlas_1 = atlas
log.info(self.__class__)
if atlas is None:
atlas = atlas_1
if atlas is None:
return
include_dirs = self.get_include_dirs()
h = (self.combine_paths(lib_dirs+include_dirs,'cblas.h') or [None])[0]
if h:
h = os.path.dirname(h)
dict_append(info,include_dirs=[h])
info['language'] = 'c'
if lapack is not None:
dict_append(info,**lapack)
dict_append(info,**atlas)
elif 'lapack_atlas' in atlas['libraries']:
dict_append(info,**atlas)
dict_append(info,define_macros=[('ATLAS_WITH_LAPACK_ATLAS',None)])
self.set_info(**info)
return
else:
dict_append(info,**atlas)
dict_append(info,define_macros=[('ATLAS_WITHOUT_LAPACK',None)])
message = """
*********************************************************************
Could not find lapack library within the ATLAS installation.
*********************************************************************
"""
warnings.warn(message)
self.set_info(**info)
return
# Check if lapack library is complete, only warn if it is not.
lapack_dir = lapack['library_dirs'][0]
lapack_name = lapack['libraries'][0]
lapack_lib = None
lib_prefixes = ['lib']
if sys.platform == 'win32':
lib_prefixes.append('')
for e in self.library_extensions():
for prefix in lib_prefixes:
fn = os.path.join(lapack_dir,prefix+lapack_name+e)
if os.path.exists(fn):
lapack_lib = fn
break
if lapack_lib:
break
if lapack_lib is not None:
sz = os.stat(lapack_lib)[6]
if sz <= 4000*1024:
message = """
*********************************************************************
Lapack library (from ATLAS) is probably incomplete:
size of %s is %sk (expected >4000k)
Follow the instructions in the KNOWN PROBLEMS section of the file
numpy/INSTALL.txt.
*********************************************************************
""" % (lapack_lib,sz/1024)
warnings.warn(message)
else:
info['language'] = 'f77'
self.set_info(**info)
class atlas_blas_info(atlas_info):
_lib_names = ['f77blas','cblas']
def calc_info(self):
lib_dirs = self.get_lib_dirs()
info = {}
atlas_libs = self.get_libs('atlas_libs',
self._lib_names + self._lib_atlas)
atlas = None
for d in lib_dirs:
atlas = self.check_libs2(d,atlas_libs,[])
if atlas is not None:
break
if atlas is None:
return
include_dirs = self.get_include_dirs()
h = (self.combine_paths(lib_dirs+include_dirs,'cblas.h') or [None])[0]
if h:
h = os.path.dirname(h)
dict_append(info,include_dirs=[h])
info['language'] = 'c'
dict_append(info,**atlas)
self.set_info(**info)
return
class atlas_threads_info(atlas_info):
dir_env_var = ['PTATLAS','ATLAS']
_lib_names = ['ptf77blas','ptcblas']
class atlas_blas_threads_info(atlas_blas_info):
dir_env_var = ['PTATLAS','ATLAS']
_lib_names = ['ptf77blas','ptcblas']
class lapack_atlas_info(atlas_info):
_lib_names = ['lapack_atlas'] + atlas_info._lib_names
class lapack_atlas_threads_info(atlas_threads_info):
_lib_names = ['lapack_atlas'] + atlas_threads_info._lib_names
class lapack_info(system_info):
section = 'lapack'
dir_env_var = 'LAPACK'
_lib_names = ['lapack']
notfounderror = LapackNotFoundError
def calc_info(self):
lib_dirs = self.get_lib_dirs()
lapack_libs = self.get_libs('lapack_libs', self._lib_names)
for d in lib_dirs:
lapack = self.check_libs(d,lapack_libs,[])
if lapack is not None:
info = lapack
break
else:
return
info['language'] = 'f77'
self.set_info(**info)
class lapack_src_info(system_info):
section = 'lapack_src'
dir_env_var = 'LAPACK_SRC'
notfounderror = LapackSrcNotFoundError
def get_paths(self, section, key):
pre_dirs = system_info.get_paths(self, section, key)
dirs = []
for d in pre_dirs:
dirs.extend([d] + self.combine_paths(d,['LAPACK*/SRC','SRC']))
return [ d for d in dirs if os.path.isdir(d) ]
def calc_info(self):
src_dirs = self.get_src_dirs()
src_dir = ''
for d in src_dirs:
if os.path.isfile(os.path.join(d,'dgesv.f')):
src_dir = d
break
if not src_dir:
#XXX: Get sources from netlib. May be ask first.
return
# The following is extracted from LAPACK-3.0/SRC/Makefile.
# Added missing names from lapack-lite-3.1.1/SRC/Makefile
# while keeping removed names for Lapack-3.0 compatibility.
allaux='''
ilaenv ieeeck lsame lsamen xerbla
iparmq
''' # *.f
laux = '''
bdsdc bdsqr disna labad lacpy ladiv lae2 laebz laed0 laed1
laed2 laed3 laed4 laed5 laed6 laed7 laed8 laed9 laeda laev2
lagtf lagts lamch lamrg lanst lapy2 lapy3 larnv larrb larre
larrf lartg laruv las2 lascl lasd0 lasd1 lasd2 lasd3 lasd4
lasd5 lasd6 lasd7 lasd8 lasd9 lasda lasdq lasdt laset lasq1
lasq2 lasq3 lasq4 lasq5 lasq6 lasr lasrt lassq lasv2 pttrf
stebz stedc steqr sterf
larra larrc larrd larr larrk larrj larrr laneg laisnan isnan
lazq3 lazq4
''' # [s|d]*.f
lasrc = '''
gbbrd gbcon gbequ gbrfs gbsv gbsvx gbtf2 gbtrf gbtrs gebak
gebal gebd2 gebrd gecon geequ gees geesx geev geevx gegs gegv
gehd2 gehrd gelq2 gelqf gels gelsd gelss gelsx gelsy geql2
geqlf geqp3 geqpf geqr2 geqrf gerfs gerq2 gerqf gesc2 gesdd
gesv gesvd gesvx getc2 getf2 getrf getri getrs ggbak ggbal
gges ggesx ggev ggevx ggglm gghrd gglse ggqrf ggrqf ggsvd
ggsvp gtcon gtrfs gtsv gtsvx gttrf gttrs gtts2 hgeqz hsein
hseqr labrd lacon laein lags2 lagtm lahqr lahrd laic1 lals0
lalsa lalsd langb lange langt lanhs lansb lansp lansy lantb
lantp lantr lapll lapmt laqgb laqge laqp2 laqps laqsb laqsp
laqsy lar1v lar2v larf larfb larfg larft larfx largv larrv
lartv larz larzb larzt laswp lasyf latbs latdf latps latrd
latrs latrz latzm lauu2 lauum pbcon pbequ pbrfs pbstf pbsv
pbsvx pbtf2 pbtrf pbtrs pocon poequ porfs posv posvx potf2
potrf potri potrs ppcon ppequ pprfs ppsv ppsvx pptrf pptri
pptrs ptcon pteqr ptrfs ptsv ptsvx pttrs ptts2 spcon sprfs
spsv spsvx sptrf sptri sptrs stegr stein sycon syrfs sysv
sysvx sytf2 sytrf sytri sytrs tbcon tbrfs tbtrs tgevc tgex2
tgexc tgsen tgsja tgsna tgsy2 tgsyl tpcon tprfs tptri tptrs
trcon trevc trexc trrfs trsen trsna trsyl trti2 trtri trtrs
tzrqf tzrzf
lacn2 lahr2 stemr laqr0 laqr1 laqr2 laqr3 laqr4 laqr5
''' # [s|c|d|z]*.f
sd_lasrc = '''
laexc lag2 lagv2 laln2 lanv2 laqtr lasy2 opgtr opmtr org2l
org2r orgbr orghr orgl2 orglq orgql orgqr orgr2 orgrq orgtr
orm2l orm2r ormbr ormhr orml2 ormlq ormql ormqr ormr2 ormr3
ormrq ormrz ormtr rscl sbev sbevd sbevx sbgst sbgv sbgvd sbgvx
sbtrd spev spevd spevx spgst spgv spgvd spgvx sptrd stev stevd
stevr stevx syev syevd syevr syevx sygs2 sygst sygv sygvd
sygvx sytd2 sytrd
''' # [s|d]*.f
cz_lasrc = '''
bdsqr hbev hbevd hbevx hbgst hbgv hbgvd hbgvx hbtrd hecon heev
heevd heevr heevx hegs2 hegst hegv hegvd hegvx herfs hesv
hesvx hetd2 hetf2 hetrd hetrf hetri hetrs hpcon hpev hpevd
hpevx hpgst hpgv hpgvd hpgvx hprfs hpsv hpsvx hptrd hptrf
hptri hptrs lacgv lacp2 lacpy lacrm lacrt ladiv laed0 laed7
laed8 laesy laev2 lahef lanhb lanhe lanhp lanht laqhb laqhe
laqhp larcm larnv lartg lascl laset lasr lassq pttrf rot spmv
spr stedc steqr symv syr ung2l ung2r ungbr unghr ungl2 unglq
ungql ungqr ungr2 ungrq ungtr unm2l unm2r unmbr unmhr unml2
unmlq unmql unmqr unmr2 unmr3 unmrq unmrz unmtr upgtr upmtr
''' # [c|z]*.f
#######
sclaux = laux + ' econd ' # s*.f
dzlaux = laux + ' secnd ' # d*.f
slasrc = lasrc + sd_lasrc # s*.f
dlasrc = lasrc + sd_lasrc # d*.f
clasrc = lasrc + cz_lasrc + ' srot srscl ' # c*.f
zlasrc = lasrc + cz_lasrc + ' drot drscl ' # z*.f
oclasrc = ' icmax1 scsum1 ' # *.f
ozlasrc = ' izmax1 dzsum1 ' # *.f
sources = ['s%s.f'%f for f in (sclaux+slasrc).split()] \
+ ['d%s.f'%f for f in (dzlaux+dlasrc).split()] \
+ ['c%s.f'%f for f in (clasrc).split()] \
+ ['z%s.f'%f for f in (zlasrc).split()] \
+ ['%s.f'%f for f in (allaux+oclasrc+ozlasrc).split()]
sources = [os.path.join(src_dir,f) for f in sources]
# Lapack 3.1:
src_dir2 = os.path.join(src_dir,'..','INSTALL')
sources += [os.path.join(src_dir2,p+'lamch.f') for p in 'sdcz']
# Should we check here actual existence of source files?
# Yes, the file listing is different between 3.0 and 3.1
# versions.
sources = [f for f in sources if os.path.isfile(f)]
info = {'sources':sources,'language':'f77'}
self.set_info(**info)
atlas_version_c_text = r'''
/* This file is generated from numpydistutilssystem_info.py import
void ATL_buildinfo(void);
int main(void) {
ATL_buildinfo();
return 0;
}
'''
_cached_atlas_version = {}
def get_atlas_version(**config):
libraries = config.get('libraries', [])
library_dirs = config.get('library_dirs', [])
key = (tuple(libraries), tuple(library_dirs))
if key in _cached_atlas_version:
return _cached_atlas_version[key]
c = cmd_config(Distribution())
atlas_version = None
try:
s, o = c.get_output(atlas_version_c_text,
libraries=libraries, library_dirs=library_dirs)
except: # failed to get version from file -- maybe on Windows
# look at directory name
for o in library_dirs:
m = re.search(r'ATLAS_(?P<version>\d+[.]\d+[.]\d+)_',o)
if m:
atlas_version = m.group('version')
if atlas_version is not None:
break
# final choice --- look at ATLAS_VERSION environment
# variable
if atlas_version is None:
atlas_version = os.environ.get('ATLAS_VERSION',None)
return atlas_version or '?.?.?'
if not s:
m = re.search(r'ATLAS version (?P<version>\d+[.]\d+[.]\d+)',o)
if m:
atlas_version = m.group('version')
if atlas_version is None:
if re.search(r'undefined symbol: ATL_buildinfo',o,re.M):
atlas_version = '3.2.1_pre3.3.6'
else:
log.info('Status: %d', s)
log.info('Output: %s', o)
_cached_atlas_version[key] = atlas_version
return atlas_version
from distutils.util import get_platform
class lapack_opt_info(system_info):
notfounderror = LapackNotFoundError
def calc_info(self):
if sys.platform=='darwin' and not os.environ.get('ATLAS',None):
args = []
link_args = []
if get_platform()[-4:] == 'i386':
intel = 1
else:
intel = 0
if os.path.exists('/System/Library/Frameworks/Accelerate.framework/'):
if intel:
args.extend(['-msse3'])
else:
args.extend(['-faltivec'])
link_args.extend(['-Wl,-framework','-Wl,Accelerate'])
elif os.path.exists('/System/Library/Frameworks/vecLib.framework/'):
if intel:
args.extend(['-msse3'])
else:
args.extend(['-faltivec'])
link_args.extend(['-Wl,-framework','-Wl,vecLib'])
if args:
self.set_info(extra_compile_args=args,
extra_link_args=link_args,
define_macros=[('NO_ATLAS_INFO',3)])
return
lapack_mkl_info = get_info('lapack_mkl')
if lapack_mkl_info:
self.set_info(**lapack_mkl_info)
return
atlas_info = get_info('atlas_threads')
if not atlas_info:
atlas_info = get_info('atlas')
#atlas_info = {} ## uncomment for testing
atlas_version = None
need_lapack = 0
need_blas = 0
info = {}
if atlas_info:
version_info = atlas_info.copy()
atlas_version = get_atlas_version(**version_info)
if 'define_macros' not in atlas_info:
atlas_info['define_macros'] = []
if atlas_version is None:
atlas_info['define_macros'].append(('NO_ATLAS_INFO',2))
else:
atlas_info['define_macros'].append(('ATLAS_INFO',
'"\\"%s\\""' % atlas_version))
if atlas_version=='3.2.1_pre3.3.6':
atlas_info['define_macros'].append(('NO_ATLAS_INFO',4))
l = atlas_info.get('define_macros',[])
if ('ATLAS_WITH_LAPACK_ATLAS',None) in l \
or ('ATLAS_WITHOUT_LAPACK',None) in l:
need_lapack = 1
info = atlas_info
else:
warnings.warn(AtlasNotFoundError.__doc__)
need_blas = 1
need_lapack = 1
dict_append(info,define_macros=[('NO_ATLAS_INFO',1)])
if need_lapack:
lapack_info = get_info('lapack')
#lapack_info = {} ## uncomment for testing
if lapack_info:
dict_append(info,**lapack_info)
else:
warnings.warn(LapackNotFoundError.__doc__)
lapack_src_info = get_info('lapack_src')
if not lapack_src_info:
warnings.warn(LapackSrcNotFoundError.__doc__)
return
dict_append(info,libraries=[('flapack_src',lapack_src_info)])
if need_blas:
blas_info = get_info('blas')
#blas_info = {} ## uncomment for testing
if blas_info:
dict_append(info,**blas_info)
else:
warnings.warn(BlasNotFoundError.__doc__)
blas_src_info = get_info('blas_src')
if not blas_src_info:
warnings.warn(BlasSrcNotFoundError.__doc__)
return
dict_append(info,libraries=[('fblas_src',blas_src_info)])
self.set_info(**info)
return
class blas_opt_info(system_info):
notfounderror = BlasNotFoundError
def calc_info(self):
if sys.platform=='darwin' and not os.environ.get('ATLAS',None):
args = []
link_args = []
if get_platform()[-4:] == 'i386':
intel = 1
else:
intel = 0
if os.path.exists('/System/Library/Frameworks/Accelerate.framework/'):
if intel:
args.extend(['-msse3'])
else:
args.extend(['-faltivec'])
args.extend([
'-I/System/Library/Frameworks/vecLib.framework/Headers'])
link_args.extend(['-Wl,-framework','-Wl,Accelerate'])
elif os.path.exists('/System/Library/Frameworks/vecLib.framework/'):
if intel:
args.extend(['-msse3'])
else:
args.extend(['-faltivec'])
args.extend([
'-I/System/Library/Frameworks/vecLib.framework/Headers'])
link_args.extend(['-Wl,-framework','-Wl,vecLib'])
if args:
self.set_info(extra_compile_args=args,
extra_link_args=link_args,
define_macros=[('NO_ATLAS_INFO',3)])
return
blas_mkl_info = get_info('blas_mkl')
if blas_mkl_info:
self.set_info(**blas_mkl_info)
return
atlas_info = get_info('atlas_blas_threads')
if not atlas_info:
atlas_info = get_info('atlas_blas')
atlas_version = None
need_blas = 0
info = {}
if atlas_info:
version_info = atlas_info.copy()
atlas_version = get_atlas_version(**version_info)
if 'define_macros' not in atlas_info:
atlas_info['define_macros'] = []
if atlas_version is None:
atlas_info['define_macros'].append(('NO_ATLAS_INFO',2))
else:
atlas_info['define_macros'].append(('ATLAS_INFO',
'"\\"%s\\""' % atlas_version))
info = atlas_info
else:
warnings.warn(AtlasNotFoundError.__doc__)
need_blas = 1
dict_append(info,define_macros=[('NO_ATLAS_INFO',1)])
if need_blas:
blas_info = get_info('blas')
if blas_info:
dict_append(info,**blas_info)
else:
warnings.warn(BlasNotFoundError.__doc__)
blas_src_info = get_info('blas_src')
if not blas_src_info:
warnings.warn(BlasSrcNotFoundError.__doc__)
return
dict_append(info,libraries=[('fblas_src',blas_src_info)])
self.set_info(**info)
return
class blas_info(system_info):
section = 'blas'
dir_env_var = 'BLAS'
_lib_names = ['blas']
notfounderror = BlasNotFoundError
def calc_info(self):
lib_dirs = self.get_lib_dirs()
blas_libs = self.get_libs('blas_libs', self._lib_names)
for d in lib_dirs:
blas = self.check_libs(d,blas_libs,[])
if blas is not None:
info = blas
break
else:
return
info['language'] = 'f77' # XXX: is it generally true?
self.set_info(**info)
class blas_src_info(system_info):
section = 'blas_src'
dir_env_var = 'BLAS_SRC'
notfounderror = BlasSrcNotFoundError
def get_paths(self, section, key):
pre_dirs = system_info.get_paths(self, section, key)
dirs = []
for d in pre_dirs:
dirs.extend([d] + self.combine_paths(d,['blas']))
return [ d for d in dirs if os.path.isdir(d) ]
def calc_info(self):
src_dirs = self.get_src_dirs()
src_dir = ''
for d in src_dirs:
if os.path.isfile(os.path.join(d,'daxpy.f')):
src_dir = d
break
if not src_dir:
#XXX: Get sources from netlib. May be ask first.
return
blas1 = '''
caxpy csscal dnrm2 dzasum saxpy srotg zdotc ccopy cswap drot
dznrm2 scasum srotm zdotu cdotc dasum drotg icamax scnrm2
srotmg zdrot cdotu daxpy drotm idamax scopy sscal zdscal crotg
dcabs1 drotmg isamax sdot sswap zrotg cscal dcopy dscal izamax
snrm2 zaxpy zscal csrot ddot dswap sasum srot zcopy zswap
scabs1
'''
blas2 = '''
cgbmv chpmv ctrsv dsymv dtrsv sspr2 strmv zhemv ztpmv cgemv
chpr dgbmv dsyr lsame ssymv strsv zher ztpsv cgerc chpr2 dgemv
dsyr2 sgbmv ssyr xerbla zher2 ztrmv cgeru ctbmv dger dtbmv
sgemv ssyr2 zgbmv zhpmv ztrsv chbmv ctbsv dsbmv dtbsv sger
stbmv zgemv zhpr chemv ctpmv dspmv dtpmv ssbmv stbsv zgerc
zhpr2 cher ctpsv dspr dtpsv sspmv stpmv zgeru ztbmv cher2
ctrmv dspr2 dtrmv sspr stpsv zhbmv ztbsv
'''
blas3 = '''
cgemm csymm ctrsm dsyrk sgemm strmm zhemm zsyr2k chemm csyr2k
dgemm dtrmm ssymm strsm zher2k zsyrk cher2k csyrk dsymm dtrsm
ssyr2k zherk ztrmm cherk ctrmm dsyr2k ssyrk zgemm zsymm ztrsm
'''
sources = [os.path.join(src_dir,f+'.f') \
for f in (blas1+blas2+blas3).split()]
#XXX: should we check here actual existence of source files?
sources = [f for f in sources if os.path.isfile(f)]
info = {'sources':sources,'language':'f77'}
self.set_info(**info)
class x11_info(system_info):
section = 'x11'
notfounderror = X11NotFoundError
def __init__(self):
system_info.__init__(self,
default_lib_dirs=default_x11_lib_dirs,
default_include_dirs=default_x11_include_dirs)
def calc_info(self):
if sys.platform in ['win32']:
return
lib_dirs = self.get_lib_dirs()
include_dirs = self.get_include_dirs()
x11_libs = self.get_libs('x11_libs', ['X11'])
for lib_dir in lib_dirs:
info = self.check_libs(lib_dir, x11_libs, [])
if info is not None:
break
else:
return
inc_dir = None
for d in include_dirs:
if self.combine_paths(d, 'X11/X.h'):
inc_dir = d
break
if inc_dir is not None:
dict_append(info, include_dirs=[inc_dir])
self.set_info(**info)
class _numpy_info(system_info):
section = 'Numeric'
modulename = 'Numeric'
notfounderror = NumericNotFoundError
def __init__(self):
include_dirs = []
try:
module = __import__(self.modulename)
prefix = []
for name in module.__file__.split(os.sep):
if name=='lib':
break
prefix.append(name)
include_dirs.append(distutils.sysconfig.get_python_inc(
prefix=os.sep.join(prefix)))
except ImportError:
pass
py_incl_dir = distutils.sysconfig.get_python_inc()
include_dirs.append(py_incl_dir)
for d in default_include_dirs:
d = os.path.join(d, os.path.basename(py_incl_dir))
if d not in include_dirs:
include_dirs.append(d)
system_info.__init__(self,
default_lib_dirs=[],
default_include_dirs=include_dirs)
def calc_info(self):
try:
module = __import__(self.modulename)
except ImportError:
return
info = {}
macros = []
for v in ['__version__','version']:
vrs = getattr(module,v,None)
if vrs is None:
continue
macros = [(self.modulename.upper()+'_VERSION',
'"\\"%s\\""' % (vrs)),
(self.modulename.upper(),None)]
break
## try:
## macros.append(
## (self.modulename.upper()+'_VERSION_HEX',
## hex(vstr2hex(module.__version__))),
## )
## except Exception,msg:
## print msg
dict_append(info, define_macros = macros)
include_dirs = self.get_include_dirs()
inc_dir = None
for d in include_dirs:
if self.combine_paths(d,
os.path.join(self.modulename,
'arrayobject.h')):
inc_dir = d
break
if inc_dir is not None:
dict_append(info, include_dirs=[inc_dir])
if info:
self.set_info(**info)
return
class numarray_info(_numpy_info):
section = 'numarray'
modulename = 'numarray'
class Numeric_info(_numpy_info):
section = 'Numeric'
modulename = 'Numeric'
class numpy_info(_numpy_info):
section = 'numpy'
modulename = 'numpy'
class numerix_info(system_info):
section = 'numerix'
def calc_info(self):
which = None, None
if os.getenv("NUMERIX"):
which = os.getenv("NUMERIX"), "environment var"
# If all the above fail, default to numpy.
if which[0] is None:
which = "numpy", "defaulted"
try:
import numpy
which = "numpy", "defaulted"
except ImportError,msg1:
try:
import Numeric
which = "numeric", "defaulted"
except ImportError,msg2:
try:
import numarray
which = "numarray", "defaulted"
except ImportError,msg3:
log.info(msg1)
log.info(msg2)
log.info(msg3)
which = which[0].strip().lower(), which[1]
if which[0] not in ["numeric", "numarray", "numpy"]:
raise ValueError("numerix selector must be either 'Numeric' "
"or 'numarray' or 'numpy' but the value obtained"
" from the %s was '%s'." % (which[1], which[0]))
os.environ['NUMERIX'] = which[0]
self.set_info(**get_info(which[0]))
class f2py_info(system_info):
def calc_info(self):
try:
import numpy.f2py as f2py
except ImportError:
return
f2py_dir = os.path.join(os.path.dirname(f2py.__file__),'src')
self.set_info(sources = [os.path.join(f2py_dir,'fortranobject.c')],
include_dirs = [f2py_dir])
return
class boost_python_info(system_info):
section = 'boost_python'
dir_env_var = 'BOOST'
def get_paths(self, section, key):
pre_dirs = system_info.get_paths(self, section, key)
dirs = []
for d in pre_dirs:
dirs.extend([d] + self.combine_paths(d,['boost*']))
return [ d for d in dirs if os.path.isdir(d) ]
def calc_info(self):
src_dirs = self.get_src_dirs()
src_dir = ''
for d in src_dirs:
if os.path.isfile(os.path.join(d,'libs','python','src','module.cpp')):
src_dir = d
break
if not src_dir:
return
py_incl_dir = distutils.sysconfig.get_python_inc()
srcs_dir = os.path.join(src_dir,'libs','python','src')
bpl_srcs = glob(os.path.join(srcs_dir,'*.cpp'))
bpl_srcs += glob(os.path.join(srcs_dir,'*','*.cpp'))
info = {'libraries':[('boost_python_src',{'include_dirs':[src_dir,py_incl_dir],
'sources':bpl_srcs})],
'include_dirs':[src_dir],
}
if info:
self.set_info(**info)
return
class agg2_info(system_info):
section = 'agg2'
dir_env_var = 'AGG2'
def get_paths(self, section, key):
pre_dirs = system_info.get_paths(self, section, key)
dirs = []
for d in pre_dirs:
dirs.extend([d] + self.combine_paths(d,['agg2*']))
return [ d for d in dirs if os.path.isdir(d) ]
def calc_info(self):
src_dirs = self.get_src_dirs()
src_dir = ''
for d in src_dirs:
if os.path.isfile(os.path.join(d,'src','agg_affine_matrix.cpp')):
src_dir = d
break
if not src_dir:
return
if sys.platform=='win32':
agg2_srcs = glob(os.path.join(src_dir,'src','platform','win32','agg_win32_bmp.cpp'))
else:
agg2_srcs = glob(os.path.join(src_dir,'src','*.cpp'))
agg2_srcs += [os.path.join(src_dir,'src','platform','X11','agg_platform_support.cpp')]
info = {'libraries':[('agg2_src',{'sources':agg2_srcs,
'include_dirs':[os.path.join(src_dir,'include')],
})],
'include_dirs':[os.path.join(src_dir,'include')],
}
if info:
self.set_info(**info)
return
class _pkg_config_info(system_info):
section = None
config_env_var = 'PKG_CONFIG'
default_config_exe = 'pkg-config'
append_config_exe = ''
version_macro_name = None
release_macro_name = None
version_flag = '--modversion'
cflags_flag = '--cflags'
def get_config_exe(self):
if self.config_env_var in os.environ:
return os.environ[self.config_env_var]
return self.default_config_exe
def get_config_output(self, config_exe, option):
s,o = exec_command(config_exe+' '+self.append_config_exe+' '+option,use_tee=0)
if not s:
return o
def calc_info(self):
config_exe = find_executable(self.get_config_exe())
if not config_exe:
log.warn('File not found: %s. Cannot determine %s info.' \
% (config_exe, self.section))
return
info = {}
macros = []
libraries = []
library_dirs = []
include_dirs = []
extra_link_args = []
extra_compile_args = []
version = self.get_config_output(config_exe,self.version_flag)
if version:
macros.append((self.__class__.__name__.split('.')[-1].upper(),
'"\\"%s\\""' % (version)))
if self.version_macro_name:
macros.append((self.version_macro_name+'_%s' % (version.replace('.','_')),None))
if self.release_macro_name:
release = self.get_config_output(config_exe,'--release')
if release:
macros.append((self.release_macro_name+'_%s' % (release.replace('.','_')),None))
opts = self.get_config_output(config_exe,'--libs')
if opts:
for opt in opts.split():
if opt[:2]=='-l':
libraries.append(opt[2:])
elif opt[:2]=='-L':
library_dirs.append(opt[2:])
else:
extra_link_args.append(opt)
opts = self.get_config_output(config_exe,self.cflags_flag)
if opts:
for opt in opts.split():
if opt[:2]=='-I':
include_dirs.append(opt[2:])
elif opt[:2]=='-D':
if '=' in opt:
n,v = opt[2:].split('=')
macros.append((n,v))
else:
macros.append((opt[2:],None))
else:
extra_compile_args.append(opt)
if macros: dict_append(info, define_macros = macros)
if libraries: dict_append(info, libraries = libraries)
if library_dirs: dict_append(info, library_dirs = library_dirs)
if include_dirs: dict_append(info, include_dirs = include_dirs)
if extra_link_args: dict_append(info, extra_link_args = extra_link_args)
if extra_compile_args: dict_append(info, extra_compile_args = extra_compile_args)
if info:
self.set_info(**info)
return
class wx_info(_pkg_config_info):
section = 'wx'
config_env_var = 'WX_CONFIG'
default_config_exe = 'wx-config'
append_config_exe = ''
version_macro_name = 'WX_VERSION'
release_macro_name = 'WX_RELEASE'
version_flag = '--version'
cflags_flag = '--cxxflags'
class gdk_pixbuf_xlib_2_info(_pkg_config_info):
section = 'gdk_pixbuf_xlib_2'
append_config_exe = 'gdk-pixbuf-xlib-2.0'
version_macro_name = 'GDK_PIXBUF_XLIB_VERSION'
class gdk_pixbuf_2_info(_pkg_config_info):
section = 'gdk_pixbuf_2'
append_config_exe = 'gdk-pixbuf-2.0'
version_macro_name = 'GDK_PIXBUF_VERSION'
class gdk_x11_2_info(_pkg_config_info):
section = 'gdk_x11_2'
append_config_exe = 'gdk-x11-2.0'
version_macro_name = 'GDK_X11_VERSION'
class gdk_2_info(_pkg_config_info):
section = 'gdk_2'
append_config_exe = 'gdk-2.0'
version_macro_name = 'GDK_VERSION'
class gdk_info(_pkg_config_info):
section = 'gdk'
append_config_exe = 'gdk'
version_macro_name = 'GDK_VERSION'
class gtkp_x11_2_info(_pkg_config_info):
section = 'gtkp_x11_2'
append_config_exe = 'gtk+-x11-2.0'
version_macro_name = 'GTK_X11_VERSION'
class gtkp_2_info(_pkg_config_info):
section = 'gtkp_2'
append_config_exe = 'gtk+-2.0'
version_macro_name = 'GTK_VERSION'
class xft_info(_pkg_config_info):
section = 'xft'
append_config_exe = 'xft'
version_macro_name = 'XFT_VERSION'
class freetype2_info(_pkg_config_info):
section = 'freetype2'
append_config_exe = 'freetype2'
version_macro_name = 'FREETYPE2_VERSION'
class amd_info(system_info):
section = 'amd'
dir_env_var = 'AMD'
_lib_names = ['amd']
def calc_info(self):
lib_dirs = self.get_lib_dirs()
amd_libs = self.get_libs('amd_libs', self._lib_names)
for d in lib_dirs:
amd = self.check_libs(d,amd_libs,[])
if amd is not None:
info = amd
break
else:
return
include_dirs = self.get_include_dirs()
inc_dir = None
for d in include_dirs:
p = self.combine_paths(d,'amd.h')
if p:
inc_dir = os.path.dirname(p[0])
break
if inc_dir is not None:
dict_append(info, include_dirs=[inc_dir],
define_macros=[('SCIPY_AMD_H',None)],
swig_opts = ['-I' + inc_dir])
self.set_info(**info)
return
class umfpack_info(system_info):
section = 'umfpack'
dir_env_var = 'UMFPACK'
notfounderror = UmfpackNotFoundError
_lib_names = ['umfpack']
def calc_info(self):
lib_dirs = self.get_lib_dirs()
umfpack_libs = self.get_libs('umfpack_libs', self._lib_names)
for d in lib_dirs:
umf = self.check_libs(d,umfpack_libs,[])
if umf is not None:
info = umf
break
else:
return
include_dirs = self.get_include_dirs()
inc_dir = None
for d in include_dirs:
p = self.combine_paths(d,['','umfpack'],'umfpack.h')
if p:
inc_dir = os.path.dirname(p[0])
break
if inc_dir is not None:
dict_append(info, include_dirs=[inc_dir],
define_macros=[('SCIPY_UMFPACK_H',None)],
swig_opts = ['-I' + inc_dir])
amd = get_info('amd')
dict_append(info, **get_info('amd'))
self.set_info(**info)
return
## def vstr2hex(version):
## bits = []
## n = [24,16,8,4,0]
## r = 0
## for s in version.split('.'):
## r |= int(s) << n[0]
## del n[0]
## return r
#--------------------------------------------------------------------
def combine_paths(*args,**kws):
""" Return a list of existing paths composed by all combinations of
items from arguments.
"""
r = []
for a in args:
if not a: continue
if is_string(a):
a = [a]
r.append(a)
args = r
if not args: return []
if len(args)==1:
result = reduce(lambda a,b:a+b,map(glob,args[0]),[])
elif len (args)==2:
result = []
for a0 in args[0]:
for a1 in args[1]:
result.extend(glob(os.path.join(a0,a1)))
else:
result = combine_paths(*(combine_paths(args[0],args[1])+args[2:]))
verbosity = kws.get('verbosity',1)
log.debug('(paths: %s)', ','.join(result))
return result
language_map = {'c':0,'c++':1,'f77':2,'f90':3}
inv_language_map = {0:'c',1:'c++',2:'f77',3:'f90'}
def dict_append(d,**kws):
languages = []
for k,v in kws.items():
if k=='language':
languages.append(v)
continue
if k in d:
if k in ['library_dirs','include_dirs','define_macros']:
[d[k].append(vv) for vv in v if vv not in d[k]]
else:
d[k].extend(v)
else:
d[k] = v
if languages:
l = inv_language_map[max([language_map.get(l,0) for l in languages])]
d['language'] = l
return
def parseCmdLine(argv=(None,)):
import optparse
parser = optparse.OptionParser("usage: %prog [-v] [info objs]")
parser.add_option('-v', '--verbose', action='store_true', dest='verbose',
default=False,
help='be verbose and print more messages')
opts, args = parser.parse_args(args=argv[1:])
return opts, args
def show_all(argv=None):
import inspect
if argv is None:
argv = sys.argv
opts, args = parseCmdLine(argv)
if opts.verbose:
log.set_threshold(log.DEBUG)
else:
log.set_threshold(log.INFO)
show_only = []
for n in args:
if n[-5:] != '_info':
n = n + '_info'
show_only.append(n)
show_all = not show_only
_gdict_ = globals().copy()
for name, c in _gdict_.iteritems():
if not inspect.isclass(c):
continue
if not issubclass(c, system_info) or c is system_info:
continue
if not show_all:
if name not in show_only:
continue
del show_only[show_only.index(name)]
conf = c()
conf.verbosity = 2
r = conf.get_info()
if show_only:
log.info('Info classes not defined: %s',','.join(show_only))
if __name__ == "__main__":
show_all()
|