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)
