def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
try:
wx_config = os.environ["WX_CONFIG"]
except KeyError:
locations = []
try:
locations.append(environ["MINGW_DIR"])
locations.append(environ["MSYS_DIR"])
except KeyError:
pass
try:
wx_config = find_program("wx-config", locations)
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
try:
cppflags_cmd = [wx_config, "--cppflags"]
process = subprocess.Popen(cppflags_cmd, stdout=subprocess.PIPE)
cflags = process.communicate()[0].split()
ldflags_cmd = [wx_config, "--libs", "--gl-libs", "--static=no"]
process = subprocess.Popen(ldflags_cmd, stdout=subprocess.PIPE)
ldflags = process.communicate()[0].split()
self.found = True
except OSError:
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment["WX_CPP_FLAGS"] = cflags
self.environment["WX_LD_FLAGS"] = ldflags
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
lib_name = 'cdf'
if 'windows' in platform.system().lower():
lib_name += 'NativeLibrary'
if version is None:
version = '35_0'
limit = False
base_dirs = []
if 'CDF_BASE' in environ and environ['CDF_BASE']:
base_dirs.append(environ['CDF_BASE'])
limit = True
if 'CDF_LIB' in environ and environ['CDF_LIB']:
base_dirs.append(environ['CDF_LIB'])
limit = True
if 'CDF_INC' in environ and environ['CDF_INC']:
base_dirs.append(environ['CDF_INC'])
limit = True
if 'CDF_BIN' in environ and environ['CDF_BIN']:
base_dirs.append(environ['CDF_BIN'])
limit = True
if 'CDF_LIB_DIR' in environ and environ['CDF_LIB_DIR']:
base_dirs.append(environ['CDF_LIB_DIR'])
limit = True
if 'CDF_INCLUDE_DIR' in environ and environ['CDF_INCLUDE_DIR']:
base_dirs.append(environ['CDF_INCLUDE_DIR'])
if not limit:
try:
base_dirs += os.environ['LD_LIBRARY_PATH'].split(os.pathsep)
base_dirs += os.environ['CPATH'].split(os.pathsep)
except KeyError:
pass
if 'windows' in platform.system().lower():
base_dirs.append(os.path.join('C:', os.sep, 'CDF Distribution',
'cdf' + version + '-dist'))
try:
base_dirs.append(environ['MINGW_DIR'])
base_dirs.append(environ['MSYS_DIR'])
except KeyError:
pass
try:
incl_dir = find_header(self.hdr, base_dirs, limit=limit)
lib_dir, lib = find_library(self.lib, base_dirs, limit=limit)
exe = find_program('cdfcompare', base_dirs)
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment['CDF_INCLUDE_DIR'] = incl_dir
self.environment['CDF_LIB_DIR'] = lib_dir
self.environment['CDF_LIB_FILES'] = [lib]
self.environment['CDF_LIBRARIES'] = [lib_name]
os.environ['CDF_LIB'] = os.path.abspath(lib_dir)
os.environ['CDF_INC'] = os.path.abspath(incl_dir)
os.environ['CDF_BIN'] = os.path.abspath(os.path.dirname(exe))
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
try:
locations = glob.glob(os.path.join('C:' + os.sep + 'OpenSCG',
'openjdk*'))
java_runtime = find_program('java', locations)
java_compiler = find_program('javac', locations)
jar_archiver = find_program('jar', locations)
if not self.__check_java_version(java_runtime, [version]):
return self.found
classpaths = []
try:
_sep_ = ':'
if 'windows' in platform.system().lower():
_sep_ = ';'
pathlist = os.environ['CLASSPATH'].split(_sep_)
for path in pathlist:
classpaths.append(path)
except KeyError:
pass
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment['JAVA'] = java_runtime
self.environment['JAVA_HOME'] = os.path.abspath(os.path.join(
os.path.dirname(java_runtime), '..'))
self.environment['JAVAC'] = java_compiler
self.environment['JAR'] = jar_archiver
self.environment['CLASSPATH'] = classpaths
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
try:
ver, hdf5_inc_dir, \
hdf5_lib_dir, hdf5_libs = self.get_version(environ)
not_ok = (compare_versions(ver, version) == -1)
if strict:
not_ok = (compare_versions(ver, version) != 0)
if not_ok:
if self.debug:
print('Wrong version of ' + self.lib + ': ' +
str(ver) + ' vs ' + str(version))
self.found = False
return self.found
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
hdf5_lib_list = ['hdf5', 'hdf5_fortran', 'hdf5_cpp',
'hdf5_hl', 'hdf5hl_fortran', 'hdf5_hl_cpp',]
if 'windows' in platform.system().lower():
hdf5_lib_list = ['hdf5dll', 'hdf5_fortrandll', 'hdf5_cppdll',
'hdf5_hldll', 'hdf5_hl_fortrandll', 'hdf5_hl_cppdll',]
self.environment['HDF5_INCLUDE_DIR'] = hdf5_inc_dir
self.environment['HDF5_LIB_DIR'] = hdf5_lib_dir
self.environment['HDF5_LIB_FILES'] = hdf5_libs
self.environment['HDF5_LIBRARIES'] = hdf5_lib_list
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
try:
pyjamas_root = os.environ['PYJAMAS_ROOT']
pyjs_bin = os.path.join(pyjamas_root, 'bin')
#pyjs_lib = os.path.join(pyjamas_root, 'build', 'lib')
self.environment['PYJSBUILD'] = find_program('pyjsbuild',
[pyjs_bin])
self.found = True
except (KeyError, ConfigError, ImportError):
if self.debug:
print(sys.exc_info()[1])
try:
local = glob.glob(os.path.join(options.target_build_dir,
'pyjamas-*'))
local_bins = []
if len(local):
local_bins.append(os.path.join(local[0], 'bin'))
self.environment['PYJSBUILD'] = find_program('pyjsbuild',
local_bins)
self.found = True
except (ImportError, ConfigError):
if self.debug:
print(sys.exc_info()[1])
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
limit = False
locations = []
if self.exe.upper() in environ and environ[self.exe.upper()]:
locations.append(os.path.dirname(environ[self.exe.upper()]))
limit = True
if not limit:
try:
locations.append(os.environ[self.exe.upper() + '_ROOT'])
except KeyError:
pass
try:
locations.append(environ['MINGW_DIR'])
locations.append(environ['MSYS_DIR'])
except KeyError:
pass
try:
program = find_program(self.exe, locations, limit=limit)
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment[self.exe.upper()] = program
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
self.found = system_uses_homebrew()
if self.found:
self.brews_found = os.path.exists(python_executable()) and \
os.path.exists(pip_executable())
exe = os.path.realpath(sys.executable)
if self.brews_found and \
not exe in python_sys_executables():
switch_python()
return self.found and self.brews_found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
try:
gomp_lib_dir, gomp_lib = find_library('gomp')
self.environment['GOMP_LIBRARY_DIR'] = gomp_lib_dir
self.environment['GOMP_LIBRARY'] = gomp_lib
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
try:
incl_dir = find_header("f2c.h")
## f2c lib is built into libgfortran
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment["F2C_INCLUDE_DIR"] = incl_dir
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
if version is None:
version = '1.9.4'
try:
local_dir = os.path.join(options.target_build_dir, 'neo4j-*', 'bin')
self.environment['NEO4J'] = find_program('neo4j', [local_dir])
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
locations = []
limit = False
if 'GEOS_LIB_DIR' in environ and environ['GEOS_LIB_DIR']:
locations.append(environ['GEOS_LIB_DIR'])
limit = True
if 'GEOS_INCLUDE_DIR' in environ and environ['GEOS_INCLUDE_DIR']:
locations.append(environ['GEOS_INCLUDE_DIR'])
if not limit:
try:
locations += os.environ['LD_LIBRARY_PATH'].split(os.pathsep)
except KeyError:
pass
try:
locations.append(os.environ['GEOS_ROOT'])
except KeyError:
pass
if 'windows' in platform.system().lower():
locations.append(os.path.join('C:', os.sep, 'OSGeo4W'))
try:
locations.append(environ['MINGW_DIR'])
locations.append(environ['MSYS_DIR'])
except KeyError:
pass
try:
lib_dir, libs = find_libraries(self.lib, locations, limit=limit)
inc_dir = find_header(self.hdr, locations, limit=limit)
quoted_ver = get_header_version(os.path.join(inc_dir, self.hdr),
'GEOS_VERSION ')
ver = quoted_ver[1:-1]
not_ok = (compare_versions(ver, version) == -1)
if strict:
not_ok = (compare_versions(ver, version) != 0)
if not_ok:
if self.debug:
print('Wrong version of ' + self.lib + ': ' +
str(ver) + ' vs ' + str(version))
return self.found
self.found = True
except ConfigError:
if self.debug:
e = sys.exc_info()[1]
print(e)
return self.found
self.environment['GEOS_INCLUDE_DIR'] = inc_dir
self.environment['GEOS_LIBRARY_DIR'] = lib_dir
self.environment['GEOS_LIBRARIES'] = ['geos', ' geos_c',]
self.environment['GEOS_LIB_FILES'] = libs
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
prev = prog_config.is_installed(self, environ, version, strict)
if prev:
locations = [os.path.dirname(self.environment[self.exe.upper()])]
try:
program = find_program('npm', locations, limit=True)
self.environment['NPM'] = program
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return False
return prev
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
self.found = system_uses_macports()
if self.found:
self.ports_found = os.path.exists(python_executable())
exe_ok = False
for exe in python_sys_executables():
if exe.startswith(sys.exec_prefix):
exe_ok = True
break
if self.ports_found and not exe_ok:
if self.debug:
print(sys.exec_prefix + "/bin/python not in " + \
repr(python_sys_executables()))
switch_python()
return self.found and self.ports_found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
base_dirs = []
limit = False
if 'GRAPHVIZ_LIB_DIR' in environ and \
environ['GRAPHVIZ_LIB_DIR']:
base_dirs.append(environ['GRAPHVIZ_LIB_DIR'])
limit = True
if 'GRAPHVIZ_INCLUDE_DIR' in environ and \
environ['GRAPHVIZ_INCLUDE_DIR']:
base_dirs.append(environ['GRAPHVIZ_INCLUDE_DIR'])
if not limit:
try:
base_dirs += os.environ['LD_LIBRARY_PATH'].split(os.pathsep)
base_dirs += os.environ['CPATH'].split(os.pathsep)
except KeyError:
pass
try:
base_dirs.append(os.environ['GRAPHVIZ_ROOT'])
except KeyError:
pass
for d in programfiles_directories():
base_dirs.append(os.path.join(d, 'GnuWin32'))
base_dirs += glob_insensitive(d, self.lib + '*')
try:
base_dirs.append(environ['MINGW_DIR'])
base_dirs.append(environ['MSYS_DIR'])
except KeyError:
pass
try:
incl_dir = find_header(self.hdr, base_dirs, limit=limit)
lib_dir, lib = find_library(self.lib, base_dirs, limit=limit)
self.found = True
except ConfigError:
if self.debug:
e = sys.exc_info()[1]
print(e)
return self.found
self.environment['GRAPHVIZ_INCLUDE_DIR'] = incl_dir
self.environment['GRAPHVIZ_LIB_DIR'] = lib_dir
self.environment['GRAPHVIZ_SHLIB_DIR'] = lib_dir
self.environment['GRAPHVIZ_LIB_FILES'] = [lib]
self.environment['GRAPHVIZ_LIBRARIES'] = [self.lib]
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
if 'MSVC' in environ:
raise Exception('MinGW *and* MS Visual C both specified ' +
'as the chosen compiler.')
limit = False
if 'MINGW_DIR' in environ and environ['MINGW_DIR']:
mingw_root = environ['MINGW_DIR']
limit = True
if not limit:
try:
mingw_root = os.environ['MINGW_ROOT']
except KeyError:
locations = [os.path.join('C:', os.sep, 'MinGW')]
for d in programfiles_directories():
locations.append(os.path.join(d, 'MinGW'))
try:
gcc = find_program('mingw32-gcc', locations)
mingw_root = os.path.abspath(os.path.join(
os.path.dirname(gcc), '..'))
except ConfigError:
if self.debug:
print(sys.exc_info[1])
return self.found
msys_root = os.path.join(mingw_root, 'msys', '1.0')
try:
gcc = find_program('mingw32-gcc', [mingw_root], limit=limit)
gxx = find_program('mingw32-g++', [mingw_root], limit=limit)
gfort = find_program('mingw32-gfortran', [mingw_root], limit=limit)
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment['MINGW_DIR'] = mingw_root
self.environment['MSYS_DIR'] = msys_root
self.environment['MINGW_CC'] = gcc
self.environment['MINGW_CXX'] = gxx
self.environment['MINGW_FORTRAN'] = gfort
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
try:
import wxglade.common
ver = wxglade.common.version
not_ok = (compare_versions(ver, version) == -1)
if strict:
not_ok = (compare_versions(ver, version) != 0)
if not_ok:
if self.debug:
print('Wrong version of wxGlade: ' +
str(ver) + ' vs ' + str(version))
return self.found
self.environment['WXGLADE'] = find_program('wxglade')
self.found = True
except (ImportError, ConfigError):
if self.debug:
print(sys.exc_info()[1])
return self.found
def is_installed(self, environ, version=None, strict=False):
if version is None:
version = '3.1.2'
options.set_debug(self.debug)
limit = False
antlr_root = None
if 'ANTLR' in environ and environ['ANTLR']:
antlr_root = environ['ANTLR']
limit = True
classpaths = []
if not limit:
try:
pathlist = environ['CLASSPATH'] ## from java config
for path in pathlist:
classpaths.append(os.path.dirname(path))
except KeyError:
pass
try:
antlr_root = os.environ['ANTLR_ROOT']
except KeyError:
pass
for d in programfiles_directories():
classpaths.append(os.path.join(d, 'ANTLR', 'lib'))
try:
java_home = None
if 'JAVA_HOME' in environ.keys():
java_home = os.path.join(environ['JAVA_HOME'], 'lib')
jarfile = find_file('antlr*' + version[0] + '*.jar',
['/usr/share/java', '/usr/local/share/java',
'/opt/local/share/java', java_home,
antlr_root,] + classpaths)
self.environment['ANTLR'] = [environ['JAVA'],
"-classpath", os.path.abspath(jarfile),
"org.antlr.Tool",]
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
limit = False
locations = []
if 'CTYPESGEN' in environ and environ['CTYPESGEN']:
locations.append(os.path.dirname(environ['CTYPESGEN']))
limit = True
try:
exe = find_program('ctypesgen.py', locations, limit=limit)
import ctypesgencore
lib = os.path.dirname(os.path.dirname(ctypesgencore.__file__))
self.found = True
except (ConfigError, ImportError):
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment['CTYPESGEN'] = exe
self.environment['CTYPESGEN_PATH'] = lib
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
base_dirs = []
if 'GIT' in environ and environ['GIT']:
base_dirs.append(os.path.dirname(environ['GIT']))
base_dirs.append(os.path.join('C:', os.sep, 'msysgit', 'cmd'))
for d in programfiles_directories():
base_dirs.append(os.path.join(d, 'Git', 'cmd'))
try:
base_dirs.append(environ['MINGW_DIR'])
base_dirs.append(environ['MSYS_DIR'])
except KeyError:
pass
try:
self.environment['GIT'] = find_program('git', base_dirs)
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
base_dirs = []
limit = False
if 'PROJ4_LIB_DIR' in environ and environ['PROJ4_LIB_DIR']:
base_dirs.append(environ['PROJ4_LIB_DIR'])
limit = True
if 'PROJ4_INCLUDE_DIR' in environ and environ['PROJ4_INCLUDE_DIR']:
base_dirs.append(environ['PROJ4_INCLUDE_DIR'])
if not limit:
try:
base_dirs += os.environ['LD_LIBRARY_PATH'].split(os.pathsep)
except KeyError:
pass
try:
base_dirs.append(os.environ['PROJ4_ROOT'])
except KeyError:
pass
if 'windows' in platform.system().lower():
base_dirs.append(os.path.join('C:', os.sep, 'OSGeo4W'))
try:
base_dirs.append(environ['MINGW_DIR'])
base_dirs.append(environ['MSYS_DIR'])
except KeyError:
pass
try:
proj4_inc_dir = find_header(self.hdr, base_dirs)
proj4_lib_dir, proj4_libs = find_libraries(self.lib, base_dirs)
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment['PROJ4_INCLUDE_DIR'] = proj4_inc_dir
self.environment['PROJ4_LIBRARY_DIR'] = proj4_lib_dir
self.environment['PROJ4_LIBRARIES'] = ['proj']
self.environment['PROJ4_LIB_FILES'] = proj4_libs
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
try:
import matplotlib
ver = matplotlib.__version__
not_ok = (compare_versions(ver, version) == -1)
if strict:
not_ok = (compare_versions(ver, version) != 0)
if not_ok:
if self.debug:
print('Wrong version of ' + self.pkg + ': ' +
str(ver) + ' vs ' + str(version))
return self.found
self.found = True
except ImportError:
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment['MATPLOTLIB_DATA_FILES'] = \
matplotlib.get_py2exe_datafiles()
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
base_dirs = []
limit = False
if 'DL_LIB_DIR' in environ and environ['DL_LIB_DIR']:
base_dirs.append(environ['DL_LIB_DIR'])
limit = True
if 'DL_INCLUDE_DIR' in environ and environ['DL_INCLUDE_DIR']:
base_dirs.append(environ['DL_INCLUDE_DIR'])
if not limit:
try:
base_dirs += os.environ['LD_LIBRARY_PATH'].split(os.pathsep)
base_dirs += os.environ['CPATH'].split(os.pathsep)
except KeyError:
pass
try:
base_dirs.append(environ['MINGW_DIR'])
base_dirs.append(environ['MSYS_DIR'])
except KeyError:
pass
try:
incl_dir = find_header(self.hdr, base_dirs, limit=limit)
lib_dir, lib = find_library(self.lib, base_dirs,
limit=limit, wildcard=False)
self.found = True
except ConfigError:
if self.debug:
e = sys.exc_info()[1]
print(e)
return self.found
self.environment['DL_INCLUDE_DIR'] = incl_dir
self.environment['DL_LIB_DIR'] = lib_dir
self.environment['DL_SHLIB_DIR'] = lib_dir
self.environment['DL_LIB_FILES'] = [lib]
self.environment['DL_LIBRARIES'] = [self.lib]
return self.found
def is_installed(self, environ, version, strict=False):
options.set_debug(self.debug)
if 'MINGW_CC' in environ:
raise Exception('MS Visual C *and* MinGW both specified ' +
'as the chosen compiler.')
version, _, _ = get_msvc_version()
dot_ver = '.'.join(version)
vcvars = None
nmake = None
msvc = None
msvc_dirs = []
limit = False
if 'MSVC' in environ and environ['MSVC']:
msvc_dirs.append(os.path.dirname(environ['MSVC']))
limit = True
if not limit:
for d in programfiles_directories():
msvc_dirs.append(os.path.join(d,
'Microsoft Visual Studio ' + dot_ver,
'VC'))
try:
vcvars = find_program('vcvarsall', msvc_dirs, limit=limit)
nmake = find_program('nmake', msvc_dirs, limit=limit)
msvc = find_program('cl', msvc_dirs, limit=limit)
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment['MSVC_VARS'] = vcvars
self.environment['NMAKE'] = nmake
self.environment['MSVC'] = msvc
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
limit = False
base_dirs = []
if 'GCCXML' in environ and environ['GCCXML']:
base_dirs.append(os.path.dirname(environ['GCCXML']))
limit = True
if not limit:
for d in programfiles_directories():
base_dirs.append(os.path.join(d, 'GCC_XML'))
try:
base_dirs.append(environ['MINGW_DIR'])
base_dirs.append(environ['MSYS_DIR'])
except KeyError:
pass
try:
self.environment['GCCXML'] = find_program('gccxml', base_dirs,
limit=limit)
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
msvcr_rel_dirs = []
msvcr_dbg_dirs = []
limit = False
if 'MSVCRT_DIR' in environ and environ['MSVCRT_DIR']:
msvcr_rel_dirs.append(environ['MSVCRT_DIR'])
limit = True
if 'MSVCRT_DEBUG_DIR' in environ and environ['MSVCRT_DEBUG_DIR']:
msvcr_dbg_dirs.append(environ['MSVCRT_DEBUG_DIR'])
version, _, _ = get_msvc_version()
dot_ver = '.'.join(version)
ver = ''.join(version)
msvs_present = False
if not limit:
for d in programfiles_directories():
msvcr_rel_dirs.append(
os.path.join(d, 'Microsoft Visual Studio ' + dot_ver,
'VC', 'redist', 'x86',
'Microsoft.VC' + ver + '.CRT'))
msvcr_dbg_dirs.append(
os.path.join(d, 'Microsoft Visual Studio ' + dot_ver,
'VC', 'redist', 'Debug_NonRedist', 'x86',
'Microsoft.VC' + ver + '.DebugCRT'))
if os.path.exists(
os.path.join(d, 'Microsoft Visual Studio ' + dot_ver)):
msvs_present = True
if not msvs_present:
try:
msvcr_rel_dirs.append(os.environ['MSVCRT_DIR'])
except KeyError:
pass
try:
msvcr_rel_dirs.append(os.environ['SYSTEM'])
except KeyError:
pass
try:
msvcr_rel_dirs.append(os.environ['WINDIR'])
except KeyError:
pass
release_dir = None
debug_dir = None
try:
# Just the DLLs
release_dir, _ = find_library('msvcr' + ver, msvcr_rel_dirs,
limit=limit)
if msvs_present:
debug_dir, _ = find_library('msvcr' + ver, msvcr_dbg_dirs,
limit=limit)
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment['MSVCRT_DIR'] = release_dir
if msvs_present:
self.environment['MSVCRT_DEBUG_DIR'] = debug_dir
self.environment['MSVCRT_LIBRARIES'] = ['msvcr' + ver, 'msvcp' + ver]
return self.found
def is_installed(self, environ, version=None, strict=False):
if version is None:
ver = '5'
else:
ver = version.split('.')[0]
options.set_debug(self.debug)
lib_ver = ''
base_dirs = []
limit = False
if 'PERL_LIB_DIR' in environ and environ['PERL_LIB_DIR']:
base_dirs.append(environ['PERL_LIB_DIR'])
limit = True
if 'PERL_INCLUDE_DIR' in environ and environ['PERL_INCLUDE_DIR']:
base_dirs.append(environ['PERL_INCLUDE_DIR'])
if not limit:
try:
base_dirs += os.environ['LD_LIBRARY_PATH'].split(os.pathsep)
base_dirs += os.environ['CPATH'].split(os.pathsep)
except KeyError:
pass
try:
base_dirs.append(os.environ['PERL_CORE'])
except KeyError:
pass
try:
base_dirs.append(os.environ['PERL_ROOT'])
except KeyError:
pass
if 'windows' in platform.system().lower():
## Strawberry Perl from http://strawberryperl.com
base_dirs.append(os.path.join('C:', os.sep,
'strawberry', 'perl'))
try:
base_dirs.append(environ['MSYS_DIR']) ## msys includes perl
except KeyError:
pass
elif 'darwin' in platform.system().lower():
base_dirs.append(os.path.join('/', 'System', 'Library', 'Perl',
ver + '*', 'darwin-*'))
try:
perl_exe = find_program('perl', base_dirs)
incl_dir = find_header(self.hdr, base_dirs,
['CORE', os.path.join('lib', 'CORE'),
os.path.join('perl', 'CORE'),
os.path.join('perl' + ver, 'CORE'),
os.path.join('lib', 'perl' + ver,
ver + '.*', 'msys', 'CORE'),
])
lib_dir, perl_lib = find_library(self.lib, base_dirs,
[os.path.join('perl', 'bin'),
incl_dir,])
if 'windows' in platform.system().lower():
lib_ver = perl_lib[0].split('.')[0].split('perl')[1]
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment['PERL'] = perl_exe
self.environment['PERL_INCLUDE_DIR'] = incl_dir
self.environment['PERL_LIB_DIR'] = lib_dir
self.environment['PERL_LIBRARIES'] = ['perl' + lib_ver]
self.environment['PERL_LIB_FILES'] = [perl_lib]
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
openmpi_lib_list = ['mpi', 'mpi_cxx', 'mpi_f90']
arch = 'i686'
if struct.calcsize('P') == 8:
arch = 'x86_64'
base_dirs = []
limit = False
if 'OPENMPI_LIB_DIR' in environ and environ['OPENMPI_LIB_DIR']:
base_dirs.append(environ['OPENMPI_LIB_DIR'])
limit = True
if 'OPENMPI_INCLUDE_DIR' in environ and environ['OPENMPI_INCLUDE_DIR']:
base_dirs.append(environ['OPENMPI_INCLUDE_DIR'])
if not limit:
try:
base_dirs += os.environ['LD_LIBRARY_PATH'].split(os.pathsep)
base_dirs += os.environ['CPATH'].split(os.pathsep)
except KeyError:
pass
try:
base_dirs.append(os.environ['OPENMPI_ROOT'])
except KeyError:
pass
for d in programfiles_directories():
base_dirs.append(os.path.join(d, 'OPENMPI'))
try:
base_dirs.append(environ['MINGW_DIR'])
base_dirs.append(environ['MSYS_DIR'])
except KeyError:
pass
try:
subdirs = [os.path.join('openmpi', 'lib')]
openmpi_lib_dir, openmpi_libs = find_libraries(openmpi_lib_list[0],
base_dirs, subdirs)
openmpi_inc_dir = find_header(self.hdr, base_dirs,
['openmpi', 'openmpi-' + arch,])
openmpi_exe = find_program('mpicc', base_dirs +
[os.path.join(openmpi_lib_dir, '..')])
openmpi_exe_dir = os.path.abspath(os.path.dirname(openmpi_exe))
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
os.environ['PATH'] = os.environ.get('PATH', '') + \
os.pathsep + openmpi_exe_dir
self.environment['OPENMPI_PATH'] = openmpi_exe_dir
self.environment['OPENMPI_INCLUDE_DIR'] = openmpi_inc_dir
self.environment['OPENMPI_LIB_DIR'] = openmpi_lib_dir
self.environment['OPENMPI_LIBRARIES'] = openmpi_lib_list
self.environment['OPENMPI_LIB_FILES'] = openmpi_libs
try:
p = subprocess.Popen([openmpi_exe, '-show'],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = p.communicate()
if err != '':
self.found = False
return self.found
self.environment['OPENMPI_FLAGS'] = out.split()[1:]
except OSError:
self.found = False
return self.found
def is_installed(self, environ, version=None, strict=False):
if version is None:
required_version = "1_44_0"
else:
required_version = version.replace(".", "_")
# TODO not detecting if boost installed
options.set_debug(self.debug)
base_dirs = []
limit = False
if "BOOST_LIB_DIR" in environ and environ["BOOST_LIB_DIR"]:
base_dirs.append(environ["BOOST_LIB_DIR"])
limit = True
if "BOOST_INCLUDE_DIR" in environ and environ["BOOST_INCLUDE_DIR"]:
base_dirs.append(environ["BOOST_INCLUDE_DIR"])
if not limit:
try:
base_dirs += os.environ["LD_LIBRARY_PATH"].split(os.pathsep)
base_dirs += os.environ["CPATH"].split(os.pathsep)
except KeyError:
pass
try:
boost_root = os.environ["BOOST_ROOT"]
boost_root = boost_root.strip('"')
if os.path.exists(os.path.join(boost_root, "stage", "lib")):
base_dirs.append(os.path.join(boost_root, "stage"))
base_dirs.append(boost_root)
except KeyError:
pass
try:
base_dirs.append(os.environ["BOOST_LIBRARY_DIR"])
except KeyError:
pass
try:
base_dirs.append(environ["MINGW_DIR"])
base_dirs.append(environ["MSYS_DIR"])
except KeyError:
pass
try:
incl_dir = find_header(os.path.join("boost", "version.hpp"), base_dirs, ["boost-*"], limit=limit)
lib_dir, libs = find_libraries("boost", base_dirs, limit=limit)
# TODO boost lib_dir is wrong in windows (maybe)
boost_version = get_header_version(os.path.join(incl_dir, "boost", "version.hpp"), "BOOST_LIB_VERSION")
boost_version = boost_version.strip('"')
not_ok = compare_versions(boost_version, required_version) == -1
if strict:
not_ok = compare_versions(boost_version, required_version) != 0
if not_ok:
if self.debug:
print("Wrong version of Boost: " + str(boost_version) + " vs " + str(required_version))
return self.found
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
self.environment["BOOST_INCLUDE_DIR"] = incl_dir
self.environment["BOOST_LIB_DIR"] = lib_dir
self.environment["BOOST_LIB_FILES"] = libs
self.environment["BOOST_LIBRARIES"] = [
"boost_python",
"boost_date_time",
"boost_filesystem",
"boost_graph",
"boost_iostreams",
"boost_prg_exec_monitor",
"boost_program_options",
"boost_regex",
"boost_serialization",
"boost_signals",
"boost_system",
"boost_thread",
"boost_unit_test_framework",
"boost_wave",
"boost_wserialization",
]
return self.found
def is_installed(self, environ, version=None, strict=False):
options.set_debug(self.debug)
default_lib_paths = ['lib64', 'lib', '']
default_include_paths = ['include', os.path.join(self.lib, 'include')]
locations = [os.path.join(options.target_build_dir, d)
for d in default_include_paths + default_lib_paths]
limit = False
if self.lib.upper() + '_SHLIB_DIR' in environ and \
environ[self.lib.upper() + '_SHLIB_DIR']:
locations.append(environ[self.lib.upper() + '_SHLIB_DIR'])
if self.lib.upper() + '_LIB_DIR' in environ and \
environ[self.lib.upper() + '_LIB_DIR']:
locations.append(environ[self.lib.upper() + '_LIB_DIR'])
if self.lib.upper() + '_INCLUDE_DIR' in environ and \
environ[self.lib.upper() + '_INCLUDE_DIR']:
locations.append(environ[self.lib.upper() + '_INCLUDE_DIR'])
limit = True
if not limit:
try:
locations += os.environ['LD_LIBRARY_PATH'].split(os.pathsep)
locations += os.environ['LIBRARY_PATH'].split(os.pathsep)
locations += os.environ['CPATH'].split(os.pathsep)
except KeyError:
pass
try:
locations.append(os.environ[self.lib.upper() + '_ROOT'])
except KeyError:
pass
try:
locations.append(os.environ[self.lib.upper() + '_LIBRARY_DIR'])
except KeyError:
pass
for d in programfiles_directories():
locations.append(os.path.join(d, 'GnuWin32'))
locations += glob_insensitive(d, self.lib + '*')
try:
locations.append(environ['MINGW_DIR'])
locations.append(environ['MSYS_DIR'])
except KeyError:
pass
try:
if self.hdr:
subdirs = None
if self.hdr_dir:
subdirs = [self.hdr_dir]
incl_dir = find_header(self.hdr, locations, subdirs,
limit=limit)
default_lib_paths = ['lib64', 'lib', '']
for lib in default_lib_paths:
locations.insert(0,
os.path.abspath(os.path.join(incl_dir,
'..', lib)))
lib_dir, lib = find_library(self.lib, locations, limit=limit)
def_dir, defs = lib_dir, []
if 'windows' in platform.system().lower():
def_dir, defs = find_definitions(self.lib, locations,
limit=limit)
self.found = True
except ConfigError:
if self.debug:
print(sys.exc_info()[1])
return self.found
if self.hdr:
self.environment[self.lib.upper() + '_INCLUDE_DIR'] = incl_dir
self.environment[self.lib.upper() + '_LIB_DIR'] = def_dir
self.environment[self.lib.upper() + '_DEF_FILES'] = defs
self.environment[self.lib.upper() + '_SHLIB_DIR'] = lib_dir
self.environment[self.lib.upper() + '_LIB_FILES'] = [lib]
self.environment[self.lib.upper() + '_LIBRARIES'] = [self.lib]
return self.found
def handle_arguments(argv, option_list=()):
if '--quiet' in argv:
options.set_verbose(False)
if '--debug' in argv:
options.set_debug(True)
argv.remove('--debug')
option_plus_list = list(option_list)
option_plus_list.append('doc')
opts = dict()
opts['bundle'] = False
opts['runscript'] = ''
opts['ziplib'] = None
opts['install'] = True
opts['download'] = False
opts['sublevel'] = 0
opts['locally'] = True
sublevel_set = False
bundle = False
if 'py2exe' in argv:
bundle = True
if 'py2app' in argv:
bundle = True
app = ''
runscript = ''
for arg in list(argv):
if arg == '--show':
opts['install'] = False
if arg == '--system-install':
opts['locally'] = False
if arg == '--download':
opts['download'] = True
opts['install'] = False
if arg == '--sublevel':
idx = argv.index(arg)
opts['sublevel'] = int(argv[idx+1])
sublevel_set = True
if arg.startswith('--sublevel='):
opts['sublevel'] = int(arg[11:])
sublevel_set = True
if arg == '-b' or arg == '--build-base':
idx = argv.index(arg)
lvl = _set_options_dir(argv[idx+1], options.set_build_dir)
if not sublevel_set:
opts['sublevel'] = lvl
if arg.startswith('--build-base='):
lvl = _set_options_dir(arg[13:], options.set_build_dir)
if not sublevel_set:
opts['sublevel'] = lvl
if arg == '--download-dir':
idx = argv.index(arg)
lvl = _set_options_dir(argv[idx+1], options.set_download_dir)
if not sublevel_set:
opts['sublevel'] = lvl
if arg.startswith('--download-dir='):
lvl = _set_options_dir(arg[15:], options.set_download_dir)
if not sublevel_set:
opts['sublevel'] = lvl
## args that won't work with setup
if arg.startswith('--app='):
app = runscript = arg[6:].lower()
runscript = arg[6:].lower()
if not runscript.endswith('.py'):
runscript = runscript + '.py'
for root, _, filenames in os.walk('.'): ## source directory
for filename in filenames:
if filename == runscript:
runscript = os.path.join(root, filename)
break
argv.remove(arg)
if arg.startswith('--ziplib'):
if '=' in arg:
opts['ziplib'] = arg[9:]
if opts['ziplib'][-4:] != '.zip':
opts['ziplib'] += '.zip'
else:
opts['ziplib'] = options.default_py2exe_library
argv.remove(arg)
if bundle and app != '' and runscript != '':
opts['bundle'] = bundle
opts['runscript'] = runscript
opts['app'] = app
opts['install_dir'] = sys.prefix
data_directory = 'share'
data_override = False
for idx, arg in enumerate(argv[:]):
if arg.startswith('--prefix='):
opts['install_dir'] = arg[9:]
elif arg.startswith('--home='):
opts['install_dir'] = arg[7:]
elif arg.startswith('--user='******'install_dir'] = arg[7:]
elif arg.startswith('--install-data='):
path = arg[15:]
if os.path.isabs(path):
opts['data_install_dir'] = path
data_override = True ## always overrides the above prefixes
else:
data_directory = path
elif arg.startswith('build_') and arg[6:] in option_plus_list:
opts[arg[6:]] = True
if not 'build' in argv:
argv.insert(idx, 'build')
argv.remove(arg)
elif arg.startswith('install_') and arg[8:] in option_plus_list:
opts[arg[8:]] = True
if not 'install' in argv:
argv.insert(idx, 'install')
argv.remove(arg)
elif arg.startswith('clean_') and arg[8:] in option_plus_list:
opts[arg[8:]] = True
if not 'clean' in argv:
argv.insert(idx, 'clean')
argv.remove(arg)
if not data_override:
opts['data_install_dir'] = os.path.join(opts['install_dir'],
data_directory)
if sum([arg.startswith('install') for arg in argv]) > 0:
argv.append('--install-data=' + opts['data_install_dir'])
build_all = True
for opt in option_list: ## do not build docs by default
if opt in opts:
build_all = False
if build_all:
for opt in option_list:
opts[opt] = True
if 'doc' in opts:
opts['documentation'] = True
else:
opts['documentation'] = False
return opts, argv
