def edition_widget(engine, environment):
''' Edition GUI for FSL config - see
:class:`~capsul.qt_gui.widgets.settings_editor.SettingsEditor`
'''
from soma.qt_gui.controller_widget import ScrollControllerWidget
from soma.controller import Controller
import types
import traits.api as traits
def validate_config(widget):
controller = widget.controller_widget.controller
with widget.engine.settings as session:
conf = session.config('fsl', widget.environment)
values = {'config_id': 'fsl'}
for k in ('directory', 'config', 'prefix'):
value = getattr(controller, k)
if value is traits.Undefined:
value = None
values[k] = value
if conf is None:
session.new_config('fsl', widget.environment, values)
else:
for k, value in values.items():
if k == 'config_id':
continue
setattr(conf, k, values[k])
controller = Controller()
controller.add_trait(
'directory',
traits.Directory(traits.Undefined,
desc='Directory where FSL is installed'))
controller.add_trait(
'config',
traits.File(traits.Undefined,
output=False,
desc='Parameter to specify the fsl.sh path'))
controller.add_trait(
'prefix',
traits.String(traits.Undefined, desc='Prefix to add to FSL commands'))
conf = engine.settings.select_configurations(environment, {'fsl': 'any'})
if conf:
fconf = conf.get('capsul.engine.module.fsl', {})
controller.directory = fconf.get('directory', traits.Undefined)
controller.config = fconf.get('config', traits.Undefined)
controller.prefix = fconf.get('prefix', traits.Undefined)
widget = ScrollControllerWidget(controller, live=True)
widget.engine = engine
widget.environment = environment
widget.accept = types.MethodType(validate_config, widget)
return widget
def edition_widget(engine, environment):
''' Edition GUI for axon config - see
:class:`~capsul.qt_gui.widgets.settings_editor.SettingsEditor`
'''
from soma.qt_gui.controller_widget import ScrollControllerWidget
from soma.controller import Controller
import types
import traits.api as traits
def validate_config(widget):
controller = widget.controller_widget.controller
with widget.engine.settings as session:
conf = session.config('axon', widget.environment)
values = {'config_id': 'axon', 'user_level': controller.user_level}
if controller.shared_directory in (None, traits.Undefined, ''):
values['shared_directory'] = None
else:
values['shared_directory'] = controller.shared_directory
if conf is None:
session.new_config('axon', widget.environment, values)
else:
for k in ('shared_directory', 'user_level'):
setattr(conf, k, values[k])
controller = Controller()
controller.add_trait(
'shared_directory',
traits.Directory(desc='Directory where BrainVisa '
'shared data is installed'))
controller.add_trait(
'user_level',
traits.Int(desc='0: basic, 1: advanced, 2: expert, or more. '
'used to display or hide some advanced features or '
'process parameters that would be confusing to a novice '
'user'))
conf = engine.settings.select_configurations(environment, {'axon': 'any'})
if conf:
controller.shared_directory = conf.get('capsul.engine.module.axon',
{}).get('shared_directory',
traits.Undefined)
controller.user_level = conf.get('capsul.engine.module.axon',
{}).get('user_level', 0)
widget = ScrollControllerWidget(controller, live=True)
widget.engine = engine
widget.environment = environment
widget.accept = types.MethodType(validate_config, widget)
return widget
def edition_widget(engine, environment):
''' Edition GUI for python config - see
:class:`~capsul.qt_gui.widgets.settings_editor.SettingsEditor`
'''
from soma.qt_gui.qt_backend import Qt
from soma.qt_gui.controller_widget import ScrollControllerWidget
from soma.controller import Controller
import types
import traits.api as traits
def validate_config(widget):
controller = widget.controller_widget.controller
with widget.engine.settings as session:
conf = session.config('python', widget.environment)
values = {'config_id': 'python', 'path': controller.path}
if controller.executable in (None, traits.Undefined, ''):
values['executable'] = None
else:
values['executable'] = controller.executable
if conf is None:
session.new_config('python', widget.environment, values)
else:
for k in ('path', 'executable'):
setattr(conf, k, values[k])
controller = Controller()
controller.add_trait('executable',
traits.Str(desc='Full path of the python executable'))
controller.add_trait(
'path',
traits.List(traits.Directory(), [],
desc='paths to prepend to sys.path'))
conf = engine.settings.select_configurations(environment,
{'python': 'any'})
if conf:
controller.executable = conf.get('capsul.engine.module.python',
{}).get('executable',
traits.Undefined)
controller.path = conf.get('capsul.engine.module.python',
{}).get('path', [])
widget = ScrollControllerWidget(controller, live=True)
widget.engine = engine
widget.environment = environment
widget.accept = types.MethodType(validate_config, widget)
return widget
def edition_widget(engine, environment):
''' Edition GUI for AFNI config - see
:class:`~capsul.qt_gui.widgets.settings_editor.SettingsEditor`
'''
from soma.qt_gui.controller_widget import ScrollControllerWidget
from soma.controller import Controller
import types
import traits.api as traits
def validate_config(widget):
controller = widget.controller_widget.controller
with widget.engine.settings as session:
conf = session.config('afni', widget.environment)
values = {'config_id': 'afni'}
for k in ['directory']:
value = getattr(controller, k)
if value is traits.Undefined:
value = None
values[k] = value
if conf is None:
session.new_config('afni', widget.environment, values)
else:
for k, value in values.items():
if k == 'config_id':
continue
setattr(conf, k, values[k])
controller = Controller()
controller.add_trait(
'directory',
traits.Directory(traits.Undefined,
desc='Directory where AFNI is installed'))
conf = engine.settings.select_configurations(environment, {'afni': 'any'})
if conf:
fconf = conf.get('capsul.engine.module.afni', {})
controller.directory = fconf.get('directory', traits.Undefined)
widget = ScrollControllerWidget(controller, live=True)
widget.engine = engine
widget.environment = environment
widget.accept = types.MethodType(validate_config, widget)
return widget
def edition_widget(engine, environment):
''' Edition GUI for attributes config - see
:class:`~capsul.qt_gui.widgets.settings_editor.SettingsEditor`
'''
from soma.qt_gui.controller_widget import ScrollControllerWidget
from soma.controller import Controller
import types
import traits.api as traits
def validate_config(widget):
controller = widget.controller_widget.controller
with widget.engine.settings as session:
conf = session.config('attributes', widget.environment)
values = {'config_id': 'attributes'}
values['attributes_schema_paths'] \
= controller.attributes_schema_paths
values['attributes_schemas'] = controller.attributes_schemas
values['process_completion'] = controller.process_completion
if controller.process_completion is traits.Undefined:
values['process_completion'] = None
values['path_completion'] = controller.path_completion
if controller.path_completion is traits.Undefined:
values['path_completion'] = None
if conf is None:
session.new_config('attributes', widget.environment, values)
else:
for k in ('attributes_schema_paths', 'attributes_schemas',
'process_completion', 'path_completion'):
setattr(conf, k, values[k])
controller = Controller()
controller.add_trait(
'attributes_schema_paths',
traits.List(traits.Str(), desc='attributes shchemas modules names'))
controller.add_trait(
'attributes_schemas',
traits.DictStrStr(desc='attributes shchemas names'))
controller.add_trait(
'process_completion',
traits.Str(desc='process completion model name'))
controller.add_trait(
'path_completion',
traits.Str(desc='path completion model name',
optional=True))
conf = engine.settings.select_configurations(
environment, {'attributes': 'any'})
if conf:
aconf = conf.get(
'capsul.engine.module.attributes', {})
controller.attributes_schema_paths = aconf.get(
'attributes_schema_paths', [])
controller.attributes_schemas = aconf.get(
'attributes_schemas', {})
controller.process_completion = aconf.get(
'process_completion', 'builtin')
controller.path_completion = aconf.get(
'path_completion', traits.Undefined)
widget = ScrollControllerWidget(controller, live=True)
widget.engine = engine
widget.environment = environment
widget.accept = types.MethodType(validate_config, widget)
return widget
def edition_widget(engine, environment):
''' Edition GUI for FOM config - see
:class:`~capsul.qt_gui.widgets.settings_editor.SettingsEditor`
'''
from soma.qt_gui.controller_widget import ScrollControllerWidget
from soma.controller import Controller
import types
def validate_config(widget):
controller = widget.controller_widget.controller
with widget.engine.settings as session:
conf = session.config('fom', widget.environment)
values = {'config_id': 'fom'}
for k in ('input_fom', 'output_fom', 'shared_fom',
'volumes_format', 'meshes_format', 'auto_fom',
'fom_path', 'input_directory', 'output_directory'):
value = getattr(controller, k)
if value is traits.Undefined:
if k in ('fom_path', ):
value = []
else:
value = None
values[k] = value
if conf is None:
session.new_config('fom', widget.environment, values)
else:
for k, value in values.items():
if k == 'config_id':
continue
setattr(conf, k, values[k])
controller = Controller()
controller.add_trait(
'input_fom',
traits.Str(traits.Undefined, output=False, desc='input FOM'))
controller.add_trait(
'output_fom',
traits.Str(traits.Undefined, output=False, desc='output FOM'))
controller.add_trait(
'shared_fom',
traits.Str(traits.Undefined, output=False, desc='shared data FOM'))
controller.add_trait(
'volumes_format',
traits.Str(traits.Undefined,
output=False,
desc='Format used for volumes'))
controller.add_trait(
'meshes_format',
traits.Str(traits.Undefined,
output=False,
desc='Format used for meshes'))
controller.add_trait(
'auto_fom',
traits.Bool(
True,
output=False,
desc='Look in all FOMs when a process is not found (in '
'addition to the standard share/foms). Note that auto_fom '
'looks for the first FOM matching the process to get '
'completion for, and does not handle ambiguities. Moreover '
'it brings an overhead (typically 6-7 seconds) the first '
'time it is used since it has to parse all available FOMs.'))
controller.add_trait(
'fom_path',
traits.List(
traits.Directory(output=False),
desc='list of additional directories where to look for FOMs'))
# FIXME: until directories are included in another config module
controller.add_trait(
'input_directory',
traits.Directory(traits.Undefined,
output=False,
desc='input study data directory'))
controller.add_trait(
'output_directory',
traits.Directory(traits.Undefined,
output=False,
desc='output study data directory'))
conf = engine.settings.select_configurations(environment, {'fom': 'any'})
if conf:
fconf = conf.get('capsul.engine.module.fom', {})
controller.input_fom = fconf.get('input_fom', traits.Undefined)
controller.output_fom = fconf.get('output_fom', traits.Undefined)
controller.shared_fom = fconf.get('shared_fom', traits.Undefined)
controller.volumes_format = fconf.get('volumes_format',
traits.Undefined)
controller.meshes_format = fconf.get('meshes_format', traits.Undefined)
controller.auto_fom = fconf.get('auto_fom', traits.Undefined)
controller.fom_path = fconf.get('fom_path', traits.Undefined)
controller.input_directory = fconf.get('input_directory',
traits.Undefined)
controller.output_directory = fconf.get('output_directory',
traits.Undefined)
widget = ScrollControllerWidget(controller, live=True)
widget.engine = engine
widget.environment = environment
widget.accept = types.MethodType(validate_config, widget)
return widget
def edition_widget(engine, environment):
''' Edition GUI for SPM config - see
:class:`~capsul.qt_gui.widgets.settings_editor.SettingsEditor`
'''
from soma.qt_gui.controller_widget import ScrollControllerWidget
from soma.controller import Controller
import types
import traits.api as traits
def validate_config(widget):
controller = widget.controller_widget.controller
with widget.engine.settings as session:
values = {}
if controller.directory in (None, traits.Undefined, ''):
values['directory'] = None
else:
values['directory'] = controller.directory
values['standalone'] = controller.standalone
values['version'] = controller.version
id = 'spm%s%s' % (controller.version,
'-standalone' if controller.standalone else '')
values['config_id'] = id
query = 'config_id == "%s"' % id
conf = session.config('spm', 'global', selection=query)
if conf is None:
session.new_config('spm', widget.environment, values)
else:
for k in ('directory', 'standalone', 'version'):
setattr(conf, k, values[k])
controller = Controller()
controller.add_trait(
"directory",
traits.Directory(traits.Undefined,
output=False,
desc="Directory containing SPM."))
controller.add_trait(
"standalone",
traits.Bool(True, desc="If True, use the standalone version of SPM."))
controller.add_trait(
'version',
traits.Str(traits.Undefined,
output=False,
desc='Version string for SPM: "12", "8", etc.'))
conf = engine.settings.select_configurations(environment, {'spm': 'any'})
if conf:
controller.directory = conf.get('capsul.engine.module.spm',
{}).get('directory', traits.Undefined)
controller.standalone = conf.get('capsul.engine.module.spm',
{}).get('standalone', True)
controller.version = conf.get('capsul.engine.module.spm',
{}).get('version', '12')
# TODO handle several configs
widget = ScrollControllerWidget(controller, live=True)
widget.engine = engine
widget.environment = environment
widget.accept = types.MethodType(validate_config, widget)
return widget
