def run_and_get_results(w_list, parameters='', output_dir=None, update_vistrail=True, extra_info=None, reason='Console Mode Execution'): """run_and_get_results(w_list: list of (locator, version), parameters: str, output_dir:str, update_vistrail: boolean, extra_info:dict) Run all workflows in w_list, and returns an interpreter result object. version can be a tag name or a version id. """ elements = parameters.split("$&$") aliases = {} params = [] result = [] for locator, workflow in w_list: (v, abstractions , thumbnails, mashups) = load_vistrail(locator) controller = VistrailController(v, locator, abstractions, thumbnails, mashups, auto_save=update_vistrail) if isinstance(workflow, basestring): version = v.get_version_number(workflow) elif isinstance(workflow, (int, long)): version = workflow elif workflow is None: version = controller.get_latest_version_in_graph() else: msg = "Invalid version tag or number: %s" % workflow raise VistrailsInternalError(msg) controller.change_selected_version(version) for e in elements: pos = e.find("=") if pos != -1: key = e[:pos].strip() value = e[pos+1:].strip() if controller.current_pipeline.has_alias(key): aliases[key] = value elif 'mashup_id' in extra_info: # new-style mashups can have aliases not existing in pipeline for mashuptrail in mashups: if mashuptrail.vtVersion == version: mashup = mashuptrail.getMashup(extra_info['mashup_id']) c = mashup.getAliasByName(key).component params.append((c.vttype, c.vtid, value)) if output_dir is not None and controller.current_pipeline is not None: # FIXME DAK: why is this always done?!? there is a flag for it... if is_running_gui(): controller.updatePipelineScene() base_fname = "%s_%s_pipeline.pdf" % (locator.short_filename, version) filename = os.path.join(output_dir, base_fname) controller.current_pipeline_scene.saveToPDF(filename) else: debug.critical("Cannot save pipeline figure when not " "running in gui mode") base_fname = "%s_%s_pipeline.xml" % (locator.short_filename, version) filename = os.path.join(output_dir, base_fname) vistrails.core.db.io.save_workflow(controller.current_pipeline, filename) if not update_vistrail: conf = get_vistrails_configuration() if conf.has('thumbs'): conf.thumbs.autoSave = False jobMonitor = controller.jobMonitor current_workflow = jobMonitor.currentWorkflow() if not current_workflow: for job in jobMonitor.workflows.itervalues(): try: job_version = int(job.version) except ValueError: job_version = v.get_version_number(job.version) if version == job_version: current_workflow = job jobMonitor.startWorkflow(job) if not current_workflow: current_workflow = JobWorkflow(version) jobMonitor.startWorkflow(current_workflow) try: (results, _) = \ controller.execute_current_workflow(custom_aliases=aliases, custom_params=params, extra_info=extra_info, reason=reason) finally: jobMonitor.finishWorkflow() new_version = controller.current_version if new_version != version: debug.log("Version '%s' (%s) was upgraded. The actual " "version executed was %s" % ( workflow, version, new_version)) run = results[0] run.workflow_info = (locator.name, new_version) run.pipeline = controller.current_pipeline if update_vistrail: controller.write_vistrail(locator) result.append(run) if current_workflow.jobs: if current_workflow.completed(): run.job = "COMPLETED" else: run.job = "RUNNING: %s" % current_workflow.id for job in current_workflow.jobs.itervalues(): if not job.finished: run.job += "\n %s %s %s" % (job.start, job.name, job.description()) print run.job return result
def test_infinite_looping_upgrade(self): """Test that circular upgrades fail gracefully""" # Expected actions are as follow: # - loads workflow2.xml # * pipeline is missing looping_fix.x version 0.1 # - enables looping_fix.x (version 0.2) # * pipeline is still missing looping_fix.x version 0.1 # - runs upgrade for looping_fix.x, 0.1 -> 0.2 # - upgrade changes modules to package looping_fix.y version 0.1 # * pipeline is missing looping_fix.y version 0.1 # - enables looping_fix.y (version 0.2) # * pipeline is still missing looping_fix.y version 0.1 # Loop 50 times: # - runs upgrade for looping_fix.y, 0.1 -> 0.2 # - upgrade changes modules to package looping_fix.x version 0.1 # * pipeline is missing looping_fix.x version 0.1 # - runs upgrade for looping_fix.x, 0.1 -> 0.2 # - upgrade changes modules to package looping_fix.y version 0.1 # * pipeline is missing looping_fix.y version 0.1 # 50 calls to handle_invalid_pipeline() # Pre-adds packages so that the package manager can find them packages = ["pkg_x", "pkg_y"] prefix = "vistrails.tests.resources.looping_upgrades." pm = get_package_manager() for pkg in packages: pm.get_available_package(pkg, prefix=prefix) # Hooks handle_invalid_pipeline() from vistrails.core.vistrail.controller import VistrailController orig_hip = VistrailController.handle_invalid_pipeline count = [0] def new_hip(*args, **kwargs): count[0] += 1 return orig_hip(*args, **kwargs) VistrailController.handle_invalid_pipeline = new_hip try: # Loads workflow.xml from vistrails.core.db.io import load_vistrail from vistrails.core.db.locator import FileLocator from vistrails.core.system import vistrails_root_directory locator = FileLocator( os.path.join(vistrails_root_directory(), "tests", "resources", "looping_upgrades", "workflow2.xml") ) loaded_objs = load_vistrail(locator) controller = VistrailController(loaded_objs[0], locator, *loaded_objs[1:]) # Select version (triggers all the validation/upgrade/loading) self.assertEqual(controller.get_latest_version_in_graph(), 1) try: controller.do_version_switch(1) except InvalidPipeline: pass else: self.fail("No InvalidPipeline exception raised!") # Restores handle_invalid_pipeline() finally: VistrailController.handle_invalid_pipeline = orig_hip # disable packages for pkg in reversed(packages): try: pm.late_disable_package(pkg) except MissingPackage: pass # make sure it looped 50 times before failing max_loops = getattr(get_vistrails_configuration(), "maxPipelineFixAttempts", 50) self.assertEqual(count[0], max_loops) # Check that original version gets selected self.assertEqual(1, controller.current_version)
def run_and_get_results(w_list, parameters='', update_vistrail=True, extra_info=None, reason='Console Mode Execution'): """run_and_get_results(w_list: list of (locator, version), parameters: str, output_dir:str, update_vistrail: boolean, extra_info:dict) Run all workflows in w_list, and returns an interpreter result object. version can be a tag name or a version id. """ elements = parameters.split("$&$") aliases = {} params = [] result = [] for locator, workflow in w_list: (v, abstractions, thumbnails, mashups) = load_vistrail(locator) controller = VistrailController(v, locator, abstractions, thumbnails, mashups, auto_save=update_vistrail) if isinstance(workflow, basestring): version = v.get_version_number(workflow) elif isinstance(workflow, (int, long)): version = workflow elif workflow is None: version = controller.get_latest_version_in_graph() else: msg = "Invalid version tag or number: %s" % workflow raise VistrailsInternalError(msg) controller.change_selected_version(version) for e in elements: pos = e.find("=") if pos != -1: key = e[:pos].strip() value = e[pos + 1:].strip() if controller.current_pipeline.has_alias(key): aliases[key] = value elif 'mashup_id' in extra_info: # new-style mashups can have aliases not existing in pipeline for mashuptrail in mashups: if mashuptrail.vtVersion == version: mashup = mashuptrail.getMashup( extra_info['mashup_id']) c = mashup.getAliasByName(key).component params.append((c.vttype, c.vtid, value)) if not update_vistrail: conf = get_vistrails_configuration() if conf.has('thumbs'): conf.thumbs.autoSave = False jobMonitor = controller.jobMonitor current_workflow = jobMonitor.currentWorkflow() if not current_workflow: for job in jobMonitor.workflows.itervalues(): try: job_version = int(job.version) except ValueError: try: job_version = v.get_version_number(job.version) except KeyError: # this is a PE or mashup continue if version == job_version: current_workflow = job jobMonitor.startWorkflow(job) if not current_workflow: current_workflow = JobWorkflow(version) jobMonitor.startWorkflow(current_workflow) try: (results, _) = \ controller.execute_current_workflow(custom_aliases=aliases, custom_params=params, extra_info=extra_info, reason=reason) finally: jobMonitor.finishWorkflow() new_version = controller.current_version if new_version != version: debug.log("Version '%s' (%s) was upgraded. The actual " "version executed was %s" % (workflow, version, new_version)) run = results[0] run.workflow_info = (locator.name, new_version) run.pipeline = controller.current_pipeline if update_vistrail: controller.write_vistrail(locator) result.append(run) if current_workflow.jobs: if current_workflow.completed(): run.job = "COMPLETED" else: run.job = "RUNNING: %s" % current_workflow.id for job in current_workflow.jobs.itervalues(): if not job.finished: run.job += "\n %s %s %s" % (job.start, job.name, job.description()) print run.job return result
class Vistrail(object): """This class wraps both Vistrail and VistrailController. From it, you can get any pipeline from a tag name or version number. It has a concept of "current version", from which you can create new versions by performing actions. """ _current_pipeline = None _html = None def __init__(self, arg=None): initialize() if arg is None: # Copied from VistrailsApplicationInterface#open_vistrail() locator = UntitledLocator() loaded_objs = vistrails.core.db.io.load_vistrail(locator) self.controller = VistrailController(loaded_objs[0], locator, *loaded_objs[1:]) elif isinstance(arg, (_Pipeline, Pipeline)): if isinstance(arg, Pipeline): pipeline = arg.pipeline else: pipeline = arg # Copied from VistrailsApplicationInterface#open_workflow() vistrail = _Vistrail() ops = [] for module in pipeline.module_list: ops.append(('add', module)) for connection in pipeline.connection_list: ops.append(('add', connection)) action = vistrails.core.db.action.create_action(ops) vistrail.add_action(action, 0L) vistrail.update_id_scope() vistrail.change_description("Imported pipeline", 0L) self.controller = VistrailController(vistrail, UntitledLocator()) elif isinstance(arg, VistrailController): self.controller = arg elif isinstance(arg, basestring): raise TypeError("Vistrail was constructed from %r.\n" "Use load_vistrail() to get a Vistrail from a " "file." % type(arg).__name__) else: raise TypeError("Vistrail was constructed from unexpected " "argument type %r" % type(arg).__name__) def get_pipeline(self, version): """Returns a pipeline from a version number of tag. This does not change the currently selected version in this Vistrail. """ vistrail = self.controller.vistrail if isinstance(version, (int, long)): if not vistrail.db_has_action_with_id(version): raise NoSuchVersion("Vistrail doesn't have a version %r" % version) return Pipeline(vistrail.getPipelineVersionNumber(version)) elif isinstance(version, basestring): if not vistrail.has_tag_str(version): raise NoSuchVersion("Vistrail doesn't have a tag %r" % version) return Pipeline(vistrail.getPipelineVersionName(version)) else: raise TypeError("get_pipeline() argument must be a string or " "integer, not %r" % type(version).__name__) def select_version(self, version): """Sets a different version as current. The current workflow is accessible via current_workflow; it is the one that gets executed when calling execute(), and the version from which new versions are created if you perform actions. """ vistrail = self.controller.vistrail if isinstance(version, (int, long)): if not vistrail.db_has_action_with_id(version): raise NoSuchVersion("Vistrail doesn't have a version %r" % version) elif (isinstance(version, basestring)): if not vistrail.has_tag_str(version): raise NoSuchVersion("Vistrail doesn't have a tag %r" % version) version = vistrail.get_tag_str(version).action_id else: raise TypeError("select_version() argument must be a string " "or integer, not %r" % type(version).__name__) self.controller.do_version_switch(version) self._current_pipeline = None self._html = None def select_latest_version(self): """Sets the most recent version in the vistrail as current. """ self.controller.do_version_switch( self.controller.get_latest_version_in_graph()) self._current_pipeline = None self._html = None @property def current_pipeline(self): if self._current_pipeline is None: self._current_pipeline = Pipeline(self.controller.current_pipeline, vistrail=(self, self.current_version)) return self._current_pipeline @property def current_version(self): return self.controller.current_version def set_tag(self, *args): """Sets a tag for the current or specified version. """ if len(args) == 1: version, (tag, ) = self.controller.current_version, args elif len(args) == 2: version, tag = args else: raise TypeError("set_tag() takes 1 or 2 arguments (%r given)" % len(args)) if isinstance(version, (int, long)): if not self.controller.vistrail.db_has_action_with_id(version): raise NoSuchVersion("Vistrail doesn't have a version %r" % version) elif isinstance(version, basestring): if not self.controller.vistrail.has_tag_str(version): raise NoSuchVersion("Vistrail doesn't have a tag %r" % version) else: raise TypeError("set_tag() expects the version to be a string or " "integer, not %r" % type(version).__name__) self.controller.vistrail.set_tag(version, tag) def tag(self, tag): """Sets a tag for the current version. """ self.set_tag(tag) def execute(self, *args, **kwargs): """Executes the current workflow. """ return self.current_pipeline.execute(*args, **kwargs) @property def changed(self): return self.controller.changed # TODO : vistrail modification methods def __repr__(self): version_nb = self.controller.current_version if self.controller.vistrail.has_tag(version_nb): version = "%s (tag %s)" % ( version_nb, self.controller.vistrail.get_tag(version_nb)) else: version = version_nb return "<%s: %s, version %s, %s>" % ( self.__class__.__name__, self.controller.name, version, ('not changed', 'changed')[self.controller.changed]) def _repr_html_(self): if self._html is None: import cgi try: from cStringIO import StringIO except ImportError: from StringIO import StringIO self._html = '' stream = StringIO() self.controller.recompute_terse_graph() self.controller.save_version_graph( stream, highlight=self.controller.current_version) stream.seek(0) dot = stream.read() try: proc = subprocess.Popen(['dot', '-Tsvg'], stdin=subprocess.PIPE, stdout=subprocess.PIPE) svg, _ = proc.communicate(dot) if proc.wait() == 0: self._html += svg except OSError: pass self._html += '<pre>' + cgi.escape(repr(self)) + '</pre>' return self._html
def test_looping_pipeline_fix(self): """Chains upgrades and automatic package initialization.""" # Expected actions are as follow: # - loads workflow.xml # * pipeline is missing looping_fix.a version 0.1 # - enables looping_fix.a (version 0.2) # * pipeline is still missing looping_fix.a version 0.1 # - runs upgrade for looping_fix.a, 0.1 -> 0.2 # - upgrade changes modules to package looping_fix.b version 0.1 # * pipeline is missing looping_fix.b version 0.1 # - enables looping_fix.b (version 0.2) # * pipeline is still missing looping_fix.b version 0.1 # - runs upgrade for looping_fix.b, 0.1 -> 0.2 # - upgrade changes modules to package looping_fix.c version 1.0 # * pipeline is missing looping_fix.c version 1.0 # - enables looping_fix.c (version 1.0) # * pipeline is valid # 5 calls to handle_invalid_pipeline() # Pre-adds packages so that the package manager can find them packages = ["pkg_a", "pkg_b", "pkg_c"] prefix = "vistrails.tests.resources.looping_upgrades." pm = get_package_manager() for pkg in packages: pm.get_available_package(pkg, prefix=prefix) self.assertFalse(set(pkg.codepath for pkg in pm.enabled_package_list()).intersection(packages)) # Hooks handle_invalid_pipeline() from vistrails.core.vistrail.controller import VistrailController orig_hip = VistrailController.handle_invalid_pipeline count = [0] def new_hip(*args, **kwargs): count[0] += 1 return orig_hip(*args, **kwargs) VistrailController.handle_invalid_pipeline = new_hip try: # Loads workflow.xml from vistrails.core.db.io import load_vistrail from vistrails.core.db.locator import FileLocator from vistrails.core.system import vistrails_root_directory locator = FileLocator( os.path.join(vistrails_root_directory(), "tests", "resources", "looping_upgrades", "workflow.xml") ) loaded_objs = load_vistrail(locator) controller = VistrailController(loaded_objs[0], locator, *loaded_objs[1:]) # Select version (triggers all the validation/upgrade/loading) self.assertEqual(controller.get_latest_version_in_graph(), 1) controller.do_version_switch(1) self.assertEqual(count[0], 5) # Restores handle_invalid_pipeline() finally: VistrailController.handle_invalid_pipeline = orig_hip # disable packages for pkg in reversed(packages): try: pm.late_disable_package(pkg) except MissingPackage: pass
sender.connect("tcp://{0}:{1}".format(HOST, SEND)) while True: # Receiving pipeline instance configuration data = receiver.recv() logging.debug('Receiving: ' + data) fields = data.split("|") filename = fields[0] parameter_list = ast.literal_eval(fields[1]) inputs = ast.literal_eval(fields[2]) outputs = ast.literal_eval(fields[3]) locator = FileLocator(filename) loaded_objs = vistrails.core.db.io.load_vistrail(locator) controller = VistrailController(loaded_objs[0], locator, *loaded_objs[1:]) controller.do_version_switch(controller.get_latest_version_in_graph()) pipeline = Pipeline(controller) kwargs = {} for i in range(len(parameter_list)): kwargs[inputs[i]] = parameter_list[i] try: #Executing pipeline instance and retieving the result result = pipeline.execute(**kwargs) for output in outputs: parameter_list.append(str(result.output_port(output))) except: traceback.print_exc(file=sys.stdout) parameter_list.append(str(False)) kwargs['result'] = parameter_list[-1] record_python_run(kwargs, filename)
def run_and_get_results(w_list, parameters='', workflow_info=None, update_vistrail=True, extra_info=None, reason='Console Mode Execution'): """run_and_get_results(w_list: list of (locator, version), parameters: str, workflow_info:str, update_vistrail: boolean, extra_info:dict) Run all workflows in w_list, and returns an interpreter result object. version can be a tag name or a version id. """ elements = parameters.split("$&$") aliases = {} result = [] for locator, workflow in w_list: (v, abstractions , thumbnails, mashups) = load_vistrail(locator) controller = VistrailController(v, locator, abstractions, thumbnails, mashups, auto_save=update_vistrail) if isinstance(workflow, basestring): version = v.get_version_number(workflow) elif isinstance(workflow, (int, long)): version = workflow elif workflow is None: version = controller.get_latest_version_in_graph() else: msg = "Invalid version tag or number: %s" % workflow raise VistrailsInternalError(msg) controller.change_selected_version(version) for e in elements: pos = e.find("=") if pos != -1: key = e[:pos].strip() value = e[pos+1:].strip() if controller.current_pipeline.has_alias(key): aliases[key] = value if workflow_info is not None and controller.current_pipeline is not None: # FIXME DAK: why is this always done?!? there is a flag for it... if is_running_gui(): controller.updatePipelineScene() base_fname = "%s_%s_pipeline.pdf" % (locator.short_filename, version) filename = os.path.join(workflow_info, base_fname) controller.current_pipeline_scene.saveToPDF(filename) else: debug.critical("Cannot save pipeline figure when not " "running in gui mode") base_fname = "%s_%s_pipeline.xml" % (locator.short_filename, version) filename = os.path.join(workflow_info, base_fname) vistrails.core.db.io.save_workflow(controller.current_pipeline, filename) if not update_vistrail: conf = get_vistrails_configuration() if conf.has('thumbs'): conf.thumbs.autoSave = False (results, _) = \ controller.execute_current_workflow(custom_aliases=aliases, extra_info=extra_info, reason=reason) new_version = controller.current_version if new_version != version: debug.warning("Version '%s' (%s) was upgraded. The actual " "version executed was %s" % \ (workflow, version, new_version)) run = results[0] run.workflow_info = (locator.name, new_version) run.pipeline = controller.current_pipeline if update_vistrail: controller.write_vistrail(locator) result.append(run) return result
class Vistrail(object): """This class wraps both Vistrail and VistrailController. From it, you can get any pipeline from a tag name or version number. It has a concept of "current version", from which you can create new versions by performing actions. """ _current_pipeline = None _html = None def __init__(self, arg=None): initialize() if arg is None: # Copied from VistrailsApplicationInterface#open_vistrail() locator = UntitledLocator() loaded_objs = vistrails.core.db.io.load_vistrail(locator) self.controller = VistrailController(loaded_objs[0], locator, *loaded_objs[1:]) elif isinstance(arg, (_Pipeline, Pipeline)): if isinstance(arg, Pipeline): pipeline = arg.pipeline else: pipeline = arg # Copied from VistrailsApplicationInterface#open_workflow() vistrail = _Vistrail() ops = [] for module in pipeline.module_list: ops.append(('add', module)) for connection in pipeline.connection_list: ops.append(('add', connection)) action = vistrails.core.db.action.create_action(ops) vistrail.add_action(action, 0L) vistrail.update_id_scope() vistrail.change_description("Imported pipeline", 0L) self.controller = VistrailController(vistrail, UntitledLocator()) elif isinstance(arg, VistrailController): self.controller = arg elif isinstance(arg, basestring): raise TypeError("Vistrail was constructed from %r.\n" "Use load_vistrail() to get a Vistrail from a " "file." % type(arg).__name__) else: raise TypeError("Vistrail was constructed from unexpected " "argument type %r" % type(arg).__name__) def get_pipeline(self, version): """Returns a pipeline from a version number of tag. This does not change the currently selected version in this Vistrail. """ vistrail = self.controller.vistrail if isinstance(version, (int, long)): if not vistrail.db_has_action_with_id(version): raise NoSuchVersion("Vistrail doesn't have a version %r" % version) return Pipeline(vistrail.getPipelineVersionNumber(version)) elif isinstance(version, basestring): if not vistrail.has_tag_str(version): raise NoSuchVersion("Vistrail doesn't have a tag %r" % version) return Pipeline(vistrail.getPipelineVersionName(version)) else: raise TypeError("get_pipeline() argument must be a string or " "integer, not %r" % type(version).__name__) def select_version(self, version): """Sets a different version as current. The current workflow is accessible via current_workflow; it is the one that gets executed when calling execute(), and the version from which new versions are created if you perform actions. """ vistrail = self.controller.vistrail if isinstance(version, (int, long)): if not vistrail.db_has_action_with_id(version): raise NoSuchVersion("Vistrail doesn't have a version %r" % version) elif (isinstance(version, basestring)): if not vistrail.has_tag_str(version): raise NoSuchVersion("Vistrail doesn't have a tag %r" % version) version = vistrail.get_tag_str(version).action_id else: raise TypeError("select_version() argument must be a string " "or integer, not %r" % type(version).__name__) self.controller.do_version_switch(version) self._current_pipeline = None self._html = None def select_latest_version(self): """Sets the most recent version in the vistrail as current. """ self.controller.do_version_switch( self.controller.get_latest_version_in_graph()) self._current_pipeline = None self._html = None @property def current_pipeline(self): if self._current_pipeline is None: self._current_pipeline = Pipeline( self.controller.current_pipeline, vistrail=(self, self.current_version)) return self._current_pipeline @property def current_version(self): return self.controller.current_version def set_tag(self, *args): """Sets a tag for the current or specified version. """ if len(args) == 1: version, (tag,) = self.controller.current_version, args elif len(args) == 2: version, tag = args else: raise TypeError("set_tag() takes 1 or 2 arguments (%r given)" % len(args)) if isinstance(version, (int, long)): if not self.controller.vistrail.db_has_action_with_id(version): raise NoSuchVersion("Vistrail doesn't have a version %r" % version) elif isinstance(version, basestring): if not self.controller.vistrail.has_tag_str(version): raise NoSuchVersion("Vistrail doesn't have a tag %r" % version) else: raise TypeError("set_tag() expects the version to be a string or " "integer, not %r" % type(version).__name__) self.controller.vistrail.set_tag(version, tag) def tag(self, tag): """Sets a tag for the current version. """ self.set_tag(tag) def execute(self, *args, **kwargs): """Executes the current workflow. """ return self.current_pipeline.execute(*args, **kwargs) @property def changed(self): return self.controller.changed # TODO : vistrail modification methods def __repr__(self): version_nb = self.controller.current_version if self.controller.vistrail.has_tag(version_nb): version = "%s (tag %s)" % ( version_nb, self.controller.vistrail.get_tag(version_nb)) else: version = version_nb return "<%s: %s, version %s, %s>" % ( self.__class__.__name__, self.controller.name, version, ('not changed', 'changed')[self.controller.changed]) def _repr_html_(self): if self._html is None: import cgi try: from cStringIO import StringIO except ImportError: from StringIO import StringIO self._html = '' stream = StringIO() self.controller.recompute_terse_graph() self.controller.save_version_graph( stream, highlight=self.controller.current_version) stream.seek(0) dot = stream.read() try: proc = subprocess.Popen(['dot', '-Tsvg'], stdin=subprocess.PIPE, stdout=subprocess.PIPE) svg, _ = proc.communicate(dot) if proc.wait() == 0: self._html += svg except OSError: pass self._html += '<pre>' + cgi.escape(repr(self)) + '</pre>' return self._html
def previewChanges(self, aliases): print "previewChanges", aliases # we will just execute the pipeline with the given alias dictionary controller = VistrailController() controller.set_vistrail(self.plot_vistrail, self.locator) version = self.plot_vistrail.get_version_number(self.workflow_tag) if self.workflow_tag else controller.get_latest_version_in_graph() controller.change_selected_version(version) (results, _) = controller.execute_current_workflow(aliases)
def load(self, loadworkflow=True): config = ConfigParser.ConfigParser() if config.read(self.config_file): if config.has_section('global'): if config.has_option('global', 'cellnum'): self.cellnum = config.getint('global', 'cellnum') if config.has_option('global', 'filenum'): self.filenum = config.getint('global', 'filenum') if config.has_option('global', 'varnum'): self.varnum = config.getint('global', 'varnum') print " ------ Loaded plot %s, varnum = %d ------ " % ( self.name, self.varnum ) if config.has_option('global', 'workflow_tag'): self.workflow_tag = config.get('global', 'workflow_tag') # else: # debug.warning("CDAT Package: file %s does not contain a required option 'workflow_tag'. Widget will not be loaded."%self.config_file) # self.loaded = False # return if config.has_option('global', 'filetypes'): types = config.get('global', 'filetypes') tlist = [t.strip() for t in types.split(";")] for t in tlist: kv = t.split(":") self.filetypes[kv[0].strip()] = [v.strip() for v in kv[1].split(",")] if config.has_option('global', 'qt_filter'): self.qt_filter = config.get('global', 'qt_filter') if config.has_option('global', 'dependencies'): deps = config.get('global', 'dependencies') self.dependencies = [d.strip() for d in deps.split(",")] if config.has_option('global', 'serialized_config_alias'): self.serializedConfigAlias = config.get('global', 'serialized_config_alias') for y in range(self.filenum): self.files.append( 'Filename' + str(y+1) ) for v in range(self.varnum): self.vars.append( 'VariableName' + str(v+1) ) self.axes.append( 'Axes' + str(v+1) ) for x in range(self.cellnum): section_name = 'cell' + str(x+1) if config.has_section(section_name): cellType = config.get(section_name, 'celltype') if config.has_option(section_name, 'address_alias'): self.cells.append( Cell( cellType, None, None, config.get(section_name, 'address_alias') ) ) else: self.cells.append(Cell( cellType,"Row"+str(x+1), "Column"+str(x+1) ) ) else: for y in range(self.filenum): option_name = 'filename_alias' + str(y+1) if config.has_option('global', option_name): self.files.append(config.get('global', option_name)) for v in range(self.varnum): option_name = 'varname_alias' + str(v+1) if config.has_option('global', option_name): self.vars.append(config.get('global', option_name)) axes_name = 'axes_alias' + str(v+1) if config.has_option('global', axes_name): self.axes.append(config.get('global', axes_name)) for x in range(self.cellnum): section_name = 'cell' + str(x+1) if (config.has_section(section_name) and config.has_option(section_name, 'celltype') and config.has_option(section_name, 'row_alias') and config.has_option(section_name, 'col_alias')): self.cells.append(Cell(config.get(section_name, 'celltype'), config.get(section_name, 'row_alias'), config.get(section_name, 'col_alias'))) if loadworkflow: #load workflow in vistrail #only if dependencies are enabled manager = get_package_manager() self.unsatisfied_deps = [] for dep in self.dependencies: if not manager.has_package(dep): self.unsatisfied_deps.append(dep) if len(self.unsatisfied_deps) == 0: try: (self.plot_vistrail, abstractions , thumbnails, mashups) = load_vistrail(self.locator) controller = VistrailController() controller.set_vistrail(self.plot_vistrail, self.locator, abstractions, thumbnails, mashups) self.workflow_version = self.plot_vistrail.get_version_number(self.workflow_tag) if self.workflow_tag else controller.get_latest_version_in_graph() print " Loaded %s version: %s" % ( self.name, str( self.workflow_version ) ) controller.change_selected_version(self.workflow_version) self.workflow = controller.current_pipeline self.loaded = True except Exception, err: debug.warning( "Error loading workflow %s: %s" % ( self.name, err ) ) self.loaded = False else: debug.warning("UV-CDAT: %s widget could not be loaded \ because it depends on packages that are not loaded:"%self.name) debug.warning(" %s"%", ".join(self.unsatisfied_deps)) self.loaded = False else: debug.warning("UV-CDAT: file %s does not contain a 'global'\ section. Widget will not be loaded."%self.config_file) self.loaded = False