def _write_process(process, pyf, name, enabled): if isinstance(process, NipypeProcess): mod = process._nipype_interface.__module__ classname = process._nipype_interface.__class__.__name__ else: mod = process.__module__ # if process is a function with XML decorator, we need to # retreive the original function name. func = getattr(process, '_function', None) if func: classname = func.__name__ else: classname = process.__class__.__name__ procname = '.'.join((mod, classname)) proc_copy = get_process_instance(procname) make_opt = [] for tname, trait in six.iteritems(proc_copy.user_traits()): ntrait = process.trait(tname) if ntrait.optional and not trait.optional: make_opt.append(tname) node_options = '' if len(make_opt) != 0: node_options += ', make_optional=%s' % repr(make_opt) print(' self.add_process("%s", "%s"%s)' % (name, procname, node_options), file=pyf) for pname in process.user_traits(): value = getattr(process, pname) init_value = getattr(proc_copy, pname) if value != init_value \ and not (value is Undefined and init_value == ''): repvalue = get_repr_value(value) print(' self.nodes["%s"].process.%s = %s' % (name, pname, repvalue), file=pyf)
def __init__(self, process, iterative_parameters, study_config=None, context_name=None): super(ProcessIteration, self).__init__() if self.study_config is None and hasattr(Process, '_study_config'): study_config = Process._study_config if study_config is not None: self.study_config = study_config self.process = get_process_instance(process, study_config=study_config) if context_name is not None: self.process.context_name = context_name self.regular_parameters = set() self.iterative_parameters = set(iterative_parameters) # Check that all iterative parameters are valid process parameters user_traits = self.process.user_traits() for parameter in self.iterative_parameters: if parameter not in user_traits: raise ValueError('Cannot iterate on parameter %s ' 'that is not a parameter of process %s' % (parameter, self.process.id)) # use the completion system (if any) to get induced (additional) # iterated parameters if study_config is not None: completion_engine \ = ProcessCompletionEngine.get_completion_engine(self) if hasattr(completion_engine, 'get_induced_iterative_parameters'): induced_iterative_parameters \ = completion_engine.get_induced_iterative_parameters() self.iterative_parameters.update(induced_iterative_parameters) iterative_parameters = self.iterative_parameters # Create iterative process parameters by copying process parameter # and changing iterative parameters to list for name, trait in six.iteritems(user_traits): if name in iterative_parameters: self.add_trait( name, List(trait, output=trait.output, optional=trait.optional)) if trait.groups: self.trait(name).groups = trait.groups else: self.regular_parameters.add(name) self.add_trait(name, trait) # copy initial value of the underlying process to self # Note: should be this be done via a links system ? setattr(self, name, getattr(self.process, name))
def _write_process(process, parent, name): procnode = ET.SubElement(parent, 'process') if isinstance(process, NipypeProcess): mod = process._nipype_interface.__module__ classname = process._nipype_interface.__class__.__name__ else: mod = process.__module__ # if process is a function with XML decorator, we need to # retreive the original function name. func = getattr(process, '_function', None) if func: classname = func.__name__ else: classname = process.__class__.__name__ procnode.set('module', "%s.%s" % (mod, classname)) procnode.set('name', name) proc_copy = get_process_instance("%s.%s" % (mod, classname)) if isinstance(process, NipypeProcess): # WARNING: not sure I'm doing the right things for nipype. To be # fixed if needed. for param in process.inputs_to_copy: elem = ET.SubElement(procnode, 'nipype') elem.set('name', param) if param in process.inputs_to_clean: elem.set('copyfile', 'discard') else: elem.set('copyfile', 'true') np_input = getattr(process._nipype_interface.inputs, param) if np_input: use_default = getattr(np_input, 'usedefault', False) # is it that? if use_default: elem.set('use_default', 'true') for param, np_input in \ six.iteritems(process._nipype_interface.inputs.__dict__): use_default = getattr(np_input, 'usedefault', False) # is it that? if use_default and param not in process.inputs_to_copy: elem = ET.SubElement(procnode, 'nipype') elem.set('name', param) elem.set('use_default', 'true') # set initial values for param_name, trait in six.iteritems(process.user_traits()): if param_name not in ('nodes_activation', 'selection_changed'): value = getattr(process, param_name) if value not in (None, Undefined, '', []) \ or (trait.optional and not proc_copy.trait(param_name).optional): value = repr(value) elem = ET.SubElement(procnode, 'set') elem.set('name', param_name) elem.set('value', value) return procnode
def __init__(self, process, iterative_parameters, study_config=None, context_name=None): super(ProcessIteration, self).__init__() if self.study_config is None and hasattr(Process, '_study_config'): study_config = Process._study_config if study_config is not None: self.study_config = study_config self.process = get_process_instance(process, study_config=study_config) if context_name is not None: self.process.context_name = context_name self.regular_parameters = set() self.iterative_parameters = set(iterative_parameters) # Check that all iterative parameters are valid process parameters user_traits = self.process.user_traits() for parameter in self.iterative_parameters: if parameter not in user_traits: raise ValueError('Cannot iterate on parameter %s ' 'that is not a parameter of process %s' % (parameter, self.process.id)) # use the completion system (if any) to get induced (additional) # iterated parameters if study_config is not None: completion_engine \ = ProcessCompletionEngine.get_completion_engine(self) if hasattr(completion_engine, 'get_induced_iterative_parameters'): induced_iterative_parameters \ = completion_engine.get_induced_iterative_parameters() self.iterative_parameters.update(induced_iterative_parameters) iterative_parameters = self.iterative_parameters # Create iterative process parameters by copying process parameter # and changing iterative parameters to list for name, trait in six.iteritems(user_traits): if name in iterative_parameters: self.add_trait(name, List(trait, output=trait.output, optional=trait.optional)) if trait.groups: self.trait(name).groups = trait.groups else: self.regular_parameters.add(name) self.add_trait(name, trait) # copy initial value of the underlying process to self # Note: should be this be done via a links system ? setattr(self, name, getattr(self.process, name))
def get_process_instance(self, process_or_id, **kwargs): """ Return a Process instance given an identifier. The identifier is either: * a derived Process class. * a derived Process class instance. * a Nipype Interface instance. * a Nipype Interface class. * a string description of the class `<module>.<class>`. * a string description of a function to warp `<module>.<function>`. * a string description of a pipeline `<module>.<fname>.xml`. * an XML filename for a pipeline Default values of the process instance are passed as additional parameters. .. note: If no process is found an ImportError is raised. .. note: If the 'process_or_id' parameter is not valid a ValueError is raised. .. note: If the function to warp does not contain a process description in its decorator or docstring ('<process>...</process>') a ValueError is raised. Parameters ---------- process_or_id: instance or class description (mandatory) a process/nipype interface instance/class or a string description. kwargs: default values of the process instance parameters. Returns ------- result: Process an initialized process instance. """ return get_process_instance(process_or_id, study_config=self, **kwargs)
def get_process_instance(self, process_or_id, **kwargs): """ Return a Process instance given an identifier. The identifier is either: * a derived Process class. * a derived Process class instance. * a Nipype Interface instance. * a Nipype Interface class. * a string description of the class `<module>.<class>`. * a string description of a function to warp `<module>.<function>`. * a string description of a pipeline `<module>.<fname>.xml`. * an XML filename for a pipeline Default values of the process instance are passed as additional parameters. .. note: If no process is found an ImportError is raised. .. note: If the 'process_or_id' parameter is not valid a ValueError is raised. .. note: If the function to warp does not contain a process description in its decorator or docstring ('<process>...</process>') a ValueError is raised. Parameters ---------- process_or_id: instance or class description (mandatory) a process/nipype interface instance/class or a string description. kwargs: default values of the process instance parameters. Returns ------- result: Process an initialized process instance. """ return get_process_instance(process_or_id, study_config=self, **kwargs)
def _write_process(process, parent, name, dont_write_plug_values=set(), init_plug_values={}): procnode = ET.SubElement(parent, 'process') if isinstance(process, NipypeProcess): mod = process._nipype_interface.__module__ classname = process._nipype_interface.__class__.__name__ else: mod = process.__module__ # if process is a function with XML decorator, we need to # retrieve the original function name. func = getattr(process, '_function', None) if func: classname = func.__name__ else: classname = process.__class__.__name__ if classname == 'Pipeline': # don't accept the base Pipeline class classname = name if '.' in class_name: classname = classname[:classname.index('.')] classname = classname[0].upper() + class_name[1:] procnode.set('module', "%s.%s" % (mod, classname)) procnode.set('name', name) proc_copy = get_process_instance("%s.%s" % (mod, classname)) if isinstance(process, NipypeProcess): # WARNING: not sure I'm doing the right things for nipype. To be # fixed if needed. for param in process.inputs_to_copy: elem = ET.SubElement(procnode, 'nipype') elem.set('name', param) if param in process.inputs_to_clean: elem.set('copyfile', 'discard') else: elem.set('copyfile', 'true') np_input = getattr(process._nipype_interface.inputs, param) if np_input: use_default = getattr(np_input, 'usedefault', False) # is it that? if use_default: elem.set('use_default', 'true') for param, np_input in \ six.iteritems(process._nipype_interface.inputs.__dict__): use_default = getattr(np_input, 'usedefault', False) # is it that? if use_default and param not in process.inputs_to_copy: elem = ET.SubElement(procnode, 'nipype') elem.set('name', param) elem.set('use_default', 'true') # set initial values dont_write_plug_values = set(dont_write_plug_values) dont_write_plug_values.update( ('nodes_activation', 'selection_changed')) for param_name, trait in six.iteritems(process.user_traits()): if param_name not in dont_write_plug_values: if param_name in init_plug_values: value = init_plug_values[param_name] else: value = getattr(process, param_name) if value not in (None, Undefined, '', []) \ or (trait.optional and not proc_copy.trait(param_name).optional): if isinstance(value, Controller): value_repr = repr(dict(value.export_to_dict())) else: value_repr = repr(value) try: eval(value_repr) except Exception: print( 'warning, value of parameter %s cannot be saved' % param_name) continue elem = ET.SubElement(procnode, 'set') elem.set('name', param_name) elem.set('value', value_repr) return procnode
def __init__(self, process, iterative_parameters, study_config=None, context_name=None): super(ProcessIteration, self).__init__() if self.study_config is None and hasattr(Process, '_study_config'): study_config = study_cmod.default_study_config() if study_config is not None: self.study_config = study_config self.process = get_process_instance(process, study_config=study_config) if context_name is not None: self.process.context_name = context_name self.regular_parameters = set() self.iterative_parameters = set(iterative_parameters) # use the completion system (if any) to get induced (additional) # iterated parameters if study_config is not None: # don't import this at module level to avoid cyclic imports from capsul.attributes.completion_engine \ import ProcessCompletionEngine completion_engine \ = ProcessCompletionEngine.get_completion_engine(self) if hasattr(completion_engine, 'get_induced_iterative_parameters'): induced_iterative_parameters \ = completion_engine.get_induced_iterative_parameters() self.iterative_parameters.update(induced_iterative_parameters) iterative_parameters = self.iterative_parameters # Check that all iterative parameters are valid process parameters user_traits = self.process.user_traits() has_output = False inputs = [] for parameter in self.iterative_parameters: if parameter not in user_traits: raise ValueError('Cannot iterate on parameter %s ' 'that is not a parameter of process %s' % (parameter, self.process.id)) if user_traits[parameter].output: has_output = True else: inputs.append(parameter) # Create iterative process parameters by copying process parameter # and changing iterative parameters to list for name, trait in six.iteritems(user_traits): if name in iterative_parameters: kw = {} if trait.input_filename is False: kw['input_filename'] = False self.add_trait(name, List(trait, output=trait.output, optional=trait.optional, **kw)) if trait.groups: self.trait(name).groups = trait.groups if trait.forbid_completion is not None: # we don't have access to the pipeline or even the # node in self, we cannot propagate the forbid_completion # value outside of self. # However this will be done in Pipeline.add_process() when # inserting self in a pipeline, so this is OK. trait(name).forbid_completion \ = trait.forbid_completion else: self.regular_parameters.add(name) self.add_trait(name, trait) # copy initial value of the underlying process to self # Note: should be this be done via a links system ? setattr(self, name, getattr(self.process, name)) # if the process has iterative outputs, the output lists have to be # resized according to inputs if has_output: self.on_trait_change(self._resize_outputs, inputs)