def comm_count(self): r"""int: The number of comms.""" out = 0 for k in self.cleanup_comm_classes: cls = get_comm_class(k) out += cls.comm_count() return out
def _init_single_comm(self, name, io, comm_kws, **kwargs): r"""Parse keyword arguments for input/output comm.""" self.debug("Creating %s comm", io) s = get_schema() if comm_kws is None: comm_kws = dict() if io == 'input': direction = 'recv' comm_type = self._icomm_type touches_model = self._is_output attr_comm = 'icomm' comm_kws['close_on_eof_recv'] = False else: direction = 'send' comm_type = self._ocomm_type touches_model = self._is_input attr_comm = 'ocomm' comm_kws['direction'] = direction comm_kws['dont_open'] = True comm_kws['reverse_names'] = True comm_kws.setdefault('comm', {'comm': comm_type}) assert (name == self.name) comm_kws.setdefault('name', name) if not isinstance(comm_kws['comm'], list): comm_kws['comm'] = [comm_kws['comm']] for i, x in enumerate(comm_kws['comm']): if x is None: comm_kws['comm'][i] = dict() elif not isinstance(x, dict): comm_kws['comm'][i] = dict(comm=x) comm_kws['comm'][i].setdefault('comm', comm_type) any_files = False all_files = True if not touches_model: comm_kws['no_suffix'] = True ikws = [] for x in comm_kws['comm']: if get_comm_class(x['comm']).is_file: any_files = True ikws += s['file'].get_subtype_properties(x['comm']) else: all_files = False ikws += s['comm'].get_subtype_properties(x['comm']) ikws = list(set(ikws)) for k in ikws: if (k not in comm_kws) and (k in kwargs): comm_kws[k] = kwargs.pop(k) if ('comm_env' in kwargs) and ('comm_env' not in comm_kws): comm_kws['env'] = kwargs.pop('comm_env') if any_files and (io == 'input'): kwargs.setdefault('timeout_send_1st', 60) self.debug('%s comm_kws:\n%s', attr_comm, self.pprint(comm_kws, 1)) setattr(self, attr_comm, new_comm(comm_kws.pop('name'), **comm_kws)) setattr(self, '%s_kws' % attr_comm, comm_kws) if touches_model: self.env.update(getattr(self, attr_comm).opp_comms) elif not all_files: self.comm_env.update(getattr(self, attr_comm).opp_comms) return kwargs
def is_installed(cls, language=None): r"""Determine if the necessary libraries are installed for this communication class. Args: language (str, optional): Specific language that should be checked for compatibility. Defaults to None and all languages supported on the current platform will be checked. Returns: bool: Is the comm installed. """ return get_comm_class().is_installed(language=language)
def new_comm_kwargs(cls, name, request_comm=None, **kwargs): r"""Initialize communication with new comms. Args: name (str): Name for new comm. request_comm (str, optional): Name of class for new output comm. Defaults to None. """ args = [name] ocomm_class = get_comm_class(request_comm) kwargs['direction'] = 'send' if 'address' not in kwargs: oargs, kwargs = ocomm_class.new_comm_kwargs(name, **kwargs) kwargs['request_comm'] = request_comm return args, kwargs
def is_comm_installed(comm, language=None): r"""Check to see if yggdrasil can use a communication mechanism on the current machine. Args: comm (str): Communication mechanism to check. language (str, optional): Specific programming language that communication mechanism should be check for. Defaults to None and all supported languages will be checked. Returns: bool: True if the communication mechanism can be used on the current machine, False otherwise. """ from yggdrasil import communication cmm = communication.get_comm_class(comm) return cmm.is_installed(language=language)
def ErrorComm(name, base_comm='CommBase', **kwargs): # pragma: debug r"""Wrapper to return errored version of a comm class. Args: name (str): The environment variable where communication address is stored. base_comm (str, optional): Name of the base comm that should be used. Defaults to 'CommBase'. **kwargs: Additional keyword arguments are passed to the class constructor. Returns: ErrorClass: Instance of a comm class that will raise an error at the requested locaiton. """ base_class = get_comm_class(base_comm) out = ErrorClass(base_class, name, **kwargs) if base_comm is None: base_comm = str(base_class).split("'")[1].split(".")[-1] out._comm_class = base_comm return out
def new_comm_kwargs(cls, name, *args, **kwargs): r"""Get keyword arguments for new comm.""" if 'address' not in kwargs: addresses = [] comm = kwargs.get('comm', None) ncomm = kwargs.pop('ncomm', 0) if comm is None: comm = [None for i in range(ncomm)] assert (isinstance(comm, list)) ncomm = len(comm) for i in range(ncomm): x = comm[i] if x is None: x = {} iname = x.pop('name', get_comm_name(name, i)) icls = get_comm_class(x.get('comm', None)) _, ickw = icls.new_comm_kwargs(iname, **x) ickw['name'] = iname comm[i] = ickw addresses.append(ickw['address']) kwargs['comm'] = comm kwargs['address'] = addresses args = tuple([name] + list(args)) return args, kwargs
def ocomm_import_cls(self): r"""class: Class used for connection output comm.""" return get_comm_class(self.ocomm_name)
def comm_count(cls): r"""int: Number of communication connections.""" return get_comm_class().comm_count()
def underlying_comm_class(self): r"""str: Name of underlying communication class.""" return get_comm_class().underlying_comm_class()