def after_registration(cls, **kwargs):
r"""Operations that should be performed to modify class attributes after
registration."""
if cls.default_compiler is None:
if platform._is_linux:
cls.default_compiler = 'g++'
elif platform._is_mac:
cls.default_compiler = 'clang++'
elif platform._is_win: # pragma: windows
cls.default_compiler = 'cl'
cls.function_param['print'] = 'std::cout << "{message}" << std::endl;'
CModelDriver.after_registration(cls, **kwargs)
if kwargs.get('second_pass', False):
return
internal_libs = copy.deepcopy(cls.internal_libraries)
internal_libs[cls.interface_library] = internal_libs.pop(
CModelDriver.interface_library)
internal_libs[cls.interface_library]['source'] = os.path.join(
cls.get_language_dir(),
os.path.splitext(
os.path.basename(
internal_libs[cls.interface_library]['source']))[0] +
cls.language_ext[0])
internal_libs[cls.interface_library]['include_dirs'].append(
cls.get_language_dir())
internal_libs[cls.interface_library]['language'] = cls.language
cls.internal_libraries = internal_libs
def test_get_compilation_tool():
r"""Test get_compilation_tool for different name variations."""
from yggdrasil.drivers.CModelDriver import CModelDriver
if CModelDriver.is_language_installed():
tooltype = 'compiler'
out = CModelDriver.get_tool('compiler').__class__
toolname = out.toolname.lower()
toolpath = os.path.join('somedir', toolname)
toolfile = toolpath + '.exe'
vals = [toolpath, toolfile]
if platform._is_win:
vals += [toolname.upper(), toolfile.upper()]
for v in vals:
assert_equal(CompiledModelDriver.get_compilation_tool(tooltype, v),
out)
assert_raises(ValueError, CompiledModelDriver.get_compilation_tool,
'compiler', 'invalid')
# else:
# assert_raises(NotImplementedError, CModelDriver.get_tool, 'compiler')
# assert_equal(CModelDriver.get_tool(
# 'compiler', default='invalid'), 'invalid')
assert_equal(
CompiledModelDriver.get_compilation_tool('compiler',
'invalid',
default='invalid'), 'invalid')
def test_update_ld_library_path():
r"""Test update_ld_library_path method."""
lang_dir = CModelDriver.get_language_dir()
total = os.pathsep.join(['test', lang_dir])
env = {'LD_LIBRARY_PATH': 'test'}
env = CModelDriver.update_ld_library_path(env)
assert (env['LD_LIBRARY_PATH'] == total)
# Second time to ensure that path not added twice
env = CModelDriver.update_ld_library_path(env)
assert (env['LD_LIBRARY_PATH'] == total)
def test_create_include():
r"""Test create_include."""
target = 'target'
tempdir = tempfile.gettempdir()
fname_dll = os.path.join(tempdir, 'test.dll')
fname_lib = os.path.join(tempdir, 'test.lib')
for fname in [fname_dll, fname_lib]:
with open(fname, 'w') as fd:
fd.write('')
assert(os.path.isfile(fname))
testlist = [(['-DYGG'], [], ['ADD_DEFINITIONS(-DYGG)']),
(['-Wall'], [], ['ADD_DEFINITIONS(-Wall)']),
(['/nologo'], [], ['ADD_DEFINITIONS(/nologo)']),
(['-Iinclude_dir'], [], ['INCLUDE_DIRECTORIES(include_dir)']),
([], ['-lm'], ['TARGET_LINK_LIBRARIES(%s -lm)' % target]),
([], ['-Llib_dir'], ['LINK_DIRECTORIES(lib_dir)']),
([], ['/LIBPATH:"lib_dir"'], ['LINK_DIRECTORIES(lib_dir)']),
([], ['m'], ['TARGET_LINK_LIBRARIES(%s m)' % target])]
if CMakeConfigure.add_libraries: # pragma: debug
testlist += [([], [fname_dll], ['ADD_LIBRARY(test SHARED IMPORTED)']),
([], [fname_lib], ['ADD_LIBRARY(test STATIC IMPORTED)'])]
else:
tempdir_cp = tempdir
if platform._is_win: # pragma: windows
tempdir_cp = tempdir.replace('\\', re.escape('\\'))
testlist += [([], [fname_dll], [('FIND_LIBRARY(TEST_LIBRARY NAMES %s '
'test HINTS %s)')
% (os.path.basename(fname_dll), tempdir_cp)]),
([], [fname_lib], [('FIND_LIBRARY(TEST_LIBRARY NAMES %s '
'test HINTS %s)')
% (os.path.basename(fname_lib), tempdir_cp)])]
from yggdrasil.drivers.CModelDriver import CModelDriver
CModelDriver.compile_dependencies()
CMakeModelDriver.compile_dependencies()
kws = {'compiler': CModelDriver.get_tool('compiler'),
'linker': CModelDriver.get_tool('linker')}
for c, l, lines in testlist:
out = CMakeConfigure.create_include(None, target, compiler_flags=c,
linker_flags=l, verbose=True,
**kws)
for x in lines:
try:
assert(x in out)
except AssertionError: # pragma: debug
print("Could not find '%s':" % x)
pprint.pprint(out)
raise
for fname in [fname_dll, fname_lib]:
os.remove(fname)
assert_raises(ValueError, CMakeConfigure.create_include,
None, target, compiler_flags=['invalid'], **kws)
assert_raises(ValueError, CMakeConfigure.create_include,
None, target, linker_flags=['-invalid'], **kws)
assert_raises(ValueError, CMakeConfigure.create_include,
None, target, linker_flags=['/invalid'], **kws)
def __init__(self, *args, **kwargs):
super(TestCModelParam, self).__init__(*args, **kwargs)
script_dir = os.path.dirname(self.src[0])
self.args = [self.args[0], '1']
if CModelDriver.is_installed():
compiler = CModelDriver.get_tool('compiler')
linker = CModelDriver.get_tool('linker')
include_flag = compiler.create_flag('include_dirs', script_dir)
library_flag = linker.create_flag('library_dirs', script_dir)
self._inst_kwargs.update(compiler_flags=include_flag,
linker_flags=library_flag)
def test_GCCCompiler_dll2a():
r"""Test the dll2a method of the GCCCompiler class."""
gcc = CModelDriver.get_tool('compiler', toolname='gcc', default=None)
if gcc:
kws = {'toolname': 'gcc'}
if platform._is_win:
kws['libtype'] = 'shared'
dll = CModelDriver.get_dependency_library('python', **kws)
gcc.dll2a(dll, overwrite=True)
else:
with pytest.raises(NotImplementedError):
CModelDriver.get_tool('compiler', toolname='gcc')
def set_env(self):
r"""Get environment variables that should be set for the model process.
Returns:
dict: Environment variables for the model process.
"""
out = super(RModelDriver, self).set_env()
out['RETICULATE_PYTHON'] = PythonModelDriver.get_interpreter()
c_linker = CModelDriver.get_tool('linker')
search_dirs = c_linker.get_search_path(conda_only=True)
out = CModelDriver.update_ld_library_path(out,
paths_to_add=search_dirs,
add_to_front=True)
return out
def set_env(self, **kwargs):
r"""Get environment variables that should be set for the model process.
Args:
**kwargs: Additional keyword arguments are passed to the parent
class's method.
Returns:
dict: Environment variables for the model process.
"""
if kwargs.get('for_compile', False):
kwargs.setdefault('compile_kwargs', {})
kwargs['compile_kwargs']['language'] = self.target_language
kwargs['compile_kwargs'][
'language_driver'] = self.target_language_driver
for k in [
'env_compiler', 'env_compiler_flags', 'env_linker',
'env_linker_flags'
]:
kwargs['compile_kwargs'][k] = getattr(self, k)
out = super(MakeModelDriver, self).set_env(**kwargs)
if not kwargs.get('for_compile', False):
if hasattr(self.target_language_driver, 'update_ld_library_path'):
self.target_language_driver.update_ld_library_path(out)
# C++ may also need the C libraries
if self.target_language == 'c++':
out = CModelDriver.update_ld_library_path(out)
return out
def test_get_compilation_tool():
r"""Test get_compilation_tool for different name variations."""
from yggdrasil.drivers.CModelDriver import CModelDriver
tooltype = 'compiler'
out = CModelDriver.get_tool('compiler').__class__
toolname = out.toolname.lower()
toolpath = os.path.join('somedir', toolname)
toolfile = toolpath + '.exe'
vals = [toolname.upper(), toolpath, toolfile, toolfile.upper()]
for v in vals:
assert_equal(CompiledModelDriver.get_compilation_tool(tooltype, v), out)
assert_raises(ValueError, CompiledModelDriver.get_compilation_tool,
'compiler', 'invalid')
def set_env_class(cls, **kwargs):
r"""Set environment variables that are instance independent.
Args:
**kwargs: Additional keyword arguments are passed to the parent
class's method and update_ld_library_path.
Returns:
dict: Environment variables for the model process.
"""
out = super(CPPModelDriver, cls).set_env_class(**kwargs)
out = CModelDriver.update_ld_library_path(out, **kwargs)
return out
def set_env(self, **kwargs):
r"""Get environment variables that should be set for the model process.
Args:
**kwargs: Additional keyword arguments are passed to the parent
class's method.
Returns:
dict: Environment variables for the model process.
"""
out = super(CPPModelDriver, self).set_env(**kwargs)
out = CModelDriver.update_ld_library_path(out)
return out
