def add_to_persistent_pipeline(self, pipeline):
"""add_to_persistent_pipeline(pipeline):
(module_id_map, connection_id_map, modules_added)
Adds a pipeline to the persistent pipeline of the cached interpreter
and adds current logging object to each existing module.
Returns four things: two dictionaries describing the mapping
of ids from the passed pipeline to the persistent one (the
first one has the module id mapping, the second one has the
connection id mapping), a set of all module ids added to the
persistent pipeline, and a set of all connection ids added to
the persistent pipeline."""
module_id_map = Bidict()
connection_id_map = Bidict()
modules_added = set()
connections_added = set()
pipeline.refresh_signatures()
# we must traverse vertices in topological sort order
verts = pipeline.graph.vertices_topological_sort()
for new_module_id in verts:
new_sig = pipeline.subpipeline_signature(new_module_id)
if not self._persistent_pipeline.has_subpipeline_signature(new_sig):
# Must add module to persistent pipeline
persistent_module = copy.copy(pipeline.modules[new_module_id])
persistent_id = self._persistent_pipeline.fresh_module_id()
persistent_module.id = persistent_id
self._persistent_pipeline.add_module(persistent_module)
self._persistent_pipeline.modules[persistent_id]._signature = \
base64.b16encode(new_sig).lower()
module_id_map[new_module_id] = persistent_id
modules_added.add(new_module_id)
else:
i = self._persistent_pipeline \
.subpipeline_id_from_signature(new_sig)
module_id_map[new_module_id] = i
for connection in pipeline.connections.itervalues():
new_sig = pipeline.connection_signature(connection.id)
if not self._persistent_pipeline.has_connection_signature(new_sig):
# Must add connection to persistent pipeline
persistent_connection = copy.copy(connection)
persistent_id = self._persistent_pipeline.fresh_connection_id()
persistent_connection.id = persistent_id
persistent_connection.sourceId = module_id_map[
connection.sourceId]
persistent_connection.destinationId = module_id_map[
connection.destinationId]
self._persistent_pipeline.add_connection(persistent_connection)
connection_id_map[connection.id] = persistent_id
connections_added.add(connection.id)
else:
i = self._persistent_pipeline \
.connection_id_from_signature(new_sig)
connection_id_map[connection.id] = i
# update persistent signatures
self._persistent_pipeline.compute_signatures()
return (module_id_map, connection_id_map,
modules_added, connections_added)
def __init__(self, parent=None, f=QtCore.Qt.WindowFlags()):
QtGui.QMainWindow.__init__(self, parent, f)
BaseView.__init__(self)
self.set_title("Mashup")
self.controller = None
self.mshpController = None
self.createActions()
#Setting up a toolbar
self.createToolBar()
self.tab_to_stack_idx = {}
self.button_to_tab_idx = Bidict()
widget = QtGui.QWidget(self)
layout = QtGui.QVBoxLayout()
layout.setMargin(0)
layout.setSpacing(0)
self.tabBar = QtGui.QTabBar(self)
self.tabBar.setDocumentMode(True)
self.tabBar.setTabsClosable(False)
self.tabBar.setExpanding(False)
self.tabBar.currentChanged.connect(self.switchTab)
self.stack = QtGui.QStackedWidget(self)
layout.addWidget(self.tabBar)
layout.addWidget(self.stack)
widget.setLayout(layout)
self.setCentralWidget(widget)
self.createAliasPanelTab()
widget.setVisible(True)
#self.createPipelineTab()
self.setWindowTitle("Mashup Builder")
self.vtversion = -1
self.manager = MashupsManager.getInstance()
def clear(self):
"""clear(self) -> None. Removes all references, prepares for
deletion."""
for connector_list in self.inputPorts.itervalues():
for connector in connector_list:
connector.clear()
self.inputPorts = {}
self.outputPorts = {}
self.logging = _dummy_logging
self.is_method = Bidict()
self._latest_method_order = 0
def build_widget(self):
layout = QtGui.QVBoxLayout()
layout.setMargin(4)
layout.setSpacing(2)
self.searchBox = QSearchBox(True, False, self)
layout.addWidget(self.searchBox)
radio_layout = QtGui.QHBoxLayout()
radio_layout.setSpacing(5)
radio_layout.setAlignment(QtCore.Qt.AlignLeft)
radio_layout.addWidget(QtGui.QLabel("Search:"))
searchAll = QtGui.QRadioButton("Open Vistrails")
searchCurrent = QtGui.QRadioButton("Current Vistrail")
searchWorkflow = QtGui.QRadioButton("Current Workflow")
self.level_group = QtGui.QButtonGroup()
self.level_group.addButton(searchAll)
self.level_group.addButton(searchCurrent)
self.level_group.addButton(searchWorkflow)
self.level_map = \
Bidict([(QueryController.LEVEL_ALL, searchAll),
(QueryController.LEVEL_VISTRAIL, searchCurrent),
(QueryController.LEVEL_WORKFLOW, searchWorkflow)])
radio_layout.addWidget(searchAll)
radio_layout.addWidget(searchCurrent)
radio_layout.addWidget(searchWorkflow)
searchCurrent.setChecked(True)
self.editButton = QtGui.QPushButton("Edit")
self.editButton.setEnabled(False)
self.backButton = QtGui.QPushButton("Back to Search")
self.backButton.setEnabled(False)
radio_layout.addStretch(1)
radio_layout.addWidget(self.editButton, 0, QtCore.Qt.AlignRight)
radio_layout.addWidget(self.backButton, 0, QtCore.Qt.AlignRight)
layout.addLayout(radio_layout)
self.setLayout(layout)
self.connect(self.searchBox, QtCore.SIGNAL('resetSearch()'),
self.resetSearch)
self.connect(self.searchBox, QtCore.SIGNAL('executeSearch(QString)'),
self.executeSearch)
self.connect(self.searchBox, QtCore.SIGNAL('refineMode(bool)'),
self.refineMode)
self.connect(self.backButton, QtCore.SIGNAL('clicked()'),
self.backToSearch)
self.connect(self.editButton, QtCore.SIGNAL('clicked()'),
self.doEdit)
self.connect(self.level_group,
QtCore.SIGNAL('buttonClicked(QAbstractButton*)'),
self.levelChanged)
def __init__(self):
self.inputPorts = {}
self.outputPorts = {}
self.upToDate = False
self.setResult("self", self) # every object can return itself
self.logging = _dummy_logging
# isMethod stores whether a certain input port is a method.
# If so, isMethod maps the port to the order in which it is
# stored. This is so that modules that need to know about the
# method order can work correctly
self.is_method = Bidict()
self._latest_method_order = 0
# Pipeline info that a module should know about This is useful
# for a spreadsheet cell to know where it is from. It will be
# also used for talking back and forth between the spreadsheet
# and the builder besides Parameter Exploration.
self.moduleInfo = {
'locator': None,
'vistrailName': 'Unknown',
'version': -1,
'pipeline': None,
'moduleId': -1,
'reason': 'Pipeline Execution',
'actions': []
}
self.is_breakpoint = False
# is_fold_operator stores wether the module is a part of a fold
self.is_fold_operator = False
# is_fold_module stores whether the module is a fold module
self.is_fold_module = False
# computed stores wether the module was computed
# used for the logging stuff
self.computed = False
self.suspended = False
self.signature = None
def __init__(self, controller, panel, parent=None):
""" QAliasList(parent: QWidget) -> QAliasTable
"""
QtGui.QTreeWidget.__init__(self, parent)
self.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.setRootIsDecorated(False)
self.panel = panel
self.aliases = Bidict()
self.alias_widgets = {}
self.current_item = None
self.controller = controller
self.header().setStretchLastSection(True)
self.setHeaderLabels(
QtCore.QStringList() << "Position" << "Name" << "Type")
self.itemSelectionChanged.connect(self.setPreviousSelected)
self.connect(
self,
QtCore.SIGNAL(
"currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)"),
self.currentAliasChanged)
self.previousSelected = -1
class QQueryView(QtGui.QWidget, BaseView):
VISUAL_SEARCH_VIEW = 0
GLOBAL_RESULT_VIEW = 1
VERSION_RESULT_VIEW = 2
WORKFLOW_RESULT_VIEW = 3
RESULT_LEVEL_MAP = \
Bidict([(QueryController.LEVEL_ALL, GLOBAL_RESULT_VIEW),
(QueryController.LEVEL_VISTRAIL, VERSION_RESULT_VIEW),
(QueryController.LEVEL_WORKFLOW, WORKFLOW_RESULT_VIEW)])
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
BaseView.__init__(self)
self.build_widget()
self.set_title("Search")
def set_controller(self, controller=None):
if self.controller:
self.disconnect(self.controller,
QtCore.SIGNAL('stateChanged'),
self.update_controller)
self.controller = controller
if controller:
self.connect(self.controller,
QtCore.SIGNAL('stateChanged'),
self.update_controller)
self.vt_controller.vistrail_view = self.version_result_view
self.vt_controller.current_pipeline_view = \
self.workflow_result_view.scene()
# self.vt_controller.vistrail_view.set_controller(self.vt_controller)
self.vt_controller.set_vistrail(controller.vistrail, None,
set_log_on_vt=False)
self.vt_controller.change_selected_version(controller.current_version)
self.version_result_view.set_controller(self.vt_controller)
self.workflow_result_view.set_controller(self.vt_controller)
self.query_controller.set_vistrail_controller(controller)
def update_controller(self):
self.vt_controller.set_vistrail(self.controller.vistrail, None,
set_log_on_vt=False)
self.vt_controller.change_selected_version(
self.controller.current_version)
def build_widget(self):
layout = QtGui.QVBoxLayout()
layout.setMargin(0)
layout.setSpacing(0)
self.query_controller = QueryController(self)
self.vt_controller = VistrailController(auto_save=False)
self.p_controller = VistrailController(Vistrail(), auto_save=False)
self.connect(self.p_controller,
QtCore.SIGNAL('vistrailChanged()'),
self.vistrailChanged)
self.query_box = QQueryBox()
self.query_box.set_controller(self.query_controller)
layout.addWidget(self.query_box)
self.stacked_widget = QtGui.QStackedWidget()
self.pipeline_view = QQueryPipelineView()
self.p_controller.current_pipeline_view = self.pipeline_view.scene()
self.pipeline_view.set_controller(self.p_controller)
self.pipeline_view.set_query_controller(self.query_controller)
QQueryView.VISUAL_SEARCH_VIEW = \
self.stacked_widget.addWidget(self.pipeline_view)
self.global_result_view = QQueryResultGlobalView()
QQueryView.GLOBAL_RESULT_VIEW = \
self.stacked_widget.addWidget(self.global_result_view)
self.version_result_view = QQueryResultVersionView()
self.connect(self.version_result_view.scene(),
QtCore.SIGNAL('versionSelected(int,bool,bool,bool,bool)'),
self.result_version_selected)
# self.version_result_view.set_controller(self.vt_controller)
QQueryView.VERSION_RESULT_VIEW = \
self.stacked_widget.addWidget(self.version_result_view)
self.workflow_result_view = QQueryResultWorkflowView()
# self.workflow_result_view.set_controller(self.vt_controller)
QQueryView.WORKFLOW_RESULT_VIEW = \
self.stacked_widget.addWidget(self.workflow_result_view)
self.stacked_widget.setCurrentWidget(self.pipeline_view)
layout.addWidget(self.stacked_widget)
self.setLayout(layout)
self.current_display = QQueryView.VISUAL_SEARCH_VIEW
self.current_result_view = QQueryView.VERSION_RESULT_VIEW
def set_default_layout(self):
from gui.module_palette import QModulePalette
from gui.module_info import QModuleInfo
self.set_palette_layout(
{QtCore.Qt.LeftDockWidgetArea: QModulePalette,
QtCore.Qt.RightDockWidgetArea: QModuleInfo,
})
def set_action_links(self):
self.action_links = \
{ 'execute': ('query_pipeline_changed', self.set_execute_action) }
# also add other notification here...
from gui.vistrails_window import _app
_app.register_notification('query_pipeline_changed',
self.set_reset_button)
def set_reset_button(self, pipeline):
self.query_box.setManualResetEnabled(self.pipeline_non_empty(pipeline))
def set_result_level(self, level):
view_idx = QQueryView.RESULT_LEVEL_MAP[level]
if self.current_display != QQueryView.VISUAL_SEARCH_VIEW:
self.set_display_view(view_idx)
self.current_result_view = view_idx
self.query_controller.update_results()
def set_to_search_mode(self):
self.set_display_view(QQueryView.VISUAL_SEARCH_VIEW)
self.query_box.backButton.setEnabled(False)
self.query_box.editButton.setEnabled(False)
self.set_reset_button(self.p_controller.current_pipeline)
from gui.vistrails_window import _app
_app.notify('query_pipeline_changed',
self.p_controller.current_pipeline)
def set_to_result_mode(self):
self.set_display_view(self.current_result_view)
self.query_box.backButton.setEnabled(True)
if self.query_controller.level >= QueryController.LEVEL_VISTRAIL:
self.query_box.editButton.setEnabled(True)
self.query_box.setManualResetEnabled(True)
from gui.vistrails_window import _app
_app.notify('query_pipeline_changed',
self.p_controller.current_pipeline)
def set_display_view(self, view_type):
self.current_display = view_type
self.stacked_widget.setCurrentIndex(view_type)
def get_current_view(self):
return self.stacked_widget.currentWidget()
def set_action_defaults(self):
self.action_defaults = \
{
'execute': [('setEnabled', True, self.set_execute_action),
('setIcon', False, CurrentTheme.VISUAL_QUERY_ICON),
('setToolTip', False, 'Execute a visual query')],
'publishWeb': [('setEnabled', False, False)],
'publishPaper': [('setEnabled', False, False)],
}
def set_execute_action(self, pipeline=None):
if not self.vt_controller:
return False
if pipeline is None:
pipeline = self.p_controller.current_pipeline
if self.current_display == QQueryView.VISUAL_SEARCH_VIEW:
return self.pipeline_non_empty(pipeline)
return False
def pipeline_non_empty(self, pipeline):
return pipeline is not None and len(pipeline.modules) > 0
def vistrailChanged(self):
from gui.vistrails_window import _app
self.p_controller.current_pipeline.ensure_connection_specs()
_app.notify('query_pipeline_changed', self.p_controller.current_pipeline)
def query_changed(self, query=None):
if query is None:
self.query_controller.reset_search()
# FIXME add support for changing the query to something specific
def version_changed(self, version_id):
self.vt_controller.change_selected_version(version_id)
def result_version_selected(self, version_id, by_click, do_validate=True,
from_root=False, double_click=False):
if by_click:
self.query_controller.search.setCurrentVistrail(
self.vt_controller.vistrail)
self.vt_controller.change_selected_version(version_id, by_click,
do_validate, from_root)
if double_click:
self.query_controller.set_level(QueryController.LEVEL_WORKFLOW)
self.query_controller.show_workflow_matches()
def get_vertex_map(g):
return Bidict([(v, k) for (k, v) in enumerate(g.iter_vertices())])
def get_edge_map(g):
itor = enumerate(imap(lambda x: x[2], g.iter_all_edges()))
return Bidict([(v, k) for (k, v) in itor])
class PortSpec(DBPortSpec):
port_type_map = Bidict([('input', 'destination'), ('output', 'source'),
('invalid', 'invalid')])
end_point_map = Bidict([('source', PortEndPoint.Source),
('destination', PortEndPoint.Destination),
('invalid', PortEndPoint.Invalid)])
##########################################################################
# Constructors and copy
def __init__(self, *args, **kwargs):
signature = None
if 'signature' in kwargs:
signature = kwargs['signature']
del kwargs['signature']
if 'optional' not in kwargs:
kwargs['optional'] = 0 # False
elif type(kwargs['optional']) != type(0):
if type(kwargs['optional']) == type(True):
if kwargs['optional']:
kwargs['optional'] = 1
else:
kwargs['optional'] = 0
else:
raise VistrailsInternalError("Cannot parse 'optional' kw "
"-- must be an int or bool")
if 'sort_key' not in kwargs:
kwargs['sort_key'] = -1
if 'id' not in kwargs:
kwargs['id'] = -1
if 'tooltip' in kwargs:
self._tooltip = kwargs['tooltip']
del kwargs['tooltip']
else:
self._tooltip = None
DBPortSpec.__init__(self, *args, **kwargs)
self._entries = None
self._descriptors = None
self._short_sigstring = None
self._labels = None
self._defaults = None
if signature is not None:
self.create_entries(signature)
if not self.sigstring and self._entries is not None:
# create sigstring from entries
self.create_sigstring_and_descriptors()
# DAKOOP: removed this---we will check in module_registry and pipeline
# validation, this way, we can let errors go all the way up
# elif self._entries is None and self.sigstring:
# # create entries from sigstring
# self.create_entries_and_descriptors()
# else:
# raise VistrailsInternalError("Need to specify signature or "
# "sigstring to create PortSpec")
if self._entries is not None and self._tooltip is None:
self.create_tooltip()
self.is_valid = True
def __copy__(self):
return PortSpec.do_copy(self)
def do_copy(self, new_ids=False, id_scope=None, id_remap=None):
cp = DBPortSpec.do_copy(self, new_ids, id_scope, id_remap)
cp._entries = copy.copy(self._entries)
cp._descriptors = copy.copy(self._descriptors)
cp._short_sigstring = self._short_sigstring
cp._labels = self._labels
cp._defaults = self._defaults
cp._tooltip = self._tooltip
cp.is_valid = self.is_valid
cp.__class__ = PortSpec
if cp._entries is not None:
cp.create_tooltip()
return cp
@staticmethod
def convert(_port_spec):
from core.modules.module_registry import module_registry_loaded, \
ModuleRegistryException
if _port_spec.__class__ == PortSpec:
return
_port_spec.__class__ = PortSpec
_port_spec._entries = None
_port_spec._descriptors = None
_port_spec._short_sigstring = None
_port_spec._labels = None
_port_spec._defaults = None
_port_spec._tooltip = None
_port_spec.is_valid = True
# FIXME probably can just let validation take care of this...
if module_registry_loaded():
try:
_port_spec.create_entries_and_descriptors()
_port_spec.create_tooltip()
except ModuleRegistryException, e:
_port_spec._descriptors = None
_port_spec._entries = None
# raise e
else:
