def __init__(self, *args, **kwargs): super(TestClientResponseParam, self).__init__(*args, **kwargs) self.driver = 'ClientResponseDriver' self.args = None self.attr_list += ['comm', 'msg_id', 'response_address'] self.comm_name = tools.get_default_comm() self.server_comm = tools.get_default_comm() self.icomm_name = self.server_comm self.ocomm_name = self.comm_name
def __init__(self, *args, **kwargs): super(TestClientParam, self).__init__(*args, **kwargs) self.driver = 'ClientDriver' self.args = None self.attr_list += [ 'comm', 'response_drivers', 'request_name', 'request_address' ] # Increased to allow forwarding between IPC comms on MacOS # self.timeout = 5.0 self.route_timeout = 2 * self.timeout # self.debug_flag = True self.comm_name = tools.get_default_comm() self.server_comm = tools.get_default_comm() self.icomm_name = self.comm_name self.ocomm_name = self.server_comm
def __init__(self, *args, **kwargs): super(TestServerParam, self).__init__(*args, **kwargs) self.driver = 'ServerDriver' self.args = None self.attr_list += ['comm', 'response_drivers', 'nclients', 'request_name'] # Increased to allow forwarding between IPC comms on MacOS self.timeout = 5.0 self.route_timeout = 2 * self.timeout # if tools.get_default_comm() == "IPCComm": # self.route_timeout = 120.0 # self.debug_flag = True # self.sleeptime = 0.5 # self.timeout = 10.0 self.comm_name = tools.get_default_comm() self.client_comm = tools.get_default_comm() self.icomm_name = self.client_comm self.ocomm_name = self.comm_name
def _get_alias(cls, overwrite=False): r"""Initialize the default comm class as the alias. Args: overwrite (bool, optional): If True, the existing aliased class will be replaced. Defaults to False Returns: class: The actual default comm class that this class represents. """ if (getattr(cls, '_alias', None) is None) or overwrite: from yggdrasil.tools import get_default_comm cls._alias = import_component('comm', get_default_comm()) return cls._alias
def get_comm_class(comm=None): r"""Return a communication class given it's name. Args: comm (str, optional): Name of communicator class. Defaults to tools.get_default_comm() if not provided. Returns: class: Communicator class. """ if (comm is None) or (comm == 'DefaultComm'): comm = tools.get_default_comm() mod = importlib.import_module('yggdrasil.communication.%s' % comm) comm_cls = getattr(mod, comm) return comm_cls
def get_internal_suffix(cls, commtype=None): r"""Determine the suffix that should be used for internal libraries. Args: commtype (str, optional): If provided, this is the communication type that should be used for the model. If None, the default comm is used. Returns: str: Suffix that should be added to internal libraries to differentiate between different dependencies. """ out = super(FortranModelDriver, cls).get_internal_suffix(commtype=commtype) if commtype is None: commtype = tools.get_default_comm() out += '_%s' % commtype[:3].lower() return out
import unittest from yggdrasil import tools, platform from yggdrasil.tests import MagicTestError, assert_raises from yggdrasil.schema import get_schema from yggdrasil.components import import_component from yggdrasil.drivers.tests import test_Driver as parent from yggdrasil.drivers.ConnectionDriver import ConnectionDriver from yggdrasil.communication import ( new_comm, ZMQComm, IPCComm, RMQComm) _default_comm = tools.get_default_comm() _zmq_installed = ZMQComm.ZMQComm.is_installed(language='python') _ipc_installed = IPCComm.IPCComm.is_installed(language='python') _rmq_installed = RMQComm.RMQComm.is_installed(language='python') @unittest.skipIf(platform._is_win, ("Temp skip connection tests on windows for " "time's sake.")) class TestConnectionParam(parent.TestParam): r"""Test parameters for the ConnectionDriver class.""" comm_name = _default_comm icomm_name = _default_comm ocomm_name = _default_comm testing_option_kws = {} driver = 'ConnectionDriver' def __init__(self, *args, **kwargs): super(TestConnectionParam, self).__init__(*args, **kwargs) self.attr_list += ['icomm_kws', 'ocomm_kws', 'icomm', 'ocomm',
def ygginfo(): r"""Print information about yggdrasil installation.""" from yggdrasil import __version__, tools, config, platform from yggdrasil.components import import_component lang_list = tools.get_installed_lang() prefix = ' ' curr_prefix = '' vardict = [ ('Location', os.path.dirname(__file__)), ('Version', __version__), ('Languages', ', '.join(lang_list)), ('Communication Mechanisms', ', '.join(tools.get_installed_comm())), ('Default Comm Mechanism', tools.get_default_comm()), ('Config File', config.usr_config_file) ] parser = argparse.ArgumentParser( description= 'Display information about the current yggdrasil installation.') parser.add_argument( '--no-languages', action='store_true', dest='no_languages', help='Don\'t print information about individual languages.') parser.add_argument( '--verbose', action='store_true', help='Increase the verbosity of the printed information.') args = parser.parse_args() try: # Add language information if not args.no_languages: # Install languages vardict.append(('Installed Languages:', '')) curr_prefix += prefix for lang in sorted(lang_list): drv = import_component('model', lang) vardict.append((curr_prefix + '%s:' % lang.upper(), '')) curr_prefix += prefix if lang == 'executable': vardict.append((curr_prefix + 'Location', '')) else: exec_name = drv.language_executable() if not os.path.isabs(exec_name): exec_name = tools.which(exec_name) vardict.append((curr_prefix + 'Location', exec_name)) vardict.append( (curr_prefix + 'Version', drv.language_version())) curr_prefix = curr_prefix.rsplit(prefix, 1)[0] curr_prefix = curr_prefix.rsplit(prefix, 1)[0] # Not installed languages vardict.append(("Languages Not Installed:", '')) curr_prefix += prefix for lang in tools.get_supported_lang(): if lang in lang_list: continue drv = import_component('model', lang) vardict.append((curr_prefix + '%s:' % lang.upper(), '')) curr_prefix += prefix vardict.append((curr_prefix + "Language Installed", drv.is_language_installed())) vardict.append((curr_prefix + "Base Languages Installed", drv.are_base_languages_installed())) if not drv.are_base_languages_installed(): vardict.append( (curr_prefix + "Base Languages Not Installed", [ b for b in drv.base_languages if (not import_component('model', b).is_installed()) ])) vardict.append((curr_prefix + "Dependencies Installed", drv.are_dependencies_installed())) vardict.append((curr_prefix + "Interface Installed", drv.is_interface_installed())) vardict.append( (curr_prefix + "Comm Installed", drv.is_comm_installed())) vardict.append( (curr_prefix + "Configured", drv.is_configured())) vardict.append((curr_prefix + "Disabled", drv.is_disabled())) curr_prefix = curr_prefix.rsplit(prefix, 1)[0] curr_prefix = curr_prefix.rsplit(prefix, 1)[0] # Add verbose information if args.verbose: # Conda info if os.environ.get('CONDA_PREFIX', ''): out = tools.bytes2str( subprocess.check_output(['conda', 'info'])).strip() curr_prefix += prefix vardict.append((curr_prefix + 'Conda Info:', "\n%s%s" % (curr_prefix + prefix, ("\n" + curr_prefix + prefix).join( out.splitlines(False))))) curr_prefix = curr_prefix.rsplit(prefix, 1)[0] # R and reticulate info Rdrv = import_component("model", "R") if Rdrv.is_installed(): env_reticulate = copy.deepcopy(os.environ) env_reticulate['RETICULATE_PYTHON'] = sys.executable # Stack size out = Rdrv.run_executable(["-e", "Cstack_info()"]).strip() vardict.append((curr_prefix + "R Cstack_info:", "\n%s%s" % (curr_prefix + prefix, ("\n" + curr_prefix + prefix).join( out.splitlines(False))))) # Compilation tools interp = 'R'.join(Rdrv.get_interpreter().rsplit('Rscript', 1)) vardict.append((curr_prefix + "R C Compiler:", "")) curr_prefix += prefix for x in ['CC', 'CFLAGS', 'CXX', 'CXXFLAGS']: out = tools.bytes2str( subprocess.check_output([interp, 'CMD', 'config', x])).strip() vardict.append((curr_prefix + x, "%s" % ("\n" + curr_prefix + prefix).join( out.splitlines(False)))) curr_prefix = curr_prefix.rsplit(prefix, 1)[0] # Session info out = Rdrv.run_executable(["-e", "sessionInfo()"]).strip() vardict.append((curr_prefix + "R sessionInfo:", "\n%s%s" % (curr_prefix + prefix, ("\n" + curr_prefix + prefix).join( out.splitlines(False))))) # Reticulate conda_list if os.environ.get('CONDA_PREFIX', ''): out = Rdrv.run_executable([ "-e", ("library(reticulate); " "reticulate::conda_list()") ], env=env_reticulate).strip() vardict.append( (curr_prefix + "R reticulate::conda_list():", "\n%s%s" % (curr_prefix + prefix, ("\n" + curr_prefix + prefix).join( out.splitlines(False))))) # Windows python versions if platform._is_win: # pragma: windows out = Rdrv.run_executable([ "-e", ("library(reticulate); " "reticulate::py_versions_windows()") ], env=env_reticulate).strip() vardict.append( (curr_prefix + "R reticulate::py_versions_windows():", "\n%s%s" % (curr_prefix + prefix, ("\n" + curr_prefix + prefix).join( out.splitlines(False))))) # conda_binary if platform._is_win: # pragma: windows out = Rdrv.run_executable([ "-e", ("library(reticulate); " "conda <- reticulate:::conda_binary(\"auto\"); " "system(paste(conda, \"info --json\"))") ], env=env_reticulate).strip() vardict.append( (curr_prefix + "R reticulate::py_versions_windows():", "\n%s%s" % (curr_prefix + prefix, ("\n" + curr_prefix + prefix).join( out.splitlines(False))))) # Reticulate py_config out = Rdrv.run_executable([ "-e", ("library(reticulate); " "reticulate::py_config()") ], env=env_reticulate).strip() vardict.append((curr_prefix + "R reticulate::py_config():", "\n%s%s" % (curr_prefix + prefix, ("\n" + curr_prefix + prefix).join( out.splitlines(False))))) finally: # Print things max_len = max(len(x[0]) for x in vardict) lines = [] line_format = '%-' + str(max_len) + 's' + prefix + '%s' for k, v in vardict: lines.append(line_format % (k, v)) logger.info("yggdrasil info:\n%s" % '\n'.join(lines))
def cleanup_comm_classes(self): r"""list: Comm classes that should be cleaned up following the test.""" return [tools.get_default_comm()]
def get_flags(for_cmake=False, for_api=False, cpp=False): r"""Get the necessary flags for compiling & linking with Ygg libraries. Args: for_cmake (bool, optional): If True, the returned flags will match the format required by cmake. Defaults to False. for_api (bool, optional): If True, the returned flags will match those required for compiling the API static library. Defaults to False. cpp (bool, optional): If True, flags for compiling a C++ model are returned. Otherwise, flags for compiling a C model are returned. Defaults to False. Returns: tuple(list, list): compile and linker flags. """ if cpp: _compile_flags = os.environ.get('CXXFLAGS', '').split() else: _compile_flags = os.environ.get('CFLAGS', '').split() _linker_flags = os.environ.get('LDFLAGS', '').split() if not _c_installed: # pragma: windows logging.warning("No library installed for models written in C") return _compile_flags, _linker_flags if platform._is_win: # pragma: windows _compile_flags += ["/nologo", "-D_CRT_SECURE_NO_WARNINGS"] _compile_flags += ['-I' + _top_dir] _compile_flags += ['-I' + _incl_interface] if not for_cmake: _regex_win32 = os.path.split(_regex_win32_lib) _compile_flags += ['-I' + _regex_win32[0]] if tools.is_comm_installed('ZMQComm', language='c'): zmq_flags = get_zmq_flags(for_cmake=for_cmake, for_api=for_api) _compile_flags += zmq_flags[0] _linker_flags += zmq_flags[1] if tools.is_comm_installed('IPCComm', language='c'): ipc_flags = get_ipc_flags(for_cmake=for_cmake, for_api=for_api) _compile_flags += ipc_flags[0] _linker_flags += ipc_flags[1] # Include dir for x in [ _incl_interface, _incl_io, _incl_comm, _incl_seri, _incl_regex, _incl_dtype ]: _compile_flags += ["-I" + x] # Interface library if not for_api: if cpp: plib = _api_static_cpp else: plib = _api_static_c plib_d, plib_f = os.path.split(plib) if for_cmake: _linker_flags.append(plib) # _linker_flags += [_api_static_c, _api_static_cpp] elif platform._is_win: # pragma: windows _linker_flags += ['/LIBPATH:%s' % plib_d, plib_f] else: _linker_flags += ["-L" + plib_d] _linker_flags += [ "-l" + os.path.splitext(plib_f)[0].split(_prefix)[-1] ] if tools.get_default_comm() == 'IPCComm': _compile_flags += ["-DIPCDEF"] return _compile_flags, _linker_flags