def init_window(self): """ Method to initialize the main window. """ # First set some meta information self.setApplicationName(self._application_name) self.setOrganizationName(self._organisation_name) self.setApplicationVersion(self._version) # Get the user interface description from capsul resources ui_file = os.path.join(os.path.dirname(__file__), "activation_inspector.ui") #ui_file = os.path.join(resources.__path__[0], "activation_inspector.ui") # Create and show the activation/pipeline/controller windows self.pipeline_window = PipelineDeveloperView(self.pipeline, show_sub_pipelines=True) self.controller_window = ScrollControllerWidget(self.pipeline, live=True) self.activation_window = ActivationInspector( self.pipeline, ui_file, self.record_file, developper_view=self.pipeline_window) self.pipeline_window.show() self.activation_window.show() self.controller_window.show() return True
class ActivationInspectorApp(Application): """ ActivationInspector Application. While developing a pipeline, nodes are connected through links. Nodes will be automatically activated or disabled depending on their connections (a mandatory link to a disabled node will disable the current one). You will often wonder why a node will not be activated. This tool helps to determine when and why by "playing" activation rules sequences step-by-step and displaying nodes which activate or deactivate at each step. """ # Load some meta information from capsul.info import __version__ as _version from capsul.info import NAME as _application_name from capsul.info import ORGANISATION as _organisation_name def __init__(self, pipeline_path, record_file=None, *args, **kwargs): """ Method to initialize the ActivationInspectorApp class. Parameters ---------- pipeline_path: str (mandatory) the name of the pipeline we want to load. record_file: str (optional) a file where the pipeline activation steps are stored. """ # Inhetritance super(ActivationInspectorApp, self).__init__(*args, **kwargs) # Load the pipeline self.pipeline = get_process_instance(pipeline_path) # Initialize the application self.record_file = record_file self.window = None self.init_window() def init_window(self): """ Method to initialize the main window. """ # First set some meta information self.setApplicationName(self._application_name) self.setOrganizationName(self._organisation_name) self.setApplicationVersion(self._version) # Get the user interface description from capsul resources ui_file = os.path.join(os.path.dirname(__file__), "activation_inspector.ui") #ui_file = os.path.join(resources.__path__[0], "activation_inspector.ui") # Create and show the activation/pipeline/controller windows self.pipeline_window = PipelineDeveloperView(self.pipeline, show_sub_pipelines=True) self.controller_window = ScrollControllerWidget(self.pipeline, live=True) self.activation_window = ActivationInspector( self.pipeline, ui_file, self.record_file, developper_view=self.pipeline_window) self.pipeline_window.show() self.activation_window.show() self.controller_window.show() return True
class ActivationInspectorApp(Application): """ ActiovationInspector Application. """ # Load some meta informations from capsul.info import __version__ as _version from capsul.info import NAME as _application_name from capsul.info import ORGANISATION as _organisation_name def __init__(self, pipeline_path, record_file=None, *args, **kwargs): """ Method to initialize the ActivationInspectorApp class. Parameters ---------- pipeline_path: str (mandatory) the name of the pipeline we want to load. record_file: str (optional) a file where the pipeline activation steps are stored. """ # Inhetritance super(ActivationInspectorApp, self).__init__(*args, **kwargs) # Load the pipeline self.pipeline = get_process_instance(pipeline_path) # Initialize the application self.record_file = record_file self.window = None self.init_window() def init_window(self): """ Method to initialize the main window. """ # First set some meta informations self.setApplicationName(self._application_name) self.setOrganizationName(self._organisation_name) self.setApplicationVersion(self._version) # Get the user interface description from capsul resources ui_file = os.path.join(os.path.dirname(__file__), "activation_inspector.ui") #ui_file = os.path.join(resources.__path__[0], "activation_inspector.ui") # Create and show the activation/pipeline/controller windows self.pipeline_window = PipelineDevelopperView(self.pipeline, show_sub_pipelines=True) self.controller_window = ScrollControllerWidget(self.pipeline, live=True) self.activation_window = ActivationInspector( self.pipeline, ui_file, self.record_file, developper_view=self.pipeline_window) self.pipeline_window.show() self.activation_window.show() self.controller_window.show() return True
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
class ActivationInspectorApp(Application): """ ActiovationInspector Application. """ # Load some meta informations from capsul.info import __version__ as _version from capsul.info import NAME as _application_name from capsul.info import ORGANISATION as _organisation_name def __init__(self, pipeline_path, record_file=None, *args, **kwargs): """ Method to initialize the ActivationInspectorApp class. Parameters ---------- pipeline_path: str (mandatory) the name of the pipeline we want to load. record_file: str (optional) a file where the pipeline activation steps are stored. """ # Inhetritance super(ActivationInspectorApp, self).__init__(*args, **kwargs) # Load the pipeline self.pipeline = get_process_instance(pipeline_path) # Initialize the application self.record_file = record_file self.window = None self.init_window() def init_window(self): """ Method to initialize the main window. """ # First set some meta informations self.setApplicationName(self._application_name) self.setOrganizationName(self._organisation_name) self.setApplicationVersion(self._version) # Get the user interface description from capsul resources ui_file = os.path.join( os.path.dirname(__file__), "activation_inspector.ui") #ui_file = os.path.join(resources.__path__[0], "activation_inspector.ui") # Create and show the activation/pipeline/controller windows self.pipeline_window = PipelineDevelopperView(self.pipeline) self.controller_window = ScrollControllerWidget(self.pipeline,live=True) self.activation_window = ActivationInspector( self.pipeline, ui_file, self.record_file, developper_view=self.pipeline_window) self.pipeline_window.show() self.activation_window.show() self.controller_window.show() return True
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 onQualityControlClicked(self): """ Event to show / hide the board dock widget. """ # Create and show board dock widget if self.ui.actionQualityControl.isChecked(): # Create the board widget associated to the pipeline controller # Create on the fly in order to get the last status # ToDo: add callbacks if self.pipeline is not None: # board_widget = BoardWidget( # self.pipeline, parent=self.ui.dockWidgetParameters, # name="board") board_widget = ScrollControllerWidget( self.pipeline, name="outputs", live=True, hide_labels=False, select_controls="outputs", disable_controller_widget=True) #board_widget.setEnabled(False) self.ui.dockWidgetBoard.setWidget(board_widget) # Show the board widget self.ui.dockWidgetBoard.show() # Hide board dock widget else: self.ui.dockWidgetBoard.hide()
def onLoadSubPipelineClicked(self, name, sub_pipeline, modifiers): """ Event to load and display a sub pipeline. """ # Store the pipeline instance in class parameters self.pipeline = self.pipeline.nodes[name].process # Create the controller widget associated to the sub pipeline # controller: if the sub pipeline is a ProcessIteration, disable # the correspondind controller widget since this pipeline is generated # on the fly an is not directly synchronized with the rest of the # pipeline. is_iterative_pipeline = False if isinstance(self.pipeline, ProcessIteration): is_iterative_pipeline = True pipeline_widget = ScrollControllerWidget( self.pipeline, live=True, select_controls="inputs", disable_controller_widget=is_iterative_pipeline) self.ui.dockWidgetParameters.setWidget(pipeline_widget) # Store the sub pipeline instance self.pipelines[self.pipeline.name] = (self.pipeline, pipeline_widget) # Create the widget widget = PipelineDevelopperView(self.pipeline) self._insert_widget_in_tab(widget) # Connect the subpipeline clicked signal to the # onLoadSubPipelineClicked slot widget.subpipeline_clicked.connect(self.onLoadSubPipelineClicked)
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 onLoadClicked(self): """ Event to load and display a pipeline. """ # Get the pipeline instance from its string description item = self.ui.menu_treectrl.currentItem() description_list = [ str(x) for x in [item.text(1), item.text(0)] if x != "" ] process_description = ".".join(description_list) self.pipeline = get_process_instance(process_description) # Create the controller widget associated to the pipeline # controller pipeline_widget = ScrollControllerWidget(self.pipeline, live=True, select_controls="inputs") self.ui.dockWidgetParameters.setWidget(pipeline_widget) # Add observer to refresh the run button controller_widget = pipeline_widget.controller_widget for control_name, control \ in six.iteritems(controller_widget._controls): # Unpack the control item trait, control_class, control_instance, control_label = control # Add the new callback control_class.add_callback(self.onRunStatus, control_instance) # Refresh manually the run button status the first time self.onRunStatus() # Store the pipeline documentation root path self.path_to_pipeline_doc[self.pipeline.id] = item.text(2) # Store the pipeline instance self.pipelines[self.pipeline.name] = (self.pipeline, pipeline_widget) # Create the widget widget = PipelineDevelopperView(self.pipeline) self._insert_widget_in_tab(widget) # Connect the subpipeline clicked signal to the # onLoadSubPipelineClicked slot widget.subpipeline_clicked.connect(self.onLoadSubPipelineClicked)
def init_window(self): """ Method to initialize the main window. """ # First set some meta informations self.setApplicationName(self._application_name) self.setOrganizationName(self._organisation_name) self.setApplicationVersion(self._version) # Get the user interface description from capsul resources ui_file = os.path.join( os.path.dirname(__file__), "activation_inspector.ui") #ui_file = os.path.join(resources.__path__[0], "activation_inspector.ui") # Create and show the activation/pipeline/controller windows self.pipeline_window = PipelineDevelopperView(self.pipeline) self.controller_window = ScrollControllerWidget(self.pipeline,live=True) self.activation_window = ActivationInspector( self.pipeline, ui_file, self.record_file, developper_view=self.pipeline_window) self.pipeline_window.show() self.activation_window.show() self.controller_window.show() return True
# Set the logging level logging.basicConfig(level=logging.INFO) # Create a qt applicaction app = QtGui.QApplication(sys.argv) # Create the controller we want to parametrized controller = TestControls() # Set some values to the controller parameters controller.s = "" controller.f = 10.2 # Create to controller widget that are synchronized on the fly widget1 = ScrollControllerWidget(controller, live=True) widget2 = ControllerWidget(controller, live=True) widget1.show() widget2.show() # Check if the controller widget is valid before edition print("Controller widget valid before edition: ", end=' ') print(widget1.controller_widget.is_valid()) # Start the qt loop app.exec_() # Check if the controller widget is valid after edition print("Controller widget valid after edition: ", end=' ') print(widget1.controller_widget.is_valid())
def __init__(self, attributed_process, enable_attr_from_filename=False, enable_load_buttons=False): """ Parameters ---------- attributed_process: Process instance process with attributes to be displayed enable_attr_from_filename: bool (optional) if enabled, it will be possible to specify an input filename to build attributes from """ super(AttributedProcessWidget, self).__init__() self.setLayout(QtGui.QVBoxLayout()) self.attributed_process = attributed_process self._show_completion = False process = attributed_process completion_engine = getattr(process, 'completion_engine', None) if completion_engine is not None: splitter = QtGui.QSplitter(QtCore.Qt.Vertical) self.layout().addWidget(splitter) spl_up = QtGui.QWidget() spl_up.setLayout(QtGui.QVBoxLayout()) splitter.addWidget(spl_up) spl_down = QtGui.QWidget() spl_down.setLayout(QtGui.QVBoxLayout()) splitter.addWidget(spl_down) else: spl_up = self spl_down = self if enable_attr_from_filename and completion_engine is not None: c = Controller() c.add_trait('attributes_from_input_filename', File(optional=True)) cw = ControllerWidget(c, live=True) spl_up.layout().addWidget(cw) self.input_filename_controller = c c.on_trait_change(self.on_input_filename_changed, 'attributes_from_input_filename', dispatch='ui') cw.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Fixed) # groupbox area to show attributs attrib_widget = QtGui.QGroupBox('Attributes:') attrib_widget.setAlignment(QtCore.Qt.AlignLeft) attrib_widget.setLayout(QtGui.QVBoxLayout()) self.attrib_widget = attrib_widget spl_up.layout().addWidget(attrib_widget) attrib_widget.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Preferred) hlay = QtGui.QHBoxLayout() spl_up.layout().addLayout(hlay) # CheckBox to completion rules or not self.checkbox_fom = QtGui.QCheckBox('Follow completion rules') self.checkbox_fom.setChecked(True) self.checkbox_fom.stateChanged.connect(self.on_use_fom_change) hlay.addWidget(self.checkbox_fom) # Button Show/Hide completion self.btn_show_completion = QtGui.QCheckBox('Show completion') self.btn_show_completion.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed) hlay.addWidget(self.btn_show_completion) self.btn_show_completion.stateChanged.connect(self.on_show_completion) # groupbox area to show completion param_widget = QtGui.QGroupBox('Parameters:') param_widget.setAlignment(QtCore.Qt.AlignLeft) spl_down.layout().addWidget(param_widget) param_widget.setLayout(QtGui.QVBoxLayout()) param_widget.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) # Create controller widget for process and object_attribute self.controller_widget = ScrollControllerWidget(process, live=True, parent=param_widget) if completion_engine is not None: self.controller_widget2 = ScrollControllerWidget( completion_engine.get_attribute_values(), live=True, parent=attrib_widget) completion_engine.get_attribute_values().on_trait_change( completion_engine.attributes_changed, 'anytrait') else: self.controller_widget2 = ScrollControllerWidget(Controller()) # Set controller of attributs and controller of process for each # corresponding area param_widget.layout().addWidget(self.controller_widget) attrib_widget.layout().addWidget(self.controller_widget2) if enable_load_buttons and completion_engine is not None: io_lay = QtGui.QHBoxLayout() self.layout().addLayout(io_lay) self.btn_load_json = QtGui.QPushButton('Load attributes') io_lay.addWidget(self.btn_load_json) self.btn_load_json.clicked.connect(self.on_btn_load_json) self.btn_save_json = QtGui.QPushButton('Save attributes') io_lay.addWidget(self.btn_save_json) self.btn_save_json.clicked.connect(self.on_btn_save_json) if completion_engine is None: attrib_widget.hide() self.checkbox_fom.hide() self.btn_show_completion.hide() self.show_completion(True) # hide file parts else: self.show_completion(False) # hide file parts if completion_engine is not None: completion_engine.on_trait_change( self._completion_progress_changed, 'completion_progress', dispatch='ui')
def edit_elements(controller_widget, control_instance, edit_button): """ Callback to view/edit a 'ListControlWidget'. Parameters ---------- control_instance: QFrame (mandatory) the list widget item edit_button: QToolButton the signal sender """ controller_widget = get_ref(controller_widget) widget = QtGui.QDialog(controller_widget) widget.setModal(True) layout = QtGui.QVBoxLayout() widget.setLayout(layout) #hlayout = QtGui.QHBoxLayout() #layout.addLayout(hlayout) temp_controller = Controller() trait = control_instance.trait temp_controller.add_trait(control_instance.trait_name, trait) if temp_controller.trait(control_instance.trait_name).groups \ is not None: temp_controller.trait(control_instance.trait_name).groups = None value = getattr(controller_widget.controller, control_instance.trait_name) try: setattr(temp_controller, control_instance.trait_name, value) except Exception: # invalid value - don't prevent using the GUI pass control_types = dict(controller_widget._defined_controls) control_types['List'] = ListControlWidget control_types['List_File'] = ListControlWidget temp_controller_widget = ScrollControllerWidget( temp_controller, live=True, override_control_types=control_types, user_data=control_instance.user_data) layout.addWidget(temp_controller_widget) hlayout2 = QtGui.QHBoxLayout() layout.addLayout(hlayout2) hlayout2.addStretch(1) ok = QtGui.QPushButton('OK') cancel = QtGui.QPushButton('Cancel') hlayout2.addWidget(ok) hlayout2.addWidget(cancel) ok.pressed.connect(widget.accept) cancel.pressed.connect(widget.reject) if widget.exec_(): ctrl = temp_controller_widget.controller_widget._controls.get( control_instance.trait_name)[None] ListControlWidget.validate_all_values( temp_controller_widget.controller_widget, ctrl[2]) new_trait_value = getattr(temp_controller, control_instance.trait_name) setattr(controller_widget.controller, control_instance.trait_name, new_trait_value) del temp_controller_widget
def __init__(self, pipeline_menu, ui_file, default_study_config=None): """ Method to initialize the Capsul main window class. Parameters ---------- pipeline_menu: hierachic dict each key is a sub module of the module. Leafs contain a list with the url to the documentation. ui_file: str (mandatory) a filename containing the user interface description default_study_config: ordered dict (madatory) some parameters for the study configuration """ # Inheritance: load user interface window MyQUiLoader.__init__(self, ui_file) # Class parameters self.pipeline_menu = pipeline_menu self.pipelines = {} self.pipeline = None self.path_to_pipeline_doc = {} # Define dynamic controls self.controls = { QtGui.QAction: [ "actionHelp", "actionQuit", "actionBrowse", "actionLoad", "actionChangeView", "actionParameters", "actionRun", "actionStudyConfig", "actionQualityControl" ], QtGui.QTabWidget: [ "display", ], QtGui.QDockWidget: [ "dockWidgetBrowse", "dockWidgetParameters", "dockWidgetStudyConfig", "dockWidgetBoard" ], QtGui.QWidget: [ "dock_browse", "dock_parameters", "dock_study_config", "dock_board" ], QtGui.QTreeWidget: [ "menu_treectrl", ], QtGui.QLineEdit: [ "search", ], } # Add ui class parameter with the dynamic controls and initialize # default values self.add_controls_to_ui() self.ui.display.setTabsClosable(True) # Create the study configuration self.study_config = StudyConfig(default_study_config) # Create the controller widget associated to the study # configuration controller self.study_config_widget = ScrollControllerWidget(self.study_config, live=True) self.ui.dockWidgetStudyConfig.setWidget(self.study_config_widget) # Create the pipeline menu fill_treectrl(self.ui.menu_treectrl, self.pipeline_menu) # Signal for window interface self.ui.actionHelp.triggered.connect(self.onHelpClicked) self.ui.actionChangeView.triggered.connect(self.onChangeViewClicked) # Signal for tab widget self.ui.display.currentChanged.connect(self.onCurrentTabChanged) self.ui.display.tabCloseRequested.connect(self.onCloseTabClicked) # Signal for dock widget self.ui.actionBrowse.triggered.connect(self.onBrowseClicked) self.ui.actionParameters.triggered.connect(self.onParametersClicked) self.ui.actionStudyConfig.triggered.connect(self.onStudyConfigClicked) self.ui.actionQualityControl.triggered.connect( self.onQualityControlClicked) # Initialize properly the visibility of each dock widget self.onBrowseClicked() self.onParametersClicked() self.onStudyConfigClicked() self.onQualityControlClicked() # Signal for the pipeline creation self.ui.search.textChanged.connect(self.onSearchClicked) self.ui.menu_treectrl.currentItemChanged.connect( self.onTreeSelectionChanged) self.ui.actionLoad.triggered.connect(self.onLoadClicked) # Signal for the execution self.ui.actionRun.triggered.connect(self.onRunClicked)
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 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 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