def __init__(self, parent, xml):
super().__init__(parent)
self.setWindowTitle("Information")
tree = QTreeWidget()
tree.setColumnCount(2)
tree.setHeaderLabels(["Name", "Value"])
tree.setColumnWidth(0, 200)
tree.setColumnWidth(1, 350)
for stream in xml:
header = xml[stream][2]
header.tag = "Header"
footer = xml[stream][6]
footer.tag = "Footer"
root = et.Element(f"Stream {stream}")
root.extend([header, footer])
populate_tree(tree, root)
tree.expandAll()
vbox = QVBoxLayout(self)
vbox.addWidget(tree)
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok)
vbox.addWidget(buttonbox)
buttonbox.accepted.connect(self.accept)
self.resize(650, 550)
def __init__(self, parent):
super(ProjectWidget, self).__init__("Projects manager", parent)
main_tree_widget = QTreeWidget(self)
# main_layout = QVBoxLayout()
# main_tree_widget.setLayout(main_layout)
self.setObjectName("projects_dock")
self.setAllowedAreas(Qt.AllDockWidgetAreas)
main_tree_widget.setHeaderLabels(["Untitled project"])
# main_tree_widget.setHeaderLabels(["ProjectName"])
# item = QTreeWidgetItem()
for i in range(3):
parent = QTreeWidgetItem(main_tree_widget)
parent.setText(0, "Parent {}".format(i))
parent.setFlags(parent.flags() | Qt.ItemIsTristate | Qt.ItemIsUserCheckable)
for x in range(5):
child = QTreeWidgetItem(parent)
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setText(0, "Child {}".format(x))
child.setCheckState(0, Qt.Unchecked)
main_tree_widget.currentItemChanged.connect(self.changed_item)
self.setWidget(main_tree_widget)
self.setVisible(False)
print(self.objectName())
def __init__(self, parent, model):
super(AlgorithmMonitorDialog, self).__init__(parent)
self.tree = QTreeWidget(self)
self.tree.setColumnCount(3)
self.tree.setSelectionMode(QTreeWidget.NoSelection)
self.tree.setColumnWidth(0, 220)
self.tree.setHeaderLabels(['Algorithm', 'Progress', ''])
header = self.tree.header()
header.setSectionResizeMode(1, QHeaderView.Stretch)
header.setSectionResizeMode(2, QHeaderView.Fixed)
header.setStretchLastSection(False)
button_layout = QHBoxLayout()
self.close_button = QPushButton('Close')
button_layout.addStretch()
button_layout.addWidget(self.close_button)
layout = QVBoxLayout()
layout.addWidget(self.tree)
layout.addLayout(button_layout)
self.setLayout(layout)
self.setWindowTitle('Mantid - Algorithm progress')
self.setWindowIcon(QIcon(":/MantidPlot_Icon_32offset.png"))
self.resize(500, 300)
self.presenter = AlgorithmProgressDialogPresenter(self, model)
self.presenter.update_gui()
def __init__(self, parent):
if PYQT5:
super().__init__(parent, class_parent=parent)
else:
QTreeWidget.__init__(self, parent)
SpyderWidgetMixin.__init__(self, class_parent=parent)
self.__expanded_state = None
# Widget setup
self.setItemsExpandable(True)
self.setColumnCount(1)
# Setup context menu
self.collapse_all_action = None
self.collapse_selection_action = None
self.expand_all_action = None
self.expand_selection_action = None
self.setup()
self.common_actions = self.setup_common_actions()
# Signals
self.itemActivated.connect(self.activated)
self.itemClicked.connect(self.clicked)
self.itemSelectionChanged.connect(self.item_selection_changed)
self.item_selection_changed()
def connection_changed(self, connected):
build = (self._node is None) and (self._connected != connected
and connected is True)
super(SystemLog, self).connection_changed(connected)
if not build:
return
self._node = nodeFromAddress(self.channel)
self._path = self.channel.replace('SystemLog', 'ClearLog')
vb = QVBoxLayout()
self.setLayout(vb)
gb = QGroupBox('System Log (20 most recent entries)')
vb.addWidget(gb)
vb = QVBoxLayout()
gb.setLayout(vb)
self._systemLog = QTreeWidget()
vb.addWidget(self._systemLog)
self._systemLog.setColumnCount(2)
self._systemLog.setHeaderLabels(['Field', 'Value'])
self._systemLog.setColumnWidth(0, 200)
self._pb = PyDMPushButton(label='Clear Log',
pressValue=1,
init_channel=self._path)
vb.addWidget(self._pb)
def __init__(self, parent):
if PYQT5:
super().__init__(parent, class_parent=parent)
else:
QTreeWidget.__init__(self, parent)
SpyderWidgetMixin.__init__(self, class_parent=parent)
self.__expanded_state = None
# Widget setup
self.setItemsExpandable(True)
self.setColumnCount(1)
# Setup context menu
self.collapse_all_action = None
self.collapse_selection_action = None
self.expand_all_action = None
self.expand_selection_action = None
self.setup()
self.common_actions = self.setup_common_actions()
# Signals
self.itemActivated.connect(self.activated)
self.itemClicked.connect(self.clicked)
self.itemSelectionChanged.connect(self.item_selection_changed)
# To use mouseMoveEvent
self.setMouseTracking(True)
# Use horizontal scrollbar when needed
self.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
self.header().setSectionResizeMode(0, QHeaderView.ResizeToContents)
self.header().setStretchLastSection(False)
self.item_selection_changed()
def __init__(self, parent=None):
if PYQT5:
super().__init__(parent, class_parent=parent)
else:
QTreeWidget.__init__(self, parent)
SpyderWidgetMixin.__init__(self, class_parent=parent)
self.header_list = [
_('Function/Module'),
_('Total Time'),
_('Diff'),
_('Local Time'),
_('Diff'),
_('Calls'),
_('Diff'),
_('File:line')
]
self.icon_list = {
'module': self.create_icon('python'),
'function': self.create_icon('function'),
'builtin': self.create_icon('python'),
'constructor': self.create_icon('class')
}
self.profdata = None # To be filled by self.load_data()
self.stats = None # To be filled by self.load_data()
self.item_depth = None
self.item_list = None
self.items_to_be_shown = None
self.current_view_depth = None
self.compare_file = None
self.setColumnCount(len(self.header_list))
self.setHeaderLabels(self.header_list)
self.initialize_view()
self.itemActivated.connect(self.item_activated)
self.itemExpanded.connect(self.item_expanded)
def setup_page(self):
self.treeWidget = QTreeWidget(self)
self.treeWidget.setHeaderHidden(True)
self.treeWidget.itemChanged.connect(self.check_changed)
self.layout.addWidget(self.treeWidget)
action = self.create_action()
self.layout.addWidget(action)
def _make_tree_widget(self):
"""
Make a tree widget for displaying algorithms in their categories.
:return: A QTreeWidget
"""
tree = QTreeWidget(self)
tree.setColumnCount(1)
tree.setHeaderHidden(True)
tree.itemSelectionChanged.connect(self._on_tree_selection_changed)
return tree
def __init__(self, parent=None):
QTreeWidget.__init__(self, parent)
self.header_list = [
_('Line #'), _('Memory usage'), _('Increment'), _('Line contents')]
self.stats = None # To be filled by self.load_data()
self.max_time = 0 # To be filled by self.load_data()
self.header().setDefaultAlignment(Qt.AlignCenter)
self.setColumnCount(len(self.header_list))
self.setHeaderLabels(self.header_list)
self.clear()
self.itemActivated.connect(self.item_activated)
def __init__(self, parent):
QTreeWidget.__init__(self, parent)
self.setItemsExpandable(True)
self.setColumnCount(1)
self.data = {}
self.itemActivated.connect(self.activated)
self.itemClicked.connect(self.clicked)
self.itemSelectionChanged.connect(self.item_selection_changed)
self.item_selection_changed()
self.itemSelectionChanged.connect(self.item_selection_changed)
self.item_selection_changed()
def __init__(self):
QTreeWidget.__init__(self)
self.setColumnCount(2)
self.setHeaderLabels(("Title", "Keyword"))
#self.setGeometry(0, 0, 800, 300)
self.setColumnWidth(0, 400)
self.setWindowTitle('Tree - ZhuNote')
#self.show()
self.currentItemChanged.connect(self.send2view)
self.lod = []
self.font = QFont()
def __init__(self, parent=None):
QTreeWidget.__init__(self, parent)
self.header_list = [
_('Line #'), _('Memory usage'), _('Increment'), _('Line contents')]
self.stats = None # To be filled by self.load_data()
self.max_time = 0 # To be filled by self.load_data()
self.header().setDefaultAlignment(Qt.AlignCenter)
self.setColumnCount(len(self.header_list))
self.setHeaderLabels(self.header_list)
self.clear()
self.itemActivated.connect(self.item_activated)
def __init__(self, parent=None):
QTreeWidget.__init__(self, parent)
self.header_list = [
_('Status'), _('Name'), _('Message'), _('Time (ms)')]
self.data = None # To be filled by self.load_data()
self.max_time = 0 # To be filled by self.load_data()
self.header().setDefaultAlignment(Qt.AlignCenter)
self.setColumnCount(len(self.header_list))
self.setHeaderLabels(self.header_list)
self.clear()
self.setItemsExpandable(True)
self.setSortingEnabled(False)
def __init__(self, parent=None):
"""Convenience tree widget to store and view unit testing data."""
QTreeWidget.__init__(self, parent)
self.header_list = [
_('Status'), _('Name'),
_('Message'), _('Time (ms)')
]
self.testresults = []
self.header().setDefaultAlignment(Qt.AlignCenter)
self.setColumnCount(len(self.header_list))
self.setHeaderLabels(self.header_list)
self.clear()
self.setItemsExpandable(True)
self.setSortingEnabled(False)
class Editor(QDialog):
"""Basic scene editor."""
def __init__(self, parent: MainWindow, renderers: List[Renderer]) -> None:
"""Initialize the Editor."""
super().__init__(parent=parent)
self.renderers = renderers
self.tree_widget = QTreeWidget()
self.tree_widget.setHeaderHidden(True)
self.stacked_widget = QStackedWidget()
self.layout = QHBoxLayout()
self.layout.addWidget(self.tree_widget)
self.layout.addWidget(self.stacked_widget)
def _selection_callback() -> None:
for item in self.tree_widget.selectedItems():
widget_idx = item.data(0, Qt.ItemDataRole.UserRole)
self.stacked_widget.setCurrentIndex(widget_idx)
self.tree_widget.itemSelectionChanged.connect(_selection_callback)
self.setLayout(self.layout)
self.setWindowTitle("Editor")
self.setModal(True)
self.update()
def update(self) -> None:
"""Update the internal widget list."""
self.tree_widget.clear()
for idx, renderer in enumerate(self.renderers):
actors = renderer._actors # pylint: disable=protected-access
widget_idx = self.stacked_widget.addWidget(
_get_renderer_widget(renderer))
top_item = QTreeWidgetItem(self.tree_widget,
["Renderer {}".format(idx)])
top_item.setData(0, Qt.ItemDataRole.UserRole, widget_idx)
self.tree_widget.addTopLevelItem(top_item)
for name, actor in actors.items():
if actor is not None:
widget_idx = self.stacked_widget.addWidget(
_get_actor_widget(actor))
child_item = QTreeWidgetItem(top_item, [name])
child_item.setData(0, Qt.ItemDataRole.UserRole, widget_idx)
top_item.addChild(child_item)
self.tree_widget.expandAll()
def toggle(self) -> None:
"""Toggle the editor visibility."""
self.update()
if self.isVisible():
self.hide()
else:
self.show()
def __init__(self, parent, model):
super(AlgorithmMonitorDialog, self).__init__(parent)
self.tree = QTreeWidget(self)
self.tree.setColumnCount(3)
self.tree.setSelectionMode(QTreeWidget.NoSelection)
self.tree.setColumnWidth(0, 220)
self.tree.setHeaderLabels(['Algorithm', 'Progress', ''])
header = self.tree.header()
header.setSectionResizeMode(1, QHeaderView.Stretch)
header.setSectionResizeMode(2, QHeaderView.Fixed)
header.setStretchLastSection(False)
button_layout = QHBoxLayout()
self.close_button = QPushButton('Close')
button_layout.addStretch()
button_layout.addWidget(self.close_button)
layout = QVBoxLayout()
layout.addWidget(self.tree)
layout.addLayout(button_layout)
self.setLayout(layout)
self.setWindowTitle('Mantid - Algorithm progress')
self.setWindowIcon(QIcon(":/MantidPlot_Icon_32offset.png"))
self.resize(500, 300)
self.presenter = AlgorithmProgressDialogPresenter(self, model)
self.presenter.update_gui()
def __init__(self, parent):
QTreeWidget.__init__(self, parent)
self.setItemsExpandable(True)
self.setColumnCount(1)
self.itemActivated.connect(self.activated)
self.itemClicked.connect(self.clicked)
# Setup context menu
self.menu = QMenu(self)
self.collapse_all_action = None
self.collapse_selection_action = None
self.expand_all_action = None
self.expand_selection_action = None
self.common_actions = self.setup_common_actions()
self.__expanded_state = None
self.itemSelectionChanged.connect(self.item_selection_changed)
self.item_selection_changed()
def __init__(self, plugin):
plugin.layout_vertical = QVBoxLayout()
plugin.layout_vertical.setContentsMargins(11, 11, 11, 11)
plugin.layout_vertical.setSpacing(6)
plugin.group_box = QGroupBox()
plugin.contents.setLayout(plugin.layout_vertical)
plugin.layout_vertical.setContentsMargins(11, 11, 11, 11)
plugin.group_box_layout = QVBoxLayout(plugin.group_box)
plugin.group_box_layout.setContentsMargins(10, 0, 0, 0)
plugin.group_box_layout.setSpacing(0)
plugin.checkbox_horizontal_layout = QHBoxLayout()
plugin.checkbox_horizontal_layout.setContentsMargins(10, 0, 0, 0)
plugin.checkbox_horizontal_layout.setSpacing(0)
plugin.checkbox_show_mask = QCheckBox("Show Masked Data")
plugin.checkbox_show_mask.setChecked(False)
plugin.checkbox_horizontal_layout.addWidget(plugin.checkbox_show_mask)
plugin.group_box_layout.addLayout(plugin.checkbox_horizontal_layout)
plugin.layout_horizontal_mask_button = QHBoxLayout()
plugin.layout_horizontal_mask_button.setContentsMargins(0, 0, 0, 0)
plugin.layout_horizontal_mask_button.setSpacing(6)
plugin.button_mask_data = QPushButton()
plugin.button_mask_data.setText("Mask Data")
plugin.button_mask_data.setToolTip("Mask data in current ROI")
plugin.button_mask_data.setEnabled(False)
plugin.button_unmask_data = QPushButton()
plugin.button_unmask_data.setText("Unmask Data")
plugin.button_unmask_data.setToolTip(
"Remove mask from data in current ROI")
plugin.button_unmask_data.setEnabled(False)
plugin.layout_horizontal_mask_button.addWidget(plugin.button_mask_data)
plugin.layout_horizontal_mask_button.addWidget(
plugin.button_unmask_data)
plugin.group_box_layout.addLayout(plugin.layout_horizontal_mask_button)
# plugin.layout_vertical.setContentsMargins(11, 11, 11, 11)
# plugin.setMaximumHeight(120)
plugin.group_box_dq = QGroupBox("Data Quality Flags")
plugin.group_box_dq_layout = QVBoxLayout(plugin.group_box_dq)
plugin.group_box_dq_layout.setContentsMargins(10, 10, 10, 10)
plugin.tree_widget_dq = QTreeWidget()
plugin.tree_widget_dq.setColumnCount(3)
plugin.tree_widget_dq.headerItem().setText(0, "Bit")
plugin.tree_widget_dq.headerItem().setText(1, "Name")
plugin.tree_widget_dq.headerItem().setText(2, "Description")
plugin.group_box_dq_layout.addWidget(plugin.tree_widget_dq)
plugin.layout_vertical.addWidget(plugin.group_box)
plugin.layout_vertical.addWidget(plugin.group_box_dq)
def connection_changed(self, connected):
build = (self._node is None) and (self._connected != connected
and connected is True)
super(DebugTree, self).connection_changed(connected)
if not build:
return
self._node = nodeFromAddress(self.channel)
self._path = self.channel
vb = QVBoxLayout()
self.setLayout(vb)
self._tree = QTreeWidget()
vb.addWidget(self._tree)
self._tree.setColumnCount(5)
self._tree.setHeaderLabels(
['Node', 'Mode', 'Type', 'Variable', 'Command', 'Units'])
self._tree.itemExpanded.connect(self._expandCb)
hb = QHBoxLayout()
vb.addLayout(hb)
if self._node.isinstance(pyrogue.Root):
hb.addWidget(
PyDMPushButton(label='Read All',
pressValue=True,
init_channel=self._path + '.ReadAll'))
else:
hb.addWidget(
PyDMPushButton(label='Read Recursive',
pressValue=True,
init_channel=self._path + '.ReadDevice'))
self.setUpdatesEnabled(False)
DebugDev(path=self._path,
top=self,
parent=self._tree,
dev=self._node,
noExpand=False)
self.setUpdatesEnabled(True)
def __init__(self, appdata: CnaData):
QWidget.__init__(self)
self.appdata = appdata
self.last_selected = None
self.metabolite_list = QTreeWidget()
self.metabolite_list.setHeaderLabels(["Id", "Name"])
self.metabolite_list.setSortingEnabled(True)
for m in self.appdata.project.cobra_py_model.metabolites:
self.add_metabolite(m)
self.metabolite_list.setContextMenuPolicy(Qt.CustomContextMenu)
self.metabolite_list.customContextMenuRequested.connect(
self.on_context_menu)
# create context menu
self.pop_menu = QMenu(self.metabolite_list)
in_out_fluxes_action = QAction(
'compute in/out fluxes for this metabolite', self.metabolite_list)
self.pop_menu.addAction(in_out_fluxes_action)
in_out_fluxes_action.triggered.connect(self.emit_in_out_fluxes_action)
self.metabolite_mask = MetabolitesMask(appdata)
self.metabolite_mask.hide()
self.layout = QVBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.splitter = QSplitter()
self.splitter.setOrientation(Qt.Vertical)
self.splitter.addWidget(self.metabolite_list)
self.splitter.addWidget(self.metabolite_mask)
self.layout.addWidget(self.splitter)
self.setLayout(self.layout)
self.metabolite_list.currentItemChanged.connect(
self.metabolite_selected)
self.metabolite_mask.metaboliteChanged.connect(
self.handle_changed_metabolite)
self.metabolite_mask.jumpToReaction.connect(
self.emit_jump_to_reaction)
def __init__(self, parent=None):
QTreeWidget.__init__(self, parent)
self.header_list = [_('Function/Module'), _('Total Time'), _('Diff'),
_('Local Time'), _('Diff'), _('Calls'), _('Diff'),
_('File:line')]
self.icon_list = {'module': ima.icon('python'),
'function': ima.icon('function'),
'builtin': ima.icon('python_t'),
'constructor': ima.icon('class')}
self.profdata = None # To be filled by self.load_data()
self.stats = None # To be filled by self.load_data()
self.item_depth = None
self.item_list = None
self.items_to_be_shown = None
self.current_view_depth = None
self.compare_file = None
self.setColumnCount(len(self.header_list))
self.setHeaderLabels(self.header_list)
self.initialize_view()
self.itemActivated.connect(self.item_activated)
self.itemExpanded.connect(self.item_expanded)
def __init__(self, parent: MainWindow, renderers: List[Renderer]) -> None:
"""Initialize the Editor."""
super().__init__(parent=parent)
self.renderers = renderers
self.tree_widget = QTreeWidget()
self.tree_widget.setHeaderHidden(True)
self.stacked_widget = QStackedWidget()
self.layout = QHBoxLayout()
self.layout.addWidget(self.tree_widget)
self.layout.addWidget(self.stacked_widget)
def _selection_callback() -> None:
for item in self.tree_widget.selectedItems():
widget_idx = item.data(0, Qt.ItemDataRole.UserRole)
self.stacked_widget.setCurrentIndex(widget_idx)
self.tree_widget.itemSelectionChanged.connect(_selection_callback)
self.setLayout(self.layout)
self.setWindowTitle("Editor")
self.setModal(True)
self.update()
def _make_tree_widget(self):
"""
Make a tree widget for displaying algorithms in their categories.
:return: A QTreeWidget
"""
tree = QTreeWidget(self)
tree.setColumnCount(1)
tree.setHeaderHidden(True)
tree.itemSelectionChanged.connect(self._on_tree_selection_changed)
return tree
def __init__(self, *args, **kwargs):
self.active_filename = ""
self._main_view = QMainWindow()
self._main_view.setCentralWidget(QWidget())
self._main_view.centralWidget().hide()
self._editors = QStackedWidget()
self.workflow_process_selector = QComboBox()
self.workflow_process_selector.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self.workflow_process_selector.addItem("TomoPy Workflow")
self._workflow = None
self._tomo_workflow = TomographyWorkflow() # Create a workflow
self._workflow = self._tomo_workflow
self._workflow_editor = WorkflowEditor(workflow=self._workflow)
self._workflow_editor.sigRunWorkflow.connect(self.run_workflow)
self._active_workflow_executor = QTreeWidget()
self._editors.addWidget(self._workflow_editor)
if hasLTT:
self._alt_workflow = LTTWorkflow()
self.workflow_process_selector.addItem("LTT Workflow")
self._alt_workflow_editor = WorkflowEditor(self._alt_workflow)
self._alt_workflow_editor.sigRunWorkflow.connect(self.run_workflow)
self._editors.addWidget(self._alt_workflow_editor)
self.workflow_process_selector.setCurrentIndex(0)
self.workflow_process_selector.currentIndexChanged.connect(self.active_workflow_changed)
self._active_workflow_widget = QWidget()
self._active_layout = QVBoxLayout()
self._active_layout.addWidget(self.workflow_process_selector)
self._active_layout.addWidget(self._editors)
self._active_layout.addWidget(self._active_workflow_executor)
self._active_workflow_widget.setLayout(self._active_layout)
# self.hdf5_viewer = HDFTreeViewer()
# self.hdf5_viewer.load("/Users/hari/20200521_160002_heartbeat_test.h5")
self.top_controls = QWidget()
self.top_controls_layout = QHBoxLayout()
self.top_controls.setLayout(self.top_controls_layout)
self.top_controls_add_new_selector = QComboBox()
self.top_controls_frequency_selector = QSpinBox()
self.top_controls_frequency_selector.setValue(0)
self.top_controls_add_new_viewer = QPushButton()
self.top_controls_add_new_viewer.setText("Add Viewer")
self.top_controls_add_new_viewer.clicked.connect(self.add_new_viewer_selected)
self.top_controls_preview = QPushButton()
self.top_controls_preview.setText("Preview")
self.top_controls_preview.clicked.connect(self.preview_workflows)
self.top_controls_execute = QPushButton()
self.top_controls_execute.setText("Execute All")
self.top_controls_execute.clicked.connect(self.execute_workflows)
self.top_controls_add_new_selector.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.top_controls_add_new_viewer.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.top_controls_execute.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.top_controls_frequency_selector.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.top_controls_layout.addWidget(self.top_controls_add_new_selector)
self.top_controls_layout.addWidget(self.top_controls_add_new_viewer)
self.top_controls_layout.addWidget(self.top_controls_frequency_selector)
self.top_controls_layout.addWidget(self.top_controls_preview)
self.top_controls_layout.addWidget(self.top_controls_execute)
self.top_controls.setLayout(self.top_controls_layout)
self.status_bar = QLabel("None Loaded...")
# Create a layout to organize our widgets
# The first argument (which corresponds to the center widget) is required.
catalog_viewer_layout = GUILayout(self._main_view,
top=self.top_controls,
right=self._active_workflow_widget,
bottom=self.status_bar)
# Create a "View" stage that has the catalog viewer layout
self.stages = {"View": catalog_viewer_layout}
self.active_workflows = []
# For classes derived from GUIPlugin, this super __init__ must occur at end
super(TomographyPlugin, self).__init__(*args, **kwargs)
class AlgorithmMonitorDialog(QDialog):
"""
Displays progress of all running algorithms.
"""
def __init__(self, parent, model):
super(AlgorithmMonitorDialog, self).__init__(parent)
self.tree = QTreeWidget(self)
self.tree.setColumnCount(3)
self.tree.setSelectionMode(QTreeWidget.NoSelection)
self.tree.setColumnWidth(0, 220)
self.tree.setHeaderLabels(['Algorithm', 'Progress', ''])
header = self.tree.header()
header.setSectionResizeMode(1, QHeaderView.Stretch)
header.setSectionResizeMode(2, QHeaderView.Fixed)
header.setStretchLastSection(False)
button_layout = QHBoxLayout()
self.close_button = QPushButton('Close')
button_layout.addStretch()
button_layout.addWidget(self.close_button)
layout = QVBoxLayout()
layout.addWidget(self.tree)
layout.addLayout(button_layout)
self.setLayout(layout)
self.setWindowTitle('Mantid - Algorithm progress')
self.setWindowIcon(QIcon(":/MantidPlot_Icon_32offset.png"))
self.resize(500, 300)
self.presenter = AlgorithmProgressDialogPresenter(self, model)
self.presenter.update_gui()
def update(self, data):
"""
Update the gui elements.
:param data: Data in format of AlgorithmProgressModel.get_running_algorithm_data()
"""
self.tree.clear()
for alg_data in data:
name, id, properties = alg_data
item = QTreeWidgetItem([name])
self.tree.addTopLevelItem(item)
progress_bar = QProgressBar()
progress_bar.setAlignment(Qt.AlignHCenter)
self.presenter.add_progress_bar(id, progress_bar)
cancel_button = CancelButton(self.presenter, id)
self.tree.setItemWidget(item, 1, progress_bar)
self.tree.setItemWidget(item, 2, cancel_button)
for prop in properties:
item.addChild(QTreeWidgetItem(prop))
def __init__(self, parent: ReactionList):
QWidget.__init__(self)
self.parent = parent
self.reaction = None
self.is_valid = True
self.changed = False
self.setAcceptDrops(False)
layout = QVBoxLayout()
l = QHBoxLayout()
self.delete_button = QPushButton("Delete reaction")
self.delete_button.setIcon(QIcon.fromTheme("edit-delete"))
policy = QSizePolicy()
policy.ShrinkFlag = True
self.delete_button.setSizePolicy(policy)
l.addWidget(self.delete_button)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Id:")
self.id = QLineEdit()
l.addWidget(label)
l.addWidget(self.id)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Name:")
self.name = QLineEdit()
l.addWidget(label)
l.addWidget(self.name)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Equation:")
self.equation = QLineEdit()
l.addWidget(label)
l.addWidget(self.equation)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Rate min:")
self.lower_bound = QLineEdit()
l.addWidget(label)
l.addWidget(self.lower_bound)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Rate max:")
self.upper_bound = QLineEdit()
l.addWidget(label)
l.addWidget(self.upper_bound)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Coefficient in obj. function:")
self.coefficent = QLineEdit()
l.addWidget(label)
l.addWidget(self.coefficent)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Gene reaction rule:")
self.gene_reaction_rule = QLineEdit()
l.addWidget(label)
l.addWidget(self.gene_reaction_rule)
layout.addItem(l)
l = QVBoxLayout()
label = QLabel("Annotations:")
l.addWidget(label)
l2 = QHBoxLayout()
self.annotation = QTableWidget(0, 2)
self.annotation.setHorizontalHeaderLabels(
["key", "value"])
self.annotation.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
l2.addWidget(self.annotation)
self.add_anno = QPushButton("+")
self.add_anno.clicked.connect(self.add_anno_row)
l2.addWidget(self.add_anno)
l.addItem(l2)
layout.addItem(l)
l = QVBoxLayout()
label = QLabel("Metabolites involved in this reaction:")
l.addWidget(label)
l2 = QHBoxLayout()
self.metabolites = QTreeWidget()
self.metabolites.setHeaderLabels(["Id"])
self.metabolites.setSortingEnabled(True)
l2.addWidget(self.metabolites)
l.addItem(l2)
self.metabolites.itemDoubleClicked.connect(
self.emit_jump_to_metabolite)
layout.addItem(l)
self.jump_list = JumpList(self)
layout.addWidget(self.jump_list)
self.setLayout(layout)
self.delete_button.clicked.connect(self.delete_reaction)
self.throttler = SignalThrottler(500)
self.throttler.triggered.connect(self.reaction_data_changed)
self.id.textEdited.connect(self.throttler.throttle)
self.name.textEdited.connect(self.throttler.throttle)
self.equation.textEdited.connect(self.throttler.throttle)
self.lower_bound.textEdited.connect(self.throttler.throttle)
self.upper_bound.textEdited.connect(self.throttler.throttle)
self.coefficent.textEdited.connect(self.throttler.throttle)
self.gene_reaction_rule.textEdited.connect(self.throttler.throttle)
self.annotation.itemChanged.connect(self.throttler.throttle)
self.validate_mask()
class SystemLog(PyDMFrame):
def __init__(self, parent=None, init_channel=None):
PyDMFrame.__init__(self, parent, init_channel)
self._systemLog = None
self._node = None
def connection_changed(self, connected):
build = (self._node is None) and (self._connected != connected
and connected is True)
super(SystemLog, self).connection_changed(connected)
if not build:
return
self._node = nodeFromAddress(self.channel)
self._path = self.channel.replace('SystemLog', 'ClearLog')
vb = QVBoxLayout()
self.setLayout(vb)
gb = QGroupBox('System Log (20 most recent entries)')
vb.addWidget(gb)
vb = QVBoxLayout()
gb.setLayout(vb)
self._systemLog = QTreeWidget()
vb.addWidget(self._systemLog)
self._systemLog.setColumnCount(2)
self._systemLog.setHeaderLabels(['Field', 'Value'])
self._systemLog.setColumnWidth(0, 200)
self._pb = PyDMPushButton(label='Clear Log',
pressValue=1,
init_channel=self._path)
vb.addWidget(self._pb)
def value_changed(self, new_val):
lst = json.loads(new_val)
self._systemLog.clear()
# Show only the last 20 entries
# In the future we can consider a pop up dialog with the full log.
# Unclear if that is neccessary.
for ent in lst[-20:]:
widget = QTreeWidgetItem(self._systemLog)
widget.setText(
0,
time.strftime("%Y-%m-%d %H:%M:%S %Z",
time.localtime(ent['created'])))
widget.setText(1, ent['message'])
widget.setExpanded(False)
widget.setTextAlignment(0, Qt.AlignTop)
temp = QTreeWidgetItem(widget)
temp.setText(0, 'Name')
temp.setText(1, str(ent['name']))
temp.setTextAlignment(0, Qt.AlignRight)
temp = QTreeWidgetItem(widget)
temp.setText(0, 'Level')
temp.setText(
1, '{} ({})'.format(ent['levelName'], ent['levelNumber']))
temp.setTextAlignment(0, Qt.AlignRight)
if ent['exception'] is not None:
exc = QTreeWidgetItem(widget)
exc.setText(0, 'exception')
exc.setText(1, str(ent['exception']))
exc.setExpanded(False)
exc.setTextAlignment(0, Qt.AlignRight)
for v in ent['traceBack']:
temp = QTreeWidgetItem(exc)
temp.setText(0, '')
temp.setText(1, v)
def __init__(self, import_dict, local_dict, viewer, parent=None):
"""
:type import_dict: dict[str, object]
:type local_dict: dict[str, object]
:param import_dict:
:param local_dict:
:param viewer:
"""
super().__init__(parent=parent)
self.setWindowTitle("Import")
self.viewer = viewer()
self.local_viewer = viewer()
self.import_dict = import_dict
self.local_dict = local_dict
conflicts = set(local_dict.keys()) & set(import_dict.keys())
# print(conflicts)
self.list_view = QTreeWidget()
self.list_view.setColumnCount(4)
self.radio_group_list = []
self.checked_num = len(import_dict)
def rename_func(ob_name, new_name_field, rename_radio):
end_reg = re.compile(r"(.*) \((\d+)\)$")
def in_func():
if not rename_radio.isChecked() or str(new_name_field.text()).strip() != "":
return
match = end_reg.match(ob_name)
if match:
new_name_format = match.group(1) + " ({})"
i = int(match.group(2)) + 1
else:
new_name_format = ob_name + " ({})"
i = 1
while new_name_format.format(i) in self.local_dict:
i += 1
new_name_field.setText(new_name_format.format(i))
return in_func
def block_import(radio_btn, name_field):
def inner_func():
text = str(name_field.text()).strip()
if text == "" and radio_btn.isChecked():
self.import_btn.setDisabled(True)
else:
self.import_btn.setEnabled(True)
return inner_func
for name in sorted(import_dict.keys()):
item = QTreeWidgetItem()
item.setText(0, name)
# noinspection PyTypeChecker
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(0, Qt.Checked)
self.list_view.addTopLevelItem(item)
if name in conflicts:
group = QButtonGroup()
overwrite = QRadioButton("Overwrite")
overwrite.setChecked(True)
rename = QRadioButton("Rename")
new_name = QLineEdit()
new_name.textChanged.connect(block_import(rename, new_name))
rename.toggled.connect(block_import(rename, new_name))
overwrite.toggled.connect(block_import(rename, new_name))
rename.toggled.connect(rename_func(name, new_name, rename))
group.addButton(overwrite)
group.addButton(rename)
self.radio_group_list.append(group)
self.list_view.setItemWidget(item, 1, overwrite)
self.list_view.setItemWidget(item, 2, rename)
self.list_view.setItemWidget(item, 3, new_name)
self.import_btn = QPushButton("Import")
self.cancel_btn = QPushButton("Cancel")
self.check_btn = QPushButton("Check all")
self.uncheck_btn = QPushButton("Uncheck all")
self.cancel_btn.clicked.connect(self.close)
self.import_btn.clicked.connect(self.accept)
self.check_btn.clicked.connect(self.check_all)
self.uncheck_btn.clicked.connect(self.uncheck_all)
self.list_view.itemSelectionChanged.connect(self.preview)
self.list_view.itemChanged.connect(self.checked_change)
layout = QVBoxLayout()
info_layout = QHBoxLayout()
info_layout.addWidget(self.list_view, 2)
v1_lay = QVBoxLayout()
v1_lay.addWidget(QLabel("Import:"))
v1_lay.addWidget(self.viewer)
info_layout.addLayout(v1_lay, 1)
# info_layout.addWidget(self.local_viewer, 1)
v2_lay = QVBoxLayout()
v2_lay.addWidget(QLabel("Local:"))
v2_lay.addWidget(self.local_viewer)
info_layout.addLayout(v2_lay, 1)
layout.addLayout(info_layout)
btn_layout = QHBoxLayout()
btn_layout.addWidget(self.check_btn)
btn_layout.addWidget(self.uncheck_btn)
btn_layout.addStretch()
btn_layout.addWidget(self.import_btn)
btn_layout.addWidget(self.cancel_btn)
layout.addLayout(btn_layout)
self.setLayout(layout)
def generate_context_menu(self, pos: QPoint):
"""
Generate a context menu for contextMenuEvent
Parameters
----------
pos : QPoint
The point where the context menu was requested
"""
model_menu = QMenu()
skip_text = "skip me"
# Add filterbox to the context menu
txt_box = QLineEdit(model_menu)
txt_box.setPlaceholderText("Filter")
txt_box.setClearButtonEnabled(True)
txt_box_action = QWidgetAction(model_menu)
txt_box_action.setDefaultWidget(txt_box)
model_menu.addAction(txt_box_action)
# Add result treeview to the context menu
tree_view = QTreeWidget(model_menu)
tree_view.header().close()
tree_view_action = QWidgetAction(model_menu)
tree_view_action.setDefaultWidget(tree_view)
model_menu.addAction(tree_view_action)
top_level_items = {}
for cat in self._scene.registry.categories():
item = QTreeWidgetItem(tree_view)
item.setText(0, cat)
item.setData(0, Qt.UserRole, skip_text)
top_level_items[cat] = item
registry = self._scene.registry
for model, category in registry.registered_models_category_association(
).items():
self.parent = top_level_items[category]
item = QTreeWidgetItem(self.parent)
item.setText(0, model)
item.setData(0, Qt.UserRole, model)
tree_view.expandAll()
def click_handler(item):
model_name = item.data(0, Qt.UserRole)
if model_name == skip_text:
return
type_ = self._scene.registry.create(model_name)
if type_:
node = self._scene.create_node(type_)
pos_view = self.mapToScene(pos)
node.graphics_object.setPos(pos_view)
self._scene.node_placed.emit(node)
else:
logger.debug("Model not found")
model_menu.close()
tree_view.itemClicked.connect(click_handler)
# Setup filtering
def filter_handler(text):
for name, top_lvl_item in top_level_items.items():
for i in range(top_lvl_item.childCount()):
child = top_lvl_item.child(i)
model_name = child.data(0, Qt.UserRole)
child.setHidden(text not in model_name)
txt_box.textChanged.connect(filter_handler)
# make sure the text box gets focus so the user doesn't have to click on it
txt_box.setFocus()
return model_menu
class ReactionMask(QWidget):
"""The input mask for a reaction"""
def __init__(self, parent: ReactionList):
QWidget.__init__(self)
self.parent = parent
self.reaction = None
self.is_valid = True
self.changed = False
self.setAcceptDrops(False)
layout = QVBoxLayout()
l = QHBoxLayout()
self.delete_button = QPushButton("Delete reaction")
self.delete_button.setIcon(QIcon.fromTheme("edit-delete"))
policy = QSizePolicy()
policy.ShrinkFlag = True
self.delete_button.setSizePolicy(policy)
l.addWidget(self.delete_button)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Id:")
self.id = QLineEdit()
l.addWidget(label)
l.addWidget(self.id)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Name:")
self.name = QLineEdit()
l.addWidget(label)
l.addWidget(self.name)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Equation:")
self.equation = QLineEdit()
l.addWidget(label)
l.addWidget(self.equation)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Rate min:")
self.lower_bound = QLineEdit()
l.addWidget(label)
l.addWidget(self.lower_bound)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Rate max:")
self.upper_bound = QLineEdit()
l.addWidget(label)
l.addWidget(self.upper_bound)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Coefficient in obj. function:")
self.coefficent = QLineEdit()
l.addWidget(label)
l.addWidget(self.coefficent)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Gene reaction rule:")
self.gene_reaction_rule = QLineEdit()
l.addWidget(label)
l.addWidget(self.gene_reaction_rule)
layout.addItem(l)
l = QVBoxLayout()
label = QLabel("Annotations:")
l.addWidget(label)
l2 = QHBoxLayout()
self.annotation = QTableWidget(0, 2)
self.annotation.setHorizontalHeaderLabels(
["key", "value"])
self.annotation.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
l2.addWidget(self.annotation)
self.add_anno = QPushButton("+")
self.add_anno.clicked.connect(self.add_anno_row)
l2.addWidget(self.add_anno)
l.addItem(l2)
layout.addItem(l)
l = QVBoxLayout()
label = QLabel("Metabolites involved in this reaction:")
l.addWidget(label)
l2 = QHBoxLayout()
self.metabolites = QTreeWidget()
self.metabolites.setHeaderLabels(["Id"])
self.metabolites.setSortingEnabled(True)
l2.addWidget(self.metabolites)
l.addItem(l2)
self.metabolites.itemDoubleClicked.connect(
self.emit_jump_to_metabolite)
layout.addItem(l)
self.jump_list = JumpList(self)
layout.addWidget(self.jump_list)
self.setLayout(layout)
self.delete_button.clicked.connect(self.delete_reaction)
self.throttler = SignalThrottler(500)
self.throttler.triggered.connect(self.reaction_data_changed)
self.id.textEdited.connect(self.throttler.throttle)
self.name.textEdited.connect(self.throttler.throttle)
self.equation.textEdited.connect(self.throttler.throttle)
self.lower_bound.textEdited.connect(self.throttler.throttle)
self.upper_bound.textEdited.connect(self.throttler.throttle)
self.coefficent.textEdited.connect(self.throttler.throttle)
self.gene_reaction_rule.textEdited.connect(self.throttler.throttle)
self.annotation.itemChanged.connect(self.throttler.throttle)
self.validate_mask()
def add_anno_row(self):
i = self.annotation.rowCount()
self.annotation.insertRow(i)
self.changed = True
def apply(self):
try:
self.reaction.id = self.id.text()
except ValueError:
turn_red(self.id)
QMessageBox.information(
self, 'Invalid id', 'Could not apply changes identifier ' +
self.id.text() + ' already used.')
else:
self.reaction.name = self.name.text()
self.reaction.build_reaction_from_string(self.equation.text())
self.reaction.lower_bound = float(self.lower_bound.text())
self.reaction.upper_bound = float(self.upper_bound.text())
self.reaction.objective_coefficient = float(self.coefficent.text())
self.reaction.gene_reaction_rule = self.gene_reaction_rule.text()
self.reaction.annotation = {}
rows = self.annotation.rowCount()
for i in range(0, rows):
key = self.annotation.item(i, 0).text()
if self.annotation.item(i, 1) is None:
value = ""
else:
value = self.annotation.item(i, 1).text()
self.reaction.annotation[key] = value
self.changed = False
self.reactionChanged.emit(self.reaction)
def delete_reaction(self):
self.hide()
self.reactionDeleted.emit(self.reaction)
def validate_id(self):
with self.parent.appdata.project.cobra_py_model as model:
try:
r = cobra.Reaction(id=self.id.text())
model.add_reaction(r)
except ValueError:
turn_red(self.id)
return False
else:
turn_white(self.id)
return True
def validate_name(self):
with self.parent.appdata.project.cobra_py_model as model:
try:
r = cobra.Reaction(id="testid", name=self.name.text())
model.add_reaction(r)
except ValueError:
turn_red(self.name)
return False
else:
turn_white(self.name)
return True
def validate_equation(self):
ok = False
test_reaction = cobra.Reaction(
"xxxx_cnapy_test_reaction", name="cnapy test reaction")
with self.parent.appdata.project.cobra_py_model as model:
model.add_reaction(test_reaction)
try:
eqtxt = self.equation.text().rstrip()
if len(eqtxt) > 0 and eqtxt[-1] == '+':
turn_red(self.equation)
else:
test_reaction.build_reaction_from_string(eqtxt)
turn_white(self.equation)
ok = True
except ValueError:
turn_red(self.equation)
try:
test_reaction = self.parent.appdata.project.cobra_py_model.reactions.get_by_id(
"xxxx_cnapy_test_reaction")
self.parent.appdata.project.cobra_py_model.remove_reactions(
[test_reaction], remove_orphans=True)
except KeyError:
pass
return ok
def validate_lowerbound(self):
try:
_x = float(self.lower_bound.text())
except ValueError:
turn_red(self.lower_bound)
return False
else:
turn_white(self.lower_bound)
return True
def validate_upperbound(self):
try:
_x = float(self.upper_bound.text())
except ValueError:
turn_red(self.upper_bound)
return False
else:
turn_white(self.upper_bound)
return True
def validate_coefficient(self):
try:
_x = float(self.coefficent.text())
except ValueError:
turn_red(self.coefficent)
return False
else:
turn_white(self.coefficent)
return True
def validate_gene_reaction_rule(self):
try:
_x = float(self.gene_reaction_rule.text())
except ValueError:
turn_red(self.gene_reaction_rule)
return False
else:
turn_white(self.gene_reaction_rule)
return True
def validate_mask(self):
valid_id = self.validate_id()
valid_name = self.validate_name()
valid_equation = self.validate_equation()
valid_lb = self.validate_lowerbound()
valid_ub = self.validate_upperbound()
valid_coefficient = self.validate_coefficient()
if valid_id & valid_name & valid_equation & valid_lb & valid_ub & valid_coefficient:
self.is_valid = True
else:
self.is_valid = False
def reaction_data_changed(self):
self.changed = True
self.validate_mask()
if self.is_valid:
self.apply()
self.update_state()
def update_state(self):
self.jump_list.clear()
for name, m in self.parent.appdata.project.maps.items():
if self.id.text() in m["boxes"]:
self.jump_list.add(name)
self.metabolites.clear()
if self.parent.appdata.project.cobra_py_model.reactions.has_id(self.id.text()):
reaction = self.parent.appdata.project.cobra_py_model.reactions.get_by_id(
self.id.text())
for m in reaction.metabolites:
item = QTreeWidgetItem(self.metabolites)
item.setText(0, m.id)
item.setText(1, m.name)
item.setData(2, 0, m)
text = "Id: " + m.id + "\nName: " + m.name
item.setToolTip(1, text)
def emit_jump_to_map(self, name):
self.jumpToMap.emit(name, self.id.text())
def emit_jump_to_metabolite(self, metabolite):
self.jumpToMetabolite.emit(str(metabolite.data(2, 0)))
jumpToMap = Signal(str, str)
jumpToMetabolite = Signal(str)
reactionChanged = Signal(cobra.Reaction)
reactionDeleted = Signal(cobra.Reaction)
def __init__(self, appdata):
QWidget.__init__(self)
self.appdata = appdata
self.metabolite = None
self.is_valid = True
self.changed = False
self.setAcceptDrops(False)
layout = QVBoxLayout()
l = QHBoxLayout()
label = QLabel("Id:")
self.id = QLineEdit()
l.addWidget(label)
l.addWidget(self.id)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Name:")
self.name = QLineEdit()
l.addWidget(label)
l.addWidget(self.name)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Formula:")
self.formula = QLineEdit()
l.addWidget(label)
l.addWidget(self.formula)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Charge:")
self.charge = QLineEdit()
l.addWidget(label)
l.addWidget(self.charge)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Compartment:")
self.compartment = QLineEdit()
l.addWidget(label)
l.addWidget(self.compartment)
layout.addItem(l)
l = QVBoxLayout()
label = QLabel("Annotations:")
l.addWidget(label)
l2 = QHBoxLayout()
self.annotation = QTableWidget(0, 2)
self.annotation.setHorizontalHeaderLabels(
["key", "value"])
self.annotation.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
l2.addWidget(self.annotation)
self.add_anno = QPushButton("+")
self.add_anno.clicked.connect(self.add_anno_row)
l2.addWidget(self.add_anno)
l.addItem(l2)
layout.addItem(l)
l = QVBoxLayout()
label = QLabel("Reactions using this metabolite:")
l.addWidget(label)
l2 = QHBoxLayout()
self.reactions = QTreeWidget()
self.reactions.setHeaderLabels(["Id"])
self.reactions.setSortingEnabled(True)
l2.addWidget(self.reactions)
l.addItem(l2)
self.reactions.itemDoubleClicked.connect(self.emit_jump_to_reaction)
layout.addItem(l)
self.setLayout(layout)
self.throttler = SignalThrottler(500)
self.throttler.triggered.connect(self.metabolites_data_changed)
self.id.textEdited.connect(self.throttler.throttle)
self.name.textEdited.connect(self.throttler.throttle)
self.formula.textEdited.connect(self.throttler.throttle)
self.charge.textEdited.connect(self.throttler.throttle)
self.compartment.textEdited.connect(self.throttler.throttle)
self.annotation.itemChanged.connect(self.throttler.throttle)
self.validate_mask()
class CalculationPrepare(QDialog):
"""
:type mask_path_list: list[QLineEdit]
:type mask_mapper_list: list[MaskMapper]
"""
def __init__(self, file_list, calculation_plan, measurement_file_path,
settings, batch_manager):
"""
:param file_list: list of files to proceed
:type file_list: list[str]
:param calculation_plan: calculation plan for this run
:type calculation_plan: CalculationPlan
:param measurement_file_path: path to measurement result file
:type measurement_file_path: str
:param settings: settings object
:type settings: PartSettings
:type batch_manager: CalculationManager
"""
super().__init__()
self.setWindowTitle("Calculation start")
self.file_list = file_list
self.calculation_plan = calculation_plan
self.measurement_file_path = measurement_file_path
self.settings = settings
self.batch_manager = batch_manager
self.info_label = QLabel(
"Information, <i><font color='blue'>warnings</font></i>, "
"<b><font color='red'>errors</font><b>")
self.voxel_size = Spacing("Voxel size", settings.image.spacing,
settings.get("units_value", Units.nm))
all_prefix = os.path.commonprefix(file_list)
if not os.path.exists(all_prefix):
all_prefix = os.path.dirname(all_prefix)
if not os.path.isdir(all_prefix):
all_prefix = os.path.dirname(all_prefix)
self.base_prefix = QLineEdit(all_prefix, self)
self.base_prefix.setReadOnly(True)
self.result_prefix = QLineEdit(all_prefix, self)
self.result_prefix.setReadOnly(True)
self.base_prefix_btn = QPushButton("Choose data prefix")
self.base_prefix_btn.clicked.connect(self.choose_data_prefix)
self.result_prefix_btn = QPushButton("Choose save prefix")
self.result_prefix_btn.clicked.connect(self.choose_result_prefix)
self.sheet_name = QLineEdit("Sheet1")
self.sheet_name.textChanged.connect(self.verify_data)
self.measurement_file_path_view = QLineEdit(measurement_file_path)
self.measurement_file_path_view.setReadOnly(True)
self.mask_path_list = []
self.mask_mapper_list = self.calculation_plan.get_list_file_mask()
mask_file_list = []
for i, el in enumerate(self.mask_mapper_list):
if isinstance(el, MaskFile):
mask_file_list.append((i, el))
mask_path_layout = QGridLayout()
for i, (pos, mask_file) in enumerate(mask_file_list):
if mask_file.name == "":
mask_path_layout.addWidget(
right_label("Path to file {} with mask mapping".format(i +
1)))
else:
mask_path_layout.addWidget(
right_label(
"Path to file {} with mask mapping for name: {}".
format(i + 1, mask_file.name)))
mask_path = QLineEdit(self)
mask_path.setReadOnly(True)
self.mask_path_list.append(mask_path)
set_path = QPushButton("Choose file", self)
set_path.clicked.connect(self.set_mapping_mask(i, pos))
mask_path_layout.addWidget(mask_path, i, 1)
mask_path_layout.addWidget(set_path, i, 2)
self.state_list = np.zeros(
(len(self.file_list), len(self.mask_mapper_list)), dtype=np.uint8)
self.file_list_widget = QTreeWidget()
self.file_list_widget.header().close()
self.execute_btn = QPushButton("Execute")
self.execute_btn.clicked.connect(self.accept)
self.cancel_btn = QPushButton("Cancel")
self.cancel_btn.clicked.connect(self.close)
layout = QGridLayout()
layout.addWidget(self.info_label, 0, 0, 1, 5)
layout.addWidget(self.voxel_size, 1, 0, 1, 5)
layout.addWidget(right_label("Measurement sheet name:"), 3, 3)
layout.addWidget(self.sheet_name, 3, 4)
layout.addWidget(right_label("Measurement file path:"), 2, 3)
layout.addWidget(self.measurement_file_path_view, 2, 4)
layout.addWidget(right_label("Data prefix:"), 2, 0)
layout.addWidget(self.base_prefix, 2, 1)
layout.addWidget(self.base_prefix_btn, 2, 2)
layout.addWidget(right_label("Save prefix:"), 3, 0)
layout.addWidget(self.result_prefix, 3, 1)
layout.addWidget(self.result_prefix_btn, 3, 2)
layout.addLayout(mask_path_layout, 4, 0, 1, 0)
layout.addWidget(self.file_list_widget, 5, 0, 3, 6)
btn_layout = QHBoxLayout()
btn_layout.addWidget(self.execute_btn)
btn_layout.addStretch()
btn_layout.addWidget(self.cancel_btn)
layout.addLayout(btn_layout, 8, 0, 1, 0)
self.setLayout(layout)
self.verify_data()
def choose_data_prefix(self):
dial = QFileDialog()
dial.setAcceptMode(QFileDialog.AcceptOpen)
dial.setFileMode(QFileDialog.Directory)
dial.setDirectory(self.base_prefix.text())
dial.setHistory(dial.history() + self.settings.get_path_history())
if dial.exec_():
dir_path = str(dial.selectedFiles()[0])
self.base_prefix.setText(dir_path)
def choose_result_prefix(self):
dial = QFileDialog()
dial.setOption(QFileDialog.DontUseNativeDialog, True)
dial.setAcceptMode(QFileDialog.AcceptOpen)
dial.setFileMode(QFileDialog.Directory)
dial.setDirectory(self.result_prefix.text())
dial.setHistory(dial.history() + self.settings.get_path_history())
if dial.exec_():
dir_path = str(dial.selectedFiles()[0])
self.result_prefix.setText(dir_path)
def set_mapping_mask(self, i, pos):
def mapping_dialog():
dial = QFileDialog(self, "Select file")
dial.setHistory(dial.history() + self.settings.get_path_history())
base_path = str(self.base_prefix.text()).strip()
if base_path != "":
dial.setDirectory(base_path)
dial.setFileMode(QFileDialog.ExistingFile)
if dial.exec_():
path = str(dial.selectedFiles())
self.mask_path_list[i].setText(path)
file_mapper: MaskFile = self.mask_mapper_list[pos]
file_mapper.set_map_path(path)
return mapping_dialog
def get_data(self):
res = {
"file_list": self.file_list,
"base_prefix": str(self.base_prefix.text()),
"result_prefix": str(self.result_prefix.text()),
"measurement_file_path":
str(self.measurement_file_path_view.text()),
"sheet_name": str(self.sheet_name.text()),
"calculation_plan": self.calculation_plan,
"voxel_size": self.voxel_size.get_values(),
}
return Calculation(**res)
def verify_data(self):
self.execute_btn.setEnabled(True)
text = (
"information, <i><font color='blue'>warnings</font></i>, <b><font color='red'>errors</font></b><br>"
"The voxel size is for file in which metadata do not contains this information<br>"
)
if not self.batch_manager.is_valid_sheet_name(
str(self.measurement_file_path_view.text()),
str(self.sheet_name.text())):
text += "<i><font color='blue'>Sheet name already in use</i></font><br>"
self.execute_btn.setDisabled(True)
if self.state_list.size > 0:
val = np.unique(self.state_list)
if 1 in val:
self.execute_btn.setDisabled(True)
text += "<i><font color='blue'>Some mask map file are not set</font></i><br>"
if 2 in val:
self.execute_btn.setDisabled(True)
text += "<b><font color='red'>Some mask do not exists</font><b><br>"
text = text[:-4]
self.info_label.setText(text)
def showEvent(self, event):
super().showEvent(event)
ok_icon = QIcon(os.path.join(icons_dir, "task-accepted.png"))
bad_icon = QIcon(os.path.join(icons_dir, "task-reject.png"))
warn_icon = QIcon(os.path.join(icons_dir, "task-attempt.png"))
all_prefix = os.path.commonprefix(self.file_list)
if not os.path.exists(all_prefix):
all_prefix = os.path.dirname(all_prefix)
for file_num, file_path in enumerate(self.file_list):
widget = QTreeWidgetItem(self.file_list_widget)
widget.setText(0, os.path.relpath(file_path, all_prefix))
if not os.path.exists(file_path):
widget.setIcon(0, bad_icon)
widget.setToolTip(0, "File do not exists")
sub_widget = QTreeWidgetItem(widget)
sub_widget.setText(0, "File do not exists")
continue
for mask_num, mask_mapper in enumerate(self.mask_mapper_list):
if mask_mapper.is_ready():
mask_path = mask_mapper.get_mask_path(file_path)
exist = os.path.exists(mask_path)
if exist:
sub_widget = QTreeWidgetItem(widget)
sub_widget.setText(
0, "Mask {} ok".format(mask_mapper.name))
sub_widget.setIcon(0, ok_icon)
self.state_list[file_num, mask_num] = 0
else:
sub_widget = QTreeWidgetItem(widget)
sub_widget.setText(
0,
"Mask {} do not exists (path: {})".format(
mask_mapper.name,
os.path.relpath(mask_path, all_prefix)),
)
sub_widget.setIcon(0, bad_icon)
self.state_list[file_num, mask_num] = 2
else:
sub_widget = QTreeWidgetItem(widget)
sub_widget.setText(
0, "Mask {} unknown".format(mask_mapper.name))
sub_widget.setIcon(0, warn_icon)
self.state_list[file_num, mask_num] = 1
if self.state_list.shape[1] == 0:
state = 0
else:
state = self.state_list[file_num].max()
if state == 0:
widget.setIcon(0, ok_icon)
elif state == 1:
widget.setIcon(0, warn_icon)
else:
widget.setIcon(0, bad_icon)
class AlgorithmMonitorDialog(QDialog):
"""
Displays progress of all running algorithms.
"""
def __init__(self, parent, model):
super(AlgorithmMonitorDialog, self).__init__(parent)
self.tree = QTreeWidget(self)
self.tree.setColumnCount(3)
self.tree.setSelectionMode(QTreeWidget.NoSelection)
self.tree.setColumnWidth(0, 220)
self.tree.setHeaderLabels(['Algorithm', 'Progress', ''])
header = self.tree.header()
header.setSectionResizeMode(1, QHeaderView.Stretch)
header.setSectionResizeMode(2, QHeaderView.Fixed)
header.setStretchLastSection(False)
button_layout = QHBoxLayout()
self.close_button = QPushButton('Close')
button_layout.addStretch()
button_layout.addWidget(self.close_button)
layout = QVBoxLayout()
layout.addWidget(self.tree)
layout.addLayout(button_layout)
self.setLayout(layout)
self.setWindowTitle('Mantid - Algorithm progress')
self.setWindowIcon(QIcon(":/MantidPlot_Icon_32offset.png"))
self.resize(500, 300)
self.presenter = AlgorithmProgressDialogPresenter(self, model)
self.presenter.update_gui()
def update(self, data):
"""
Update the gui elements.
:param data: Data in format of AlgorithmProgressModel.get_running_algorithm_data()
"""
self.tree.clear()
for alg_data in data:
name, id, properties = alg_data
item = QTreeWidgetItem([name])
self.tree.addTopLevelItem(item)
progress_bar = QProgressBar()
progress_bar.setAlignment(Qt.AlignHCenter)
self.presenter.add_progress_bar(id, progress_bar)
cancel_button = CancelButton(self.presenter, id)
self.tree.setItemWidget(item, 1, progress_bar)
self.tree.setItemWidget(item, 2, cancel_button)
for prop in properties:
item.addChild(QTreeWidgetItem(prop))
def __init__(self, file_list, calculation_plan, measurement_file_path,
settings, batch_manager):
"""
:param file_list: list of files to proceed
:type file_list: list[str]
:param calculation_plan: calculation plan for this run
:type calculation_plan: CalculationPlan
:param measurement_file_path: path to measurement result file
:type measurement_file_path: str
:param settings: settings object
:type settings: PartSettings
:type batch_manager: CalculationManager
"""
super().__init__()
self.setWindowTitle("Calculation start")
self.file_list = file_list
self.calculation_plan = calculation_plan
self.measurement_file_path = measurement_file_path
self.settings = settings
self.batch_manager = batch_manager
self.info_label = QLabel(
"Information, <i><font color='blue'>warnings</font></i>, "
"<b><font color='red'>errors</font><b>")
self.voxel_size = Spacing("Voxel size", settings.image.spacing,
settings.get("units_value", Units.nm))
all_prefix = os.path.commonprefix(file_list)
if not os.path.exists(all_prefix):
all_prefix = os.path.dirname(all_prefix)
if not os.path.isdir(all_prefix):
all_prefix = os.path.dirname(all_prefix)
self.base_prefix = QLineEdit(all_prefix, self)
self.base_prefix.setReadOnly(True)
self.result_prefix = QLineEdit(all_prefix, self)
self.result_prefix.setReadOnly(True)
self.base_prefix_btn = QPushButton("Choose data prefix")
self.base_prefix_btn.clicked.connect(self.choose_data_prefix)
self.result_prefix_btn = QPushButton("Choose save prefix")
self.result_prefix_btn.clicked.connect(self.choose_result_prefix)
self.sheet_name = QLineEdit("Sheet1")
self.sheet_name.textChanged.connect(self.verify_data)
self.measurement_file_path_view = QLineEdit(measurement_file_path)
self.measurement_file_path_view.setReadOnly(True)
self.mask_path_list = []
self.mask_mapper_list = self.calculation_plan.get_list_file_mask()
mask_file_list = []
for i, el in enumerate(self.mask_mapper_list):
if isinstance(el, MaskFile):
mask_file_list.append((i, el))
mask_path_layout = QGridLayout()
for i, (pos, mask_file) in enumerate(mask_file_list):
if mask_file.name == "":
mask_path_layout.addWidget(
right_label("Path to file {} with mask mapping".format(i +
1)))
else:
mask_path_layout.addWidget(
right_label(
"Path to file {} with mask mapping for name: {}".
format(i + 1, mask_file.name)))
mask_path = QLineEdit(self)
mask_path.setReadOnly(True)
self.mask_path_list.append(mask_path)
set_path = QPushButton("Choose file", self)
set_path.clicked.connect(self.set_mapping_mask(i, pos))
mask_path_layout.addWidget(mask_path, i, 1)
mask_path_layout.addWidget(set_path, i, 2)
self.state_list = np.zeros(
(len(self.file_list), len(self.mask_mapper_list)), dtype=np.uint8)
self.file_list_widget = QTreeWidget()
self.file_list_widget.header().close()
self.execute_btn = QPushButton("Execute")
self.execute_btn.clicked.connect(self.accept)
self.cancel_btn = QPushButton("Cancel")
self.cancel_btn.clicked.connect(self.close)
layout = QGridLayout()
layout.addWidget(self.info_label, 0, 0, 1, 5)
layout.addWidget(self.voxel_size, 1, 0, 1, 5)
layout.addWidget(right_label("Measurement sheet name:"), 3, 3)
layout.addWidget(self.sheet_name, 3, 4)
layout.addWidget(right_label("Measurement file path:"), 2, 3)
layout.addWidget(self.measurement_file_path_view, 2, 4)
layout.addWidget(right_label("Data prefix:"), 2, 0)
layout.addWidget(self.base_prefix, 2, 1)
layout.addWidget(self.base_prefix_btn, 2, 2)
layout.addWidget(right_label("Save prefix:"), 3, 0)
layout.addWidget(self.result_prefix, 3, 1)
layout.addWidget(self.result_prefix_btn, 3, 2)
layout.addLayout(mask_path_layout, 4, 0, 1, 0)
layout.addWidget(self.file_list_widget, 5, 0, 3, 6)
btn_layout = QHBoxLayout()
btn_layout.addWidget(self.execute_btn)
btn_layout.addStretch()
btn_layout.addWidget(self.cancel_btn)
layout.addLayout(btn_layout, 8, 0, 1, 0)
self.setLayout(layout)
self.verify_data()
class TomographyPlugin(GUIPlugin):
name = "Tomography"
def __init__(self, *args, **kwargs):
self.active_filename = ""
self._main_view = QMainWindow()
self._main_view.setCentralWidget(QWidget())
self._main_view.centralWidget().hide()
self._editors = QStackedWidget()
self.workflow_process_selector = QComboBox()
self.workflow_process_selector.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self.workflow_process_selector.addItem("TomoPy Workflow")
self._workflow = None
self._tomo_workflow = TomographyWorkflow() # Create a workflow
self._workflow = self._tomo_workflow
self._workflow_editor = WorkflowEditor(workflow=self._workflow)
self._workflow_editor.sigRunWorkflow.connect(self.run_workflow)
self._active_workflow_executor = QTreeWidget()
self._editors.addWidget(self._workflow_editor)
if hasLTT:
self._alt_workflow = LTTWorkflow()
self.workflow_process_selector.addItem("LTT Workflow")
self._alt_workflow_editor = WorkflowEditor(self._alt_workflow)
self._alt_workflow_editor.sigRunWorkflow.connect(self.run_workflow)
self._editors.addWidget(self._alt_workflow_editor)
self.workflow_process_selector.setCurrentIndex(0)
self.workflow_process_selector.currentIndexChanged.connect(self.active_workflow_changed)
self._active_workflow_widget = QWidget()
self._active_layout = QVBoxLayout()
self._active_layout.addWidget(self.workflow_process_selector)
self._active_layout.addWidget(self._editors)
self._active_layout.addWidget(self._active_workflow_executor)
self._active_workflow_widget.setLayout(self._active_layout)
# self.hdf5_viewer = HDFTreeViewer()
# self.hdf5_viewer.load("/Users/hari/20200521_160002_heartbeat_test.h5")
self.top_controls = QWidget()
self.top_controls_layout = QHBoxLayout()
self.top_controls.setLayout(self.top_controls_layout)
self.top_controls_add_new_selector = QComboBox()
self.top_controls_frequency_selector = QSpinBox()
self.top_controls_frequency_selector.setValue(0)
self.top_controls_add_new_viewer = QPushButton()
self.top_controls_add_new_viewer.setText("Add Viewer")
self.top_controls_add_new_viewer.clicked.connect(self.add_new_viewer_selected)
self.top_controls_preview = QPushButton()
self.top_controls_preview.setText("Preview")
self.top_controls_preview.clicked.connect(self.preview_workflows)
self.top_controls_execute = QPushButton()
self.top_controls_execute.setText("Execute All")
self.top_controls_execute.clicked.connect(self.execute_workflows)
self.top_controls_add_new_selector.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.top_controls_add_new_viewer.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.top_controls_execute.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.top_controls_frequency_selector.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.top_controls_layout.addWidget(self.top_controls_add_new_selector)
self.top_controls_layout.addWidget(self.top_controls_add_new_viewer)
self.top_controls_layout.addWidget(self.top_controls_frequency_selector)
self.top_controls_layout.addWidget(self.top_controls_preview)
self.top_controls_layout.addWidget(self.top_controls_execute)
self.top_controls.setLayout(self.top_controls_layout)
self.status_bar = QLabel("None Loaded...")
# Create a layout to organize our widgets
# The first argument (which corresponds to the center widget) is required.
catalog_viewer_layout = GUILayout(self._main_view,
top=self.top_controls,
right=self._active_workflow_widget,
bottom=self.status_bar)
# Create a "View" stage that has the catalog viewer layout
self.stages = {"View": catalog_viewer_layout}
self.active_workflows = []
# For classes derived from GUIPlugin, this super __init__ must occur at end
super(TomographyPlugin, self).__init__(*args, **kwargs)
def active_workflow_changed(self, index):
self._editors.setCurrentIndex(index)
if index == 0:
self._workflow = self._tomo_workflow
else:
self._workflow = self._alt_workflow
def preview_workflows(self):
if len(self.active_filename) == 0:
return
preview_sinogram = self.top_controls_frequency_selector.value()
workflows = []
for aw in range(self._active_workflow_executor.topLevelItemCount()):
widget_item = self._active_workflow_executor.topLevelItem(aw)
workflow = widget_item.data(0, Qt.UserRole)
workflows.append(workflow)
active_workflows = self.active_workflows
for workflow in workflows:
def results_ready(workflow, *results):
output_image = results[0]["recon"] # We want the output_image from the last operation
# print("RECON SHAPE", output_image.shape)
for active_workflow in active_workflows:
if active_workflow[1] == workflow:
active_workflow[0].widget().setImage(output_image) # Update the result view widget
workflow.execute(callback_slot=partial(results_ready, workflow), path=self.active_filename, sinoindex=preview_sinogram)
def execute_workflows(self):
if len(self.active_filename) == 0:
return
workflows = []
for aw in range(self._active_workflow_executor.topLevelItemCount()):
widget_item = self._active_workflow_executor.topLevelItem(aw)
workflow = widget_item.data(0, Qt.UserRole)
workflows.append(workflow)
active_workflows = self.active_workflows
for workflow in workflows:
def results_ready(workflow, *results):
output_image = results[0]["recon"] # We want the output_image from the last operation
# print("RECON SHAPE", output_image.shape)
for active_workflow in active_workflows:
if active_workflow[1] == workflow:
active_workflow[0].widget().setImage(output_image) # Update the result view widget
workflow.execute(callback_slot=partial(results_ready, workflow), path=self.active_filename)
def add_new_viewer_selected(self, checked):
if self.top_controls_add_new_selector.count() == 0:
return
selected = self.top_controls_add_new_selector.currentIndex()
if selected < 0:
return
workflow = self.top_controls_add_new_selector.currentData(Qt.UserRole)
print("WORKFLOW", workflow, workflow.name)
dock_widget = QDockWidget()
viewer = CatalogView()
dock_widget.setWidget(viewer)
dock_widget.setWindowTitle(workflow.name)
if len(self.active_workflows) == 0:
self._main_view.addDockWidget(Qt.RightDockWidgetArea, dock_widget)
else:
self._main_view.tabifyDockWidget(self.active_workflows[-1][0], dock_widget)
self.active_workflows.append((dock_widget, workflow))
def appendHeader(self, header, **kwargs):
filename = header._documents["start"][0]["filename"]
self.active_filename = filename
self.status_bar.setText("Loading Filename:" + filename)
dataset, bkgs, drks = read_als_hdf5(filename)
slice_widget = MyCatalogView()
dw = QDockWidget()
dw.setWidget(slice_widget)
dw.setWindowTitle(filename)
slice_widget.setImage(dataset)
dock_children = self._main_view.findChildren(QDockWidget)
print(dock_children)
#if len(dock_children) == 0:
# self._main_view.addDockWidget(Qt.LeftDockWidgetArea, dw)
#else:
# self._main_view.tabifyDockWidget(dock_children[0], dw)
self._main_view.addDockWidget(Qt.LeftDockWidgetArea, dw)
self.status_bar.setText("Done Loading Filename:" + filename)
def appendCatalog(self, catalog, **kwargs):
"""Re-implemented from GUIPlugin - gives us access to a catalog reference
You MUST implement this method if you want to load catalog data into your GUIPlugin.
"""
# Set the catalog viewer's catalog, stream, and field (so it knows what to display)
# This is a quick and simple demonstration; stream and field should NOT be hardcoded
# stream = "primary"
# field = "img"
# self._catalog_viewer.setCatalog(catalog, stream, field)
print("CATALOG CALLED", catalog)
pass
def run_workflow(self):
"""Run the internal workflowi.
In this example, this will be called whenever the "Run Workflow" in the WorkflowEditor is clicked.
"""
item = QTreeWidgetItem()
workflow_name = self._workflow.name + ":" + str(self._active_workflow_executor.model().rowCount())
workflow = self._workflow.clone()
workflow.name = workflow_name
workflow._pretty_print()
item.setText(0, workflow_name)
item.setData(0, Qt.UserRole, workflow)
self._active_workflow_executor.addTopLevelItem(item)
self.top_controls_add_new_selector.addItem(workflow_name, userData=workflow)
