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: