def sendError(self): data = {} data['platform'] = platform.uname()[0] data['platform_version'] = platform.uname()[2] data['hashed_hostname'] = hashlib.sha1(platform.uname()[1]).hexdigest() data['hashed_username'] = hashlib.sha1(os.getlogin()).hexdigest() data['source'] = 'UV-CDAT' data['source_version'] = '1.2.1' data['description'] = self.getDescription() data['stack_trace'] = self.errorDetails.toPlainText() data['severity'] = 'FATAL' data['comments'] = self.userComments.toPlainText() if get_vistrails_configuration().output != '': fname = get_vistrails_configuration().output # read at most last 5000 chars from output log with open(fname, "r") as f: f.seek (0, 2) # Seek @ EOF fsize = f.tell() # Get Size f.seek (max (fsize-5000, 0), 0) # Set pos @ last n chars data['execution_log'] = f.read() print urlencode(data) print "http://uvcdat.llnl.gov/UVCDATUsage/log/add/error/" result = urlopen("http://uvcdat.llnl.gov/UVCDATUsage/log/add/error/", urlencode(data))
def py_import(module_name, dependency_dictionary, store_in_config=False): """Tries to import a python module, installing if necessary. If the import doesn't succeed, we guess which system we are running on and install the corresponding package from the dictionary. We then run the import again. If the installation fails, we won't try to install that same module again for the session. """ try: result = _vanilla_import(module_name) return result except ImportError: if not getattr(get_vistrails_configuration(), 'installBundles'): raise if module_name in _previously_failed_pkgs: raise PyImportException("Import of Python module '%s' failed again, " "not triggering installation" % module_name) if store_in_config: ignored_packages_list = getattr(get_vistrails_configuration(), 'bundleDeclinedList', None) if ignored_packages_list: ignored_packages = set(ignored_packages_list.split(';')) else: ignored_packages = set() if module_name in ignored_packages: raise PyImportException("Import of Python module '%s' failed " "again, installation disabled by " "configuration" % module_name) debug.warning("Import of python module '%s' failed. " "Will try to install bundle." % module_name) success = vistrails.core.bundles.installbundle.install( dependency_dictionary) if store_in_config: if bool(success): ignored_packages.discard(module_name) else: ignored_packages.add(module_name) setattr(get_vistrails_configuration(), 'bundleDeclinedList', ';'.join(sorted(ignored_packages))) setattr(get_vistrails_persistent_configuration(), 'bundleDeclinedList', ';'.join(sorted(ignored_packages))) if not success: _previously_failed_pkgs.add(module_name) raise PyImportException("Installation of Python module '%s' failed." % module_name) try: result = _vanilla_import(module_name) return result except ImportError, e: _previously_failed_pkgs.add(module_name) raise PyImportBug("Installation of package '%s' succeeded, but import " "still fails." % module_name)
def adjust_version_colors(self, controller): """ adjust_version_colors(controller: VistrailController) -> None Based on the controller to set version colors """ currentUser = controller.vistrail.getUser() ranks = {} ourMaxRank = 0 otherMaxRank = 0 am = controller.vistrail.actionMap for nodeId in sorted(self.versions.keys()): if nodeId!=0: nodeUser = am[nodeId].user if nodeUser==currentUser: ranks[nodeId] = ourMaxRank ourMaxRank += 1 else: ranks[nodeId] = otherMaxRank otherMaxRank += 1 for (nodeId, item) in self.versions.iteritems(): if nodeId == 0: item.setGhosted(True) continue nodeUser = am[nodeId].user if controller.search and nodeId!=0: action = am[nodeId] if getattr(get_vistrails_configuration(), 'hideUpgrades', True): # Use upgraded version to match action = am[controller.vistrail.get_upgrade(nodeId, False)] ghosted = not controller.search.match(controller, action) else: ghosted = False #item.setGhosted(ghosted) # we won't set it now so we can check if # the state changed in update_color if nodeUser==currentUser: max_rank = ourMaxRank else: max_rank = otherMaxRank # max_rank = ourMaxRank if nodeUser==currentUser else otherMaxRank configuration = get_vistrails_configuration() if configuration.check('customVersionColors'): custom_color = controller.vistrail.get_action_annotation( nodeId, custom_color_key) if custom_color is not None: try: custom_color = parse_custom_color(custom_color.value) except ValueError, e: debug.warning("Version %r has invalid color annotation " "(%s)" % (nodeId, e)) custom_color = None else: custom_color = None #### item.update_color(nodeUser==currentUser, ranks[nodeId], max_rank, ghosted, custom_color)
def __init__(self): d = {"prefix": "vt_tmp"} if get_vistrails_configuration().check("temporaryDirectory"): dir = get_vistrails_configuration().temporaryDirectory if os.path.exists(dir): d["dir"] = dir else: debug.critical("Temporary directory does not exist: %s" % dir) self.directory = tempfile.mkdtemp(**d) self.files = {}
def tab_changed(self, index): """ tab_changed(index: int) -> None Keep general and advanced configurations in sync """ self._configuration_tab.configuration_changed( get_vistrails_persistent_configuration(), get_vistrails_configuration()) self._general_tab.update_state( get_vistrails_persistent_configuration(), get_vistrails_configuration())
def __init__(self): d = {'prefix':'vt_tmp'} if get_vistrails_configuration().check('temporaryDir'): dir = get_vistrails_configuration().temporaryDir if os.path.exists(dir): d['dir'] = dir else: debug.critical("Temporary directory does not exist: %s" % dir) self.directory = tempfile.mkdtemp(**d) self.files = {}
def __init__(self, parent): QtGui.QDialog.__init__(self, parent) self.setWindowTitle('VisTrails Preferences') layout = QtGui.QHBoxLayout(self) layout.setMargin(0) layout.setSpacing(0) self.setLayout(layout) f = QtGui.QFrame() layout.addWidget(f) l = QtGui.QVBoxLayout(f) f.setLayout(l) self._tab_widget = QtGui.QTabWidget(f) l.addWidget(self._tab_widget) self._tab_widget.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) tabs = [("General", ["General", "Packages"]), ("Interface", ["Interface", "Startup"]), ("Paths && URLs", ["Paths", "Web Sharing"]), ("Advanced", ["Upgrades", "Thumbnails", "Advanced"]), ] for (tab_name, categories) in tabs: tab = QConfigurationPane(self, get_vistrails_persistent_configuration(), get_vistrails_configuration(), [(c, base_config[c]) for c in categories]) self._tab_widget.addTab(tab, tab_name) output_tab = QOutputConfigurationPane(self, get_vistrails_persistent_configuration(), get_vistrails_configuration()) self._tab_widget.addTab(output_tab, "Output") self._packages_tab = self.create_packages_tab() self._tab_widget.addTab(self._packages_tab, 'Packages') self._configuration_tab = self.create_configuration_tab() self._tab_widget.addTab(self._configuration_tab, 'Expert') self.connect(self._tab_widget, QtCore.SIGNAL('currentChanged(int)'), self.tab_changed) self.connect(self._configuration_tab._tree.treeWidget, QtCore.SIGNAL('configuration_changed'), self.configuration_changed)
def __init__(self, parent): QtGui.QDialog.__init__(self, parent) self.setWindowTitle('VisTrails Preferences') layout = QtGui.QHBoxLayout(self) layout.setMargin(0) layout.setSpacing(0) self.setLayout(layout) f = QtGui.QFrame() layout.addWidget(f) l = QtGui.QVBoxLayout(f) f.setLayout(l) self._tab_widget = QtGui.QTabWidget(f) l.addWidget(self._tab_widget) self._tab_widget.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) tabs = [ ("General", ["General", "Packages"]), ("Interface", ["Interface", "Startup"]), ("Paths && URLs", ["Paths", "Web Sharing"]), ("Advanced", ["Upgrades", "Thumbnails", "Advanced"]), ] for (tab_name, categories) in tabs: tab = QConfigurationPane(self, get_vistrails_persistent_configuration(), get_vistrails_configuration(), [(c, base_config[c]) for c in categories]) self._tab_widget.addTab(tab, tab_name) output_tab = QOutputConfigurationPane( self, get_vistrails_persistent_configuration(), get_vistrails_configuration()) self._tab_widget.addTab(output_tab, "Output") self._packages_tab = self.create_packages_tab() self._tab_widget.addTab(self._packages_tab, 'Packages') self._configuration_tab = self.create_configuration_tab() self._tab_widget.addTab(self._configuration_tab, 'Expert') self.connect(self._tab_widget, QtCore.SIGNAL('currentChanged(int)'), self.tab_changed) self.connect(self._configuration_tab._tree.treeWidget, QtCore.SIGNAL('configuration_changed'), self.configuration_changed)
def load_running_jobs(self): conf = configuration.get_vistrails_configuration() if conf.has('runningJobsList') and conf.runningJobsList: for url in conf.runningJobsList.split(';'): loc, version = url.split('?') locator = BaseLocator.from_url(loc) msgBox = QtGui.QMessageBox(QtGui.QMessageBox.Question, "Running Job Found", "Running Job Found:\n %s\n" "Continue now?" % url) msgBox.addButton("Later", msgBox.ActionRole) delete = msgBox.addButton("Delete", msgBox.ActionRole) yes = msgBox.addButton("Yes", msgBox.ActionRole) msgBox.exec_() if msgBox.clickedButton() == yes: from vistrails.gui.vistrails_window import _app _app.open_vistrail_without_prompt(locator, int(version.split('=')[1])) _app.get_current_view().execute() if msgBox.clickedButton() == delete: conf_jobs = conf.runningJobsList.split(';') conf_jobs.remove(url) conf.runningJobsList = ';'.join(conf_jobs) configuration.get_vistrails_persistent_configuration( ).runningJobsList = conf.runningJobsList else: conf.runningJobsList = '' configuration.get_vistrails_persistent_configuration( ).runningJobsList = conf.runningJobsList
def checkJob(self, module, id, handle): """ checkJob(module: VistrailsModule, id: str, handle: object) -> None Starts monitoring the job for the current running workflow module - the module to suspend id - the job identifier handle - an object following the JobHandle interface, i.e. with a finished method for checking if the job has completed """ if not self.currentWorkflow(): if not handle or not self.isDone(handle): raise ModuleSuspended(module, 'Job is running', handle=handle) job = self.getJob(id) if self.callback: self.callback.checkJob(module, id, handle) return conf = get_vistrails_configuration() interval = conf.jobCheckInterval if interval and not conf.jobAutorun: if handle: # wait for module to complete try: while not self.isDone(handle): time.sleep(interval) print("Waiting for job: %s," "press Ctrl+C to suspend") % job.name except KeyboardInterrupt: raise ModuleSuspended(module, 'Interrupted by user, job' ' is still running', handle=handle) else: if not handle or not self.isDone(handle): raise ModuleSuspended(module, 'Job is running', handle=handle)
def create_thumbs_tab(self): """ create_thumbs_tab() -> QThumbnailConfiguration """ return QThumbnailConfiguration(self, get_vistrails_persistent_configuration(), get_vistrails_configuration())
def create_general_tab(self): """ create_general_tab() -> QGeneralConfiguration """ return QGeneralConfiguration(self, get_vistrails_persistent_configuration(), get_vistrails_configuration())
def theFunction(src, dst): global Variant_desc, InputPort_desc if Variant_desc is None: reg = get_module_registry() Variant_desc = reg.get_descriptor_by_name( 'org.vistrails.vistrails.basic', 'Variant') InputPort_desc = reg.get_descriptor_by_name( 'org.vistrails.vistrails.basic', 'InputPort') iport = conn.destination.name oport = conn.source.name src.enableOutputPort(oport) conf = get_vistrails_configuration() error_on_others = getattr(conf, 'errorOnConnectionTypeerror') error_on_variant = (error_on_others or getattr(conf, 'errorOnVariantTypeerror')) errors = [error_on_others, error_on_variant] if isinstance(src, InputPort_desc.module): typecheck = [False] else: typecheck = [errors[desc is Variant_desc] for desc in conn.source.spec.descriptors()] dst.set_input_port( iport, ModuleConnector(src, oport, conn.destination.spec, typecheck))
def checkJob(self, module, id, monitor): """ checkJob(module: VistrailsModule, id: str, monitor: instance) -> None Starts monitoring the job for the current running workflow module - the module to suspend id - the job identifier monitor - a class instance with a finished method for checking if the job has completed """ if not self.currentWorkflow(): if not monitor or not self.isDone(monitor): raise ModuleSuspended(module, 'Job is running', queue=monitor, job_id=id) job = self.getJob(id) if self.callback: self.callback.checkJob(module, id, monitor) return conf = get_vistrails_configuration() interval = conf.jobCheckInterval if interval and not conf.jobAutorun: if monitor: # wait for module to complete try: while not self.isDone(monitor): time.sleep(interval) print ("Waiting for job: %s," "press Ctrl+C to suspend") % job.name except KeyboardInterrupt, e: raise ModuleSuspended(module, 'Interrupted by user, job' ' is still running', queue=monitor, job_id=id)
def compute(self): vt_configuration = get_vistrails_configuration() if not getattr(vt_configuration, 'interactiveMode', False): self.set_output('result', True) return cell = self.get_input('cell') label = self.force_get_input('label', None) # FIXME : This should be done via the spreadsheet, removing it properly # and then sending a new DisplayCellEvent # However, there is currently no facility to remove the widget from # wherever it is oldparent = cell.parent() assert isinstance(oldparent, QCellContainer) ncell = oldparent.takeWidget() assert ncell == cell dialog = PromptWindow(cell, label) result = dialog.exec_() == QtGui.QDialog.Accepted oldparent.setWidget(cell) self.set_output('result', result) if not result and not self.get_input('carry_on'): raise ModuleError(self, "Execution aborted")
def current_dot_vistrails(): """ current_dot_vistrails() -> str Returns the VisTrails per-user directory. """ from vistrails.core.configuration import get_vistrails_configuration return get_vistrails_configuration().dotVistrails
def checkJob(self, module, id, handle): """ checkJob(module: VistrailsModule, id: str, handle: object) Callback, checks if job has completed. """ workflow = self.jobMonitor.currentWorkflow() if not workflow: if not handle or not self.jobMonitor.isDone(handle): raise ModuleSuspended(module, 'Job is running', handle=handle) workflow_item = self.workflowItems[workflow.id] item = workflow_item.jobs.get(id, None) item.setText(0, item.job.name) # we should check the status using the JobHandle and show dialog # get current view progress bar and hijack it if handle: item.handle = handle workflow = self.jobMonitor.currentWorkflow() workflow_item = self.workflowItems.get(workflow.id, None) workflow_item.updateJobs() progress = self.controller.progress conf = configuration.get_vistrails_configuration() interval = conf.jobCheckInterval if interval and not conf.jobAutorun and not progress.suspended: # we should keep checking the job if handle: # wait for module to complete labelText = (("Running external job %s\n" "Started %s\n" "Press Cancel to suspend") % (item.job.name, item.job.start)) progress.setLabelText(labelText) while not self.jobMonitor.isDone(handle): i = 0 while i < interval: i += 1 time.sleep(1) QtCore.QCoreApplication.processEvents() if progress.wasCanceled(): # this does not work, need to create a new progress dialog #progress.goOn() new_progress = progress.__class__( progress.parent()) new_progress.setMaximum(progress.maximum()) new_progress.setValue(progress.value()) new_progress.setLabelText(labelText) new_progress.setMinimumDuration(0) new_progress.suspended = True self.controller.progress = new_progress progress.hide() progress.deleteLater() progress = new_progress progress.show() QtCore.QCoreApplication.processEvents() raise ModuleSuspended(module, 'Interrupted by user, job' ' is still running', handle=handle) return if not handle or not self.jobMonitor.isDone(handle): raise ModuleSuspended(module, 'Job is running', handle=handle)
def py_import(module_name, dependency_dictionary): """Tries to import a python module, installing if necessary. If the import doesn't succeed, we guess which system we are running on and install the corresponding package from the dictionary. We then run the import again. If the installation fails, we won't try to install that same module again for the session. """ try: result = _vanilla_import(module_name) return result except ImportError: if not getattr(get_vistrails_configuration(), 'installBundles'): raise if module_name in _previously_failed_pkgs: raise PyImportException("Import of Python module '%s' failed again, " "not triggering installation" % module_name) debug.warning("Import of python module '%s' failed. " "Will try to install bundle." % module_name) success = vistrails.core.bundles.installbundle.install(dependency_dictionary) if not success: _previously_failed_pkgs.add(module_name) raise PyImportException("Installation of Python module '%s' failed." % module_name) try: result = _vanilla_import(module_name) return result except ImportError, e: _previously_failed_pkgs.add(module_name) raise PyImportBug("Installation of package '%s' succeeded, but import " "still fails." % module_name)
def write(self, s): """write(s) -> None adds the string s to the message list and displays it """ # adds the string s to the list and s = s.strip() msgs = s.split('\n') if len(msgs) <= 3: msgs.append('Error logging message: invalid log format') s += '\n' + msgs[3] if not len(msgs[3].strip()): msgs[3] = "Unknown Error" s = '\n'.join(msgs) text = msgs[3] item = QtGui.QListWidgetItem(text) item.setData(32, s) item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEditable) self.list.addItem(item) item.setForeground(CurrentTheme.DEBUG_COLORS[msgs[0]]) self.list.setItemHidden(item, not self.levels[msgs[0]].isChecked()) alwaysShowDebugPopup = getattr(get_vistrails_configuration(), 'showDebugPopups', False) if msgs[0] == 'CRITICAL': if self.isVisible() and not alwaysShowDebugPopup: self.raise_() self.activateWindow() modal = get_vistrails_application().activeModalWidget() if modal: # need to beat modal window self.showMessageBox(item) else: self.showMessageBox(item)
def addButtonsToToolbar(self): # button for toggling executions eye_open_icon = \ QtGui.QIcon(os.path.join(vistrails_root_directory(), 'gui/resources/images/eye.png')) self.portVisibilityAction = QtGui.QAction( eye_open_icon, "Show/hide port visibility toggle buttons", None, triggered=self.showPortVisibility) self.portVisibilityAction.setCheckable(True) self.portVisibilityAction.setChecked(True) self.toolWindow().toolbar.insertAction(self.toolWindow().pinAction, self.portVisibilityAction) self.showTypesAction = QtGui.QAction(letterIcon('T'), "Show/hide type information", None, triggered=self.showTypes) self.showTypesAction.setCheckable(True) self.showTypesAction.setChecked(True) self.toolWindow().toolbar.insertAction(self.toolWindow().pinAction, self.showTypesAction) self.showEditsAction = QtGui.QAction(QtGui.QIcon( os.path.join(vistrails_root_directory(), 'gui/resources/images/pencil.png')), "Show/hide parameter widgets", None, triggered=self.showEdits) self.showEditsAction.setCheckable(True) self.showEditsAction.setChecked( get_vistrails_configuration().check('showInlineParameterWidgets')) self.toolWindow().toolbar.insertAction(self.toolWindow().pinAction, self.showEditsAction)
def checkJob(self, module, id, handle): """ checkJob(module: VistrailsModule, id: str, handle: object) -> None Starts monitoring the job for the current running workflow module - the module to suspend id - the job identifier handle - an object following the JobHandle interface, i.e. with a finished method for checking if the job has completed """ if not self.currentWorkflow(): if not handle or not self.isDone(handle): raise ModuleSuspended(module, 'Job is running', handle=handle) job = self.getJob(id) if self.callback: self.callback.checkJob(module, id, handle) return conf = get_vistrails_configuration() interval = conf.jobCheckInterval if interval and not conf.jobAutorun: if handle: # wait for module to complete try: while not self.isDone(handle): time.sleep(interval) print ("Waiting for job: %s," "press Ctrl+C to suspend") % job.name except KeyboardInterrupt: raise ModuleSuspended(module, 'Interrupted by user, job' ' is still running', handle=handle) else: if not handle or not self.isDone(handle): raise ModuleSuspended(module, 'Job is running', handle=handle)
def getResultEntity(self, controller, versions_to_check): from vistrails.core.collection.vistrail import VistrailEntity vistrail_entity = None for version in versions_to_check: if version in controller.vistrail.actionMap: action = controller.vistrail.actionMap[version] if getattr(get_vistrails_configuration(), 'hideUpgrades', True): # Use upgraded version to match action = controller.vistrail.actionMap[ controller.vistrail.get_upgrade(action.id, False)] if self.match(controller, action): # have a match, get vistrail entity if vistrail_entity is None: vistrail_entity = VistrailEntity() # don't want to add all workflows, executions vistrail_entity.set_vistrail(controller.vistrail) # only tagged versions should be displayed in the workspace tagged_version = controller.get_tagged_version(version) vistrail_entity.add_workflow_entity(tagged_version) # FIXME this is not done at the low level but in # Collection class, probably should be reworked vistrail_entity.wf_entity_map[tagged_version].parent = \ vistrail_entity return vistrail_entity
def write(self, s): """write(s) -> None adds the string s to the message list and displays it """ # adds the string s to the list and s = s.strip() msgs = s.split("\n") if len(msgs) <= 3: msgs.append("Error logging message: invalid log format") s += "\n" + msgs[3] if not len(msgs[3].strip()): msgs[3] = "Unknown Error" s = "\n".join(msgs) text = msgs[3] item = QtGui.QListWidgetItem(text) item.setData(32, s) item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEditable) self.list.addItem(item) item.setForeground(CurrentTheme.DEBUG_COLORS[msgs[0]]) self.list.setItemHidden(item, not self.levels[msgs[0]].isChecked()) alwaysShowDebugPopup = getattr(get_vistrails_configuration(), "alwaysShowDebugPopup", False) if msgs[0] == "CRITICAL": if self.isVisible() and not alwaysShowDebugPopup: self.raise_() self.activateWindow() modal = get_vistrails_application().activeModalWidget() if modal: # need to beat modal window self.showMessageBox(item) else: self.showMessageBox(item)
def checkJob(self, module, id, monitor): """ checkJob(module: VistrailsModule, id: str, monitor: instance) Callback, checks if job has completed. """ workflow = self.jobMonitor.currentWorkflow() if not workflow: if not monitor or not self.jobMonitor.isDone(monitor): raise ModuleSuspended(module, 'Job is running', monitor=monitor) workflow_item = self.workflowItems[workflow.id] item = workflow_item.jobs.get(id, None) item.setText(0, item.job.name) # we should check the status using monitor and show dialog # get current view progress bar and hijack it if monitor: item.monitor = monitor workflow = self.jobMonitor.currentWorkflow() workflow_item = self.workflowItems.get(workflow.id, None) workflow_item.updateJobs() progress = self.controller.progress conf = configuration.get_vistrails_configuration() interval = conf.jobCheckInterval if interval and not conf.jobAutorun and not progress.suspended: # we should keep checking the job if monitor: # wait for module to complete labelText = (("Running external job %s\n" "Started %s\n" "Press Cancel to suspend") % (item.job.name, item.job.start)) progress.setLabelText(labelText) while not self.jobMonitor.isDone(monitor): i = 0 while i < interval: i += 1 time.sleep(1) QtCore.QCoreApplication.processEvents() if progress.wasCanceled(): # this does not work, need to create a new progress dialog #progress.goOn() new_progress = progress.__class__(progress.parent()) new_progress.setMaximum(progress.maximum()) new_progress.setValue(progress.value()) new_progress.setLabelText(labelText) new_progress.setMinimumDuration(0) new_progress.suspended = True self.controller.progress = new_progress progress.hide() progress.deleteLater() progress = new_progress progress.show() QtCore.QCoreApplication.processEvents() raise ModuleSuspended(module, 'Interrupted by user, job' ' is still running', monitor=monitor) return if not monitor or not self.jobMonitor.isDone(monitor): raise ModuleSuspended(module, 'Job is running', monitor=monitor)
def addButtonsToToolbar(self): # button for toggling executions eye_open_icon = \ QtGui.QIcon(os.path.join(vistrails_root_directory(), 'gui/resources/images/eye.png')) self.portVisibilityAction = QtGui.QAction(eye_open_icon, "Show/hide port visibility toggle buttons", None, triggered=self.showPortVisibility) self.portVisibilityAction.setCheckable(True) self.portVisibilityAction.setChecked(True) self.toolWindow().toolbar.insertAction(self.toolWindow().pinAction, self.portVisibilityAction) self.showTypesAction = QtGui.QAction(letterIcon('T'), "Show/hide type information", None, triggered=self.showTypes) self.showTypesAction.setCheckable(True) self.showTypesAction.setChecked(True) self.toolWindow().toolbar.insertAction(self.toolWindow().pinAction, self.showTypesAction) self.showEditsAction = QtGui.QAction( QtGui.QIcon(os.path.join(vistrails_root_directory(), 'gui/resources/images/pencil.png')), "Show/hide parameter widgets", None, triggered=self.showEdits) self.showEditsAction.setCheckable(True) self.showEditsAction.setChecked( get_vistrails_configuration().check('showInlineParameterWidgets')) self.toolWindow().toolbar.insertAction(self.toolWindow().pinAction, self.showEditsAction)
def __init__(self, registry, startup): """__init__(configuration: ConfigurationObject) -> PackageManager configuration is the persistent configuration object of the application. """ global _package_manager if _package_manager: m = "Package manager can only be constructed once." raise VistrailsInternalError(m) _package_manager = self self._registry = registry self._startup = startup # Contains packages that have not yet been enabled, but exist on the # filesystem self._available_packages = {} # codepath: str -> Package # These other lists contain enabled packages self._package_list = {} # codepath: str -> Package self._package_versions = {} # identifier: str -> version -> Package self._old_identifier_map = {} # old_id: str -> new_id: str self._dependency_graph = vistrails.core.data_structures.graph.Graph() self._default_prefix_dict = { "basic_modules": "vistrails.core.modules.", "abstraction": "vistrails.core.modules.", } self._userpackages = None self._packages = None self._abstraction_pkg = None self._currently_importing_package = None # Setup a global __import__ hook that calls Package#import_override() # for all imports executed from that package import __builtin__ self._orig_import = __builtin__.__import__ __builtin__.__import__ = self._import_override # Compute the list of available packages, _available_packages self.build_available_package_names_list() if get_vistrails_configuration().loadPackages: for pkg in self._startup.enabled_packages.itervalues(): self.add_package(pkg.name, prefix=pkg.prefix) else: try: basic_pkg = self._startup.enabled_packages["basic_modules"] except KeyError: pass else: self.add_package(basic_pkg.name, prefix=basic_pkg.prefix) try: abs_pkg = self._startup.enabled_packages["abstraction"] except KeyError: pass else: self.add_package(abs_pkg.name, prefix=abs_pkg.prefix)
def __init__(self): self.elements = {} self.vtelements = {} self.conf = None conf = get_vistrails_configuration() if conf.has('thumbs'): self.conf = conf.thumbs self.init_cache()
def update_controller(self): # FIXME Need to figure out how to deal with this !!! self.vt_controller.set_vistrail(self.controller.vistrail, None, set_log_on_vt=False) hide_upgrades = getattr(get_vistrails_configuration(), 'hideUpgrades', True) self.vt_controller.change_selected_version(self.controller.current_version, hide_upgrades, hide_upgrades)
def __init__(self, registry, startup): """__init__(configuration: ConfigurationObject) -> PackageManager configuration is the persistent configuration object of the application. """ global _package_manager if _package_manager: m = "Package manager can only be constructed once." raise VistrailsInternalError(m) _package_manager = self self._registry = registry self._startup = startup # Contains packages that have not yet been enabled, but exist on the # filesystem self._available_packages = {} # codepath: str -> Package # These other lists contain enabled packages self._package_list = {} # codepath: str -> Package self._package_versions = {} # identifier: str -> version -> Package self._old_identifier_map = {} # old_id: str -> new_id: str self._dependency_graph = vistrails.core.data_structures.graph.Graph() self._default_prefix_dict = \ {'basic_modules': 'vistrails.core.modules.', 'abstraction': 'vistrails.core.modules.'} self._userpackages = None self._packages = None self._abstraction_pkg = None self._currently_importing_package = None # Setup a global __import__ hook that calls Package#import_override() # for all imports executed from that package import __builtin__ self._orig_import = __builtin__.__import__ __builtin__.__import__ = self._import_override # Compute the list of available packages, _available_packages self.build_available_package_names_list() if get_vistrails_configuration().loadPackages: for pkg in self._startup.enabled_packages.itervalues(): self.add_package(pkg.name, prefix=pkg.prefix) else: try: basic_pkg = self._startup.enabled_packages['basic_modules'] except KeyError: pass else: self.add_package(basic_pkg.name, prefix=basic_pkg.prefix) try: abs_pkg = self._startup.enabled_packages['abstraction'] except KeyError: pass else: self.add_package(abs_pkg.name, prefix=abs_pkg.prefix)
def update_controller(self): # FIXME Need to figure out how to deal with this !!! self.vt_controller.set_vistrail(self.controller.vistrail, None, set_log_on_vt=False) hide_upgrades = getattr(get_vistrails_configuration(), 'hideUpgrades', True) self.vt_controller.change_selected_version( self.controller.current_version, hide_upgrades, hide_upgrades)
def __init__(self): self._temp_directory = None self.elements = {} self.vtelements = {} self.conf = None conf = get_vistrails_configuration() if conf.has('thumbs'): self.conf = conf.thumbs self.init_cache()
def require_python_module(module_name, dep_dict=None): exists = python_module_exists(module_name) if (not exists and dep_dict and getattr(get_vistrails_configuration(), 'installBundles')): vistrails.core.bundles.installbundle.install(dep_dict) exists = python_module_exists(module_name) if not exists: raise MissingRequirement(module_name)
def current_dot_vistrails(conf=None): """ current_dot_vistrails() -> str Returns the VisTrails per-user directory. """ if conf is None: from vistrails.core.configuration import get_vistrails_configuration conf = get_vistrails_configuration() return conf.dotVistrails
def tab_changed(self, index): """ tab_changed(index: int) -> None Keep general and advanced configurations in sync """ # FIXME Need to fix this self._configuration_tab.configuration_changed( get_vistrails_persistent_configuration(), get_vistrails_configuration())
def unload(self): for path in self.py_dependencies: if path not in sys.modules: pass elif not getattr(get_vistrails_configuration(), 'dontUnloadModules', False): debug.debug("deleting from sys.modules: %s" % path) del sys.modules[path] self.py_dependencies.clear() self._loaded = False
def checkJob(self, module, id, handle): """ checkJob(module: VistrailsModule, id: str, handle: object) Callback, checks if job has completed. """ workflow = self.jobMonitor.currentWorkflow() if not workflow: if not self.jobMonitor.isDone(handle): raise ModuleSuspended(module, 'Job is running', handle=handle) workflow_item = self.workflowItems[workflow.id] item = workflow_item.jobs.get(id, None) item.setText(0, item.job.name) # we should check the status using the JobHandle and show dialog # get current view progress bar and hijack it item.handle = handle workflow = self.jobMonitor.currentWorkflow() workflow_item = self.workflowItems.get(workflow.id, None) workflow_item.updateJobs() progress = self.controller.progress conf = get_vistrails_configuration() interval = conf.jobCheckInterval if interval and not conf.jobAutorun and not progress.suspended: # wait for module to complete labelText = (("Running external job %s\n" "Started %s\n" "Press Cancel to suspend") % (item.job.name, item.job.start)) progress.setLabelText(labelText) while not self.jobMonitor.isDone(handle): dieTime = QtCore.QDateTime.currentDateTime().addSecs(interval) while QtCore.QDateTime.currentDateTime() < dieTime: QtCore.QCoreApplication.processEvents(QtCore.QEventLoop.AllEvents, 100) if progress.wasCanceled(): # this does not work, need to create a new progress dialog #progress.goOn() new_progress = progress.__class__(progress.parent()) new_progress.setMaximum(progress.maximum()) new_progress.setValue(progress.value()) new_progress.setLabelText(labelText) new_progress.setMinimumDuration(0) new_progress.suspended = True self.controller.progress = new_progress progress.hide() progress.deleteLater() progress = new_progress progress.show() QtCore.QCoreApplication.processEvents() raise ModuleSuspended(module, 'Interrupted by user, job' ' is still running', handle=handle) return if not self.jobMonitor.isDone(handle): raise ModuleSuspended(module, 'Job is running', handle=handle)
def adjust_version_colors(self, controller): """ adjust_version_colors(controller: VistrailController) -> None Based on the controller to set version colors """ currentUser = controller.vistrail.getUser() ranks = {} ourMaxRank = 0 otherMaxRank = 0 am = controller.vistrail.actionMap for nodeId in sorted(self.versions.keys()): if nodeId!=0: nodeUser = am[nodeId].user if nodeUser==currentUser: ranks[nodeId] = ourMaxRank ourMaxRank += 1 else: ranks[nodeId] = otherMaxRank otherMaxRank += 1 for (nodeId, item) in self.versions.iteritems(): if nodeId == 0: item.setGhosted(True) continue nodeUser = am[nodeId].user if controller.search and nodeId!=0: ghosted = not controller.search.match(controller.vistrail, am[nodeId]) else: ghosted = False #item.setGhosted(ghosted) # we won't set it now so we can check if # the state changed in update_color if nodeUser==currentUser: max_rank = ourMaxRank else: max_rank = otherMaxRank # max_rank = ourMaxRank if nodeUser==currentUser else otherMaxRank configuration = get_vistrails_configuration() if configuration.check('enableCustomVersionColors'): custom_color = controller.vistrail.get_action_annotation( nodeId, custom_color_key) if custom_color is not None: try: custom_color = parse_custom_color(custom_color.value) except ValueError, e: debug.warning("Version %r has invalid color annotation " "(%s)" % (nodeId, e)) custom_color = None else: custom_color = None #### item.update_color(nodeUser==currentUser, ranks[nodeId], max_rank, ghosted, custom_color)
def createDetachedViews(self): """ createDetachedViews() -> None Create a set of QStackedWidget for displaying detached views based on the input configuration """ if getattr(get_vistrails_configuration(), 'detachHistoryView'): self.historyView = QDetachedView('History View') self.historyView.show() else: self.historyView = None
def get_vistrails_directory(config_key, conf=None): if conf is None: from vistrails.core.configuration import get_vistrails_configuration conf = get_vistrails_configuration() if conf.has_deep_value(config_key): d = conf.get_deep_value(config_key) if os.path.isabs(d): return d else: return os.path.join(current_dot_vistrails(conf), d) return None
def get_save_file_locator_from_gui(parent, obj_type, locator=None): # Ignore current locator for now # In the future, use locator to guide GUI for better starting directory suffixes = "*" + " *".join(suffix_map[obj_type]) fileName = QtGui.QFileDialog.getSaveFileName( parent, "Save Vistrail...", vistrails.core.system.vistrails_file_directory(), filter="VisTrails files (%s)" % suffixes, # filetypes.strip() options=QtGui.QFileDialog.DontConfirmOverwrite) if not fileName: return None f = str(QtCore.QFile.encodeName(fileName)) # check for proper suffix found_suffix = False for suffix in suffix_map[obj_type]: if f.endswith(suffix): found_suffix = True break if not found_suffix: if obj_type == 'vistrail': f += get_vistrails_configuration().defaultFileType else: f += suffix_map[obj_type][0] if os.path.isfile(f): msg = QtGui.QMessageBox(QtGui.QMessageBox.Question, "VisTrails", "File exists. Overwrite?", (QtGui.QMessageBox.Yes | QtGui.QMessageBox.No), parent) if msg.exec_() == QtGui.QMessageBox.No: return None dirName = os.path.dirname(f) setattr(get_vistrails_persistent_configuration(), 'fileDir', dirName) setattr(get_vistrails_configuration(), 'fileDir', dirName) vistrails.core.system.set_vistrails_file_directory(dirName) return FileLocator(f)
def match(self, controller, action): version = action.timestep from vistrails.core.configuration import get_vistrails_configuration hide_upgrades = getattr(get_vistrails_configuration(), 'hideUpgrades', True) if hide_upgrades: version = controller.create_upgrade(version, delay_update=True) p = controller.get_pipeline(version, do_validate=False) for module in p.modules.itervalues(): if self._content_matches(module.name): return True return False
def setUpClass(cls): get_vistrails_configuration().jobAutorun = True get_vistrails_persistent_configuration().jobAutorun = True QJobView.instance().set_refresh() cls.filename = (vistrails.core.system.vistrails_root_directory() + '/tests/resources/jobs.vt') pm = vistrails.core.packagemanager.get_package_manager() if pm.has_package('org.vistrails.vistrails.myjobs'): return d = {'myjob': 'vistrails.tests.resources.'} pm.late_enable_package('myjob', d)
def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.timer_id = None self.updating_now = False self.widgets = {} self.layout = QtGui.QVBoxLayout() buttonsLayout = QtGui.QHBoxLayout() run_now = QDockPushButton("Check selected") run_now.setToolTip("Check selected job now") run_now.clicked.connect(self.check_selected_job) buttonsLayout.addWidget(run_now) run_all = QDockPushButton("Check all") run_all.setToolTip("Check all jobs now") run_all.clicked.connect(self.timerEvent) buttonsLayout.addWidget(run_all) label = QtGui.QLabel('Refresh interval (seconds):') buttonsLayout.addWidget(label) self.interval = QtGui.QComboBox() for text, seconds in refresh_states: self.interval.addItem(text, seconds) self.interval.setCompleter(None) self.interval.setEditable(True) self.interval.editTextChanged.connect(self.set_refresh) self.interval.setValidator(QNumberValidator()) conf = get_vistrails_configuration() self.interval.setEditText(str(conf.jobCheckInterval)) buttonsLayout.addWidget(self.interval) self.autorun = QtGui.QCheckBox("Automatic re-execution") self.autorun.setToolTip("Automatically re-execute workflow when jobs " "complete") self.connect(self.autorun, QtCore.SIGNAL('toggled(bool)'), self.autorunToggled) self.autorun.setChecked(conf.jobAutorun) buttonsLayout.addWidget(self.autorun) buttonsLayout.addStretch(1) self.layout.addLayout(buttonsLayout) self.jobView = QJobTree() self.jobView.itemDoubleClicked.connect(self.item_clicked) self.layout.addWidget(self.jobView) self.setLayout(self.layout) self.setWindowTitle('Running Jobs') self.resize(QtCore.QSize(800, 600))
def run(self, controller, name): reportusage.record_feature('visualquery', controller) result = [] self.tupleLength = 2 for version in self.versions_to_check: from vistrails.core.configuration import get_vistrails_configuration hide_upgrades = getattr(get_vistrails_configuration(), 'hideUpgrades', True) if hide_upgrades: version = controller.create_upgrade(version, delay_update=True) p = controller.get_pipeline(version, do_validate=False) matches = set() queryModuleNameIndex = {} for moduleId, module in p.modules.iteritems(): append_to_dict_of_lists(queryModuleNameIndex, module.name, moduleId) for querySourceId in self.queryPipeline.graph.sources(): querySourceName = self.queryPipeline.modules[ querySourceId].name if not queryModuleNameIndex.has_key(querySourceName): # need to reset matches here! matches = set() continue candidates = queryModuleNameIndex[querySourceName] atLeastOneMatch = False for candidateSourceId in candidates: querySource = self.queryPipeline.modules[querySourceId] candidateSource = p.modules[candidateSourceId] if not self.matchQueryModule(candidateSource, querySource): continue (match, targetIds) = self.heuristicDAGIsomorphism \ (template = self.queryPipeline, target = p, template_ids = [querySourceId], target_ids = [candidateSourceId]) if match: atLeastOneMatch = True matches.update(targetIds) # We always perform AND operation if not atLeastOneMatch: matches = set() break for m in matches: result.append((version, m)) self.queryResult = result self.computeIndices() return result
def change_configuration(self, item, col): if item.flags() & QtCore.Qt.ItemIsEditable: new_value = self.indexFromItem(item, col).data() item.change_value(new_value) # option-specific code if item._name == 'dbDefault': # Update the state of the icons if changing between db and # file support dbState = getattr(get_vistrails_configuration(), 'dbDefault') if new_value != dbState: from vistrails.gui.vistrails_window import _app _app.setDBDefault(dbState) self.emit(QtCore.SIGNAL('configuration_changed'), item, new_value)
def get_load_file_locator_from_gui(parent, obj_type): suffixes = "*" + " *".join(suffix_map[obj_type]) fileName = QtGui.QFileDialog.getOpenFileName( parent, "Open %s..." % obj_type.capitalize(), vistrails.core.system.vistrails_file_directory(), "VisTrails files (%s)\nOther files (*)" % suffixes) if not fileName: return None filename = os.path.abspath(str(QtCore.QFile.encodeName(fileName))) dirName = os.path.dirname(filename) setattr(get_vistrails_persistent_configuration(), 'fileDir', dirName) setattr(get_vistrails_configuration(), 'fileDir', dirName) vistrails.core.system.set_vistrails_file_directory(dirName) return FileLocator(filename)
def updateVersion(self, versionNumber): """ updateVersion(versionNumber: int) -> None Update the property page of the version """ self.versionNumber = versionNumber self.versionNotes.updateVersion(versionNumber) self.versionThumbs.updateVersion(versionNumber) self.versionMashups.updateVersion(versionNumber) if self.controller: vistrail = self.controller.vistrail if self.use_custom_colors: custom_color = vistrail.get_action_annotation( versionNumber, custom_color_key) if custom_color is not None: try: custom_color = parse_custom_color(custom_color.value) custom_color = QtGui.QColor(*custom_color) except ValueError, e: debug.warning("Version %r has invalid color " "annotation (%s)" % (versionNumber, e)) custom_color = None self.customColor.setColor(custom_color) if vistrail.actionMap.has_key(versionNumber): # Follow upgrades forward to find tag tag = self.controller.get_tag(versionNumber) if getattr(get_vistrails_configuration(), 'hideUpgrades', True): base_ver = vistrail.get_base_upgrade_version(versionNumber) else: base_ver = versionNumber action = vistrail.actionMap[base_ver] self.tagEdit.setText(tag) self.userEdit.setText(action.user) self.dateEdit.setText(action.date) if base_ver != versionNumber: version_text = '%s (%s)' % (versionNumber, base_ver) else: version_text = '%s' % base_ver self.idEdit.setText(version_text) self.tagEdit.setEnabled(True) return else: self.tagEdit.setEnabled(False) self.tagReset.setEnabled(False)
def unexpected_exception(e, tb=None, frame=None): """Marks an exception that we might want to debug. Before logging an exception or showing a message (potentially with format_exception()), you might want to call this. It's a no-op unless debugging is enabled in the configuration, in which case it will start a debugger. """ if tb is None: tb = sys.exc_info()[2] if frame is None: tb_it = tb while tb_it.tb_next is not None: tb_it = tb_it.tb_next frame = tb_it.tb_frame # Whether to use the debugger try: from vistrails.core.configuration import get_vistrails_configuration debugger = getattr(get_vistrails_configuration(), 'developerDebugger', False) except Exception: debugger = False if not debugger: return # Removes PyQt's input hook try: from PyQt4 import QtCore except ImportError: pass else: QtCore.pyqtRemoveInputHook() # Prints the exception and traceback print >>sys.stderr, "!!!!!!!!!!" print >>sys.stderr, "Got unexpected exception, starting debugger" print_exception(None, e, tb, 3, file=sys.stderr) # Starts the debugger print >>sys.stderr, "!!!!!!!!!!" # pdb.post_mortem() p = pdb.Pdb() p.reset() p.interaction(frame, tb)
def require_python_module(module_name, dep_dict=None): """Fail if the given Python module isn't importable and can't be installed. This raises `MissingRequirements` and is thus suitable for use in a package's `package_requirements()` function. If `dep_dict` is provided, it will try to install the requirement before failing, using :func:`~vistrails.core.bundles.installbundle.install`. :raises MissingRequirement: on error """ exists = python_module_exists(module_name) if (not exists and dep_dict and getattr(get_vistrails_configuration(), 'installBundles')): vistrails.core.bundles.installbundle.install(dep_dict) exists = python_module_exists(module_name) if not exists: raise MissingRequirement(module_name)
def result_version_selected(self, version_id, by_click, do_validate=True, from_root=False, double_click=False): if by_click: hide_upgrades = getattr(get_vistrails_configuration(), 'hideUpgrades', True) self.query_controller.search.setCurrentController( self.vt_controller) self.vt_controller.change_selected_version(version_id, hide_upgrades, hide_upgrades, from_root) if double_click: self.query_controller.set_level(QueryController.LEVEL_WORKFLOW) self.query_controller.show_workflow_matches()
def package_dependencies(): import vistrails.core.packagemanager manager = vistrails.core.packagemanager.get_package_manager() reg = vistrails.core.modules.module_registry.get_module_registry() conf = get_vistrails_configuration() abstraction_dir = get_vistrails_directory("subworkflowsDir") if abstraction_dir is None: debug.log("Subworkflows directory unset, cannot add any abstractions") return [] p = re.compile(r".*\.xml") all_packages = set() for abstraction in os.listdir(abstraction_dir): if p.match(abstraction): abs_fname = os.path.join(abstraction_dir, abstraction) vistrail = read_vistrail(abs_fname) try: dependencies = get_abstraction_dependencies(vistrail) except vistrails.core.modules.module_registry.MissingPackage, e: dependencies = {e._identifier: set()} add_abstraction = True inter_depends = [] for package, depends in dependencies.iteritems(): if package != identifier: if not manager.has_package(package): add_abstraction = False break else: inter_depends.append(depends) if add_abstraction: # print 'adding', abstraction[:-4] all_packages.update(p for p in dependencies.iterkeys() if p != identifier) my_vistrails[abstraction[:-4]] = \ (vistrail, abs_fname, inter_depends) else: debug.critical( ("Subworkflow '%s' is missing packages it " + "depends on") % abstraction)