schrodinger.ui.qt.widgetmixins.panelmixins module¶
- class schrodinger.ui.qt.widgetmixins.panelmixins.PanelMixin(*args, **kwargs)¶
Bases:
schrodinger.models.mappers.MapperMixin
PanelMixin makes a widget act as a panel - it supports a panel singleton, and expects to be shown as a window rather than an embedded widget.
Requires ExecutionMixin
- SHOW_AS_WINDOW = True¶
- PRESETS_FEATURE_FLAG = False¶
- classmethod getPanelInstance(create=True)¶
Return the singleton instance of this panel, creating one if necessary.
- Parameters
create (bool) – Whether to create an instance of the panel if none exists
- Returns
instance of this panel.
- Return type
- classmethod panel(blocking=False, modal=False, finished_callback=None)¶
Open an instance of this class.
For full argument documentation, see
ExecutionMixin.run
.
- initSetUp()¶
- initSetDefaults()¶
@overrides: widgetmixins.InitMixin
- show()¶
- class schrodinger.ui.qt.widgetmixins.panelmixins.CleanStateMixin¶
Bases:
object
Mixin for use with
PanelMixin
. Implements two methods for saving and reverting changes to the model. Automatically saves the state of the model when a panel is run. Subclasses are responsible for callingdiscardChanges
at the right time (e.g. when a user hits the cancel button)- run(*args, **kwargs)¶
- setModel(model)¶
- saveCleanState()¶
Copy the model as a clean state. Next time
discardChanges
is called, the model will be updated to reflect this current state.
- discardChanges()¶
Revert the model to the value it was the last time
saveCleanState
was called.
- class schrodinger.ui.qt.widgetmixins.panelmixins.TaskPanelMixin(*args, **kwargs)¶
Bases:
schrodinger.ui.qt.widgetmixins.panelmixins.PanelMixin
,schrodinger.ui.qt.widgetmixins.basicmixins.StatusBarMixin
A panel where the overall panel is associated with one or more panel tasks. One task is active at any time; this task will be sync’ed to the panel state and the bottom taskbar of the panel will be associated with the active task (i.e. job options will pertain to the active task, and clicking the run button will start that task).
A panel task is a task that is launched via the taskbar at the bottom of the panel and generally represents the main purpose of the panel. There may be multiple panel tasks for panels that have more than one mode, and there is always one “active” panel task. The UX for selecting the active task of the panel is determined by each panel, but typically is done with a combobox or set of radio buttons near the top of the panel.
There is a taskmanager for each panel task. The taskmanager handles naming of the tasks and creating a new instance of the panel task each time a panel task is started. The taskmanager also provides access to previously started tasks as well as signals for when any instance of that panel task changes status or finshes.
A panel task’s naming can be customized with
setStandardBasename
.The TaskPanelMixin provides a standard taskbar for each panel task; a custom taskbar can be set by overriding
_makeTaskBar
.Similarly, a standard config dialog is provided for any panel tasks that are jobtasks. The config dialog may be customized by overriding
_makeConfigDialog
TaskPanelMixin persists job settings (accessible through the “Job Settings” item in the gear menu) between sessions. The job settings are saved whenever the config dialog is closed and loaded in
initFinalize
. The settings are saved using the keyPREFERENCES_KEY
which defaults to the class name. Subclasses should overwritePREFERENCES_KEY
so the key is stable and unique in case the class name changes or another panel is created with the same name.DEPENDENCIES: widgetmixins.MessageBoxMixin
- Variables
taskWritten – A signal emitted when a task is successfully written. Emits the task instance that was written.
- PANEL_TASKS = ()¶
- taskWritten¶
pyqtSignal(*types, name: str = …, revision: int = …, arguments: Sequence = …) -> PYQT_SIGNAL
types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal’s arguments.
- ADD_RESET_THIS_TASK_OPTION = False¶
- initSetUp()¶
- initSetOptions()¶
- initSetDefaults()¶
@overrides: widgetmixins.InitMixin
- initFinalize()¶
- property PREFERENCES_KEY¶
- setModel(model)¶
Sets the model object for the mapper. Disconnects the old model, if one is set, and connects the new model. Pass in None to have no model set.
- Parameters
model – the model instance or None
- getSettingsMenuActions(abstract_task)¶
Return a tuple representation of the settings button menu for a given
abstract_task
. For custom menus, override this method and return a list of tuples mapping desired menu item texts mapped to the method or function that should be called when the item is selected. IfNone
is returned, then no actions are set on the settings button.The following menu items are used for the default implementation:
'Job Settings' -> Opens up a config dialog 'Preferences...' -> Opens the Maestro preferences dialog to the job preferences page. 'Write' -> Write the job to a bash file ----(The above items are only shown if the task is a jobtask)------- *'Write STU ZIP File' -> Write a zip file that can be used to create a stu test. 'Reset Entire Panel' -> Resets the entire panel 'Reset This Task' -> Reset just the current task (hidden by default, can be enabled by setting the `ADD_RESET_THIS_TASK_OPTION` class variable to True). *'Start debugger...' -> Start a command line debugger with IPython *'Start debugger GUI...' -> Open up the debugger gui
Menu items that are only shown if the user has SCHRODINGER_SRC defined in their environment.
- Parameters
abstract_task (tasks.AbstractTask) – The task to retrieve menu actions for. It will always be a member of
self.PANEL_TASKS
.- Returns
A list of tuples mapping the desired menu item text with the function that should be called when the item is selected. If the slot is
None
, then a separator will be added instead and the text will be ignored.- Return type
list[tuple(str, callable) or None] or None
- setStandardBaseName(base_name, panel_task=None)¶
Set the base name used for naming tasks.
- Parameters
base_name (str) – The new base name to use
index (tasks.AbstractTask) – The abstract panel task to set the standard basename for. Must be a member of
PANEL_TASKS
. If not provided, set the basename for the currently active task.
- defineTaskPreprocessors(model)¶
Return a list of tuples containing a task and an associated preprocesor.
To include preprocessors, override this method in a subclass. Example:
def defineTaskPreprocessors(self, model): return [ (model.search_task, self._validateSearchTerms), (model.email_task, self._compileAddresses) ]
- Parameters
model (parameters.CompoundParam) – a model instance
- Returns
a list of (task, method) tuples
- Return type
list[tuple[tasks.AbstractTask, Callable]]
- defineTaskPostprocessors(model)¶
Return a list of tuples containing a task and an associated postprocessor.
The signature of this method is identical to that of
defineTaskPreprocessors()
.- Parameters
model (parameters.CompoundParam) – a model instance
- Returns
a list of (task, method) tuples
- Return type
list[tuple[tasks.AbstractTask, Callable]]
- setActiveTask(new_active_task)¶
Set the currently active task. Expects a task from
PANEL_TASKS
.- Parameters
new_active_task – Abstract task
- activeTask()¶
Return the currently active task.
- Returns
The currently active task from
PANEL_TASKS
- getTask(panel_task=None)¶
Gets the task instance for a specified panel task. This is the task instance that will be run the next time the corresponding start button is clicked.
- Parameters
panel_task – The abstract task from
PANEL_TASKS
for which to get the next task instance. If None, will return the next task instance for the active task.
- getTaskBar(panel_task=None)¶
Gets the taskbar for a panel task.
- Parameters
panel_task – The abstract task from
PANEL_TASKS
for which to get the taskbar. If None, will return the taskbar for the active panel task.
- getTaskManager(panel_task=None)¶
Gets the taskmanager for a panel task.
- Parameters
panel_task – The abstract task from
PANEL_TASKS
for which to get the taskmanager. If None, will return the taskmanager for the active task.
- class schrodinger.ui.qt.widgetmixins.panelmixins.KnimeMixin(*args, _knime_args=None, **kwargs)¶
Bases:
object
A mixin for creating Knime versions of panels. This mixin will hide the taskbars and replace them with an “OK” and “Cancel” button.
All Knime panels _must_ implement panel presets. Generally, subclasses will also implement some behavior to hide widgets that are not relevant to a Knime node as well, though this is not strictly required.
If a Knime panel needs additional arguments, they can be specified through an override of
runKnime
, passing any additional arguments to the super method as a keyword arguent. AllrunKnime
arguments will be accessible in the instance variable_knime_args
dictionary.If additional initialization logic is needed, subclasses can override
initKnime
is the last method that’s run during initialization. By default, it will just load the presets file supplied torunKnime
.The “OK” button will attempt to write a task. If a preprocessor fails then an error will show similar to the normal panel. If the preprocessing succeeds, then a job will be written and the settings for the panel will be saved.
If the “Cancel” button is pressed, the panel will just be closed without writing a job or saving settings.
If loading panel settings manually has to be supported for backward compatibility with AF2 framework, subclasses should override
loadPanelStateFromNonPresetFile
to load non-preset manager generated settings files.The
runKnime
static method is the entry point to using Knime panels.- gui_closed¶
pyqtSignal(*types, name: str = …, revision: int = …, arguments: Sequence = …) -> PYQT_SIGNAL
types is normally a sequence of individual types. Each type is either a type object or a string that is the name of a C++ type. Alternatively each type could itself be a sequence of types each describing a different overloaded signal. name is the optional C++ name of the signal. If it is not specified then the name of the class attribute that is bound to the signal is used. revision is the optional revision of the signal that is exported to QML. If it is not specified then 0 is used. arguments is the optional sequence of the names of the signal’s arguments.
- __init__(*args, _knime_args=None, **kwargs)¶
- initSetOptions()¶
- initFinalize()¶
- initKnime()¶
- loadPanelStateFromNonPresetFile(settings_fname: str, jobname: str)¶
Override to load state from a non preset manager generated settings file.
- Parameters
settings_fname (str) – Settings file path.
jobname (str) – Job name.
- Raises
NotImplementedError – If function is not implemented in subclasses.
- closeEvent(event)¶
- classmethod runKnime(*, jobname: str, settings_fname: str, **kwargs)¶
Call this static method to instantiate this panel in KNIME mode.
- Parameters
jobname – The basename to save the written job to. The job file will be written as “<jobname>.sh”
settings_fname – The filename to use save the settings of the panel. If the settings already exist, then they are used to populate the panel.