def resolve_aliases(self, pipeline,
customAliases=None):
# Compute the 'locals' dictionary by evaluating named expressions
aliases = self.build_alias_dictionary(pipeline)
if customAliases:
#customAliases can be only a subset of the aliases
#so we need to build the Alias Dictionary always
for k,v in customAliases.iteritems():
aliases[k] = v
ordered = self.compute_evaluation_order(aliases)
casting = {'int': int, 'float': float, 'double': float, 'string': str,
'Integer': int, 'Float': float, 'String': str}
for alias in reversed(ordered):
(atype,(base,exps)) = aliases[alias]
value = self.evaluate_exp(atype,base,exps,aliases)
aliases[alias] = casting[atype](value)
for mid in pipeline.modules:
for f in pipeline.modules[mid].functions:
for p in f.params:
if p.alias and p.alias!='':
p.evaluatedStrValue = str(aliases[p.alias])
else:
(base,exps) = expression.parse_expression(
str(p.strValue))
p.evaluatedStrValue = str(
self.evaluate_exp(p.type,base,exps,aliases))
return aliases
def assemble_aliases(self):
"""assemble_aliases() -> None
Generate a list of all aliases across the active pipelines
in self.pipelines, which is stored in self.aliases
Also, for each key in self.aliases, self.sources has the same key,
mapped to a tuple of the type (p, m, f, pa)
where p is the index of the pipeline in self.pipelines, m is the
index of the module, f of the function, and pa of the parameter
"""
union = {}
sources = {}
for pi in self.active_pipelines:
pipeline = self.pipelines[pi]
for name, info in pipeline.aliases.iteritems():
if not union.has_key(name):
value = str(pipeline.get_alias_str_value(name))
e = expression.parse_expression(value)
union[name] = (info[0], e)
sources[name] = [(pi, info[1], info[2], info[3])]
else:
sources[name].append((pi, info[1], info[2], info[3]))
self.sources = sources
self.aliases = union
def build_alias_dictionary(self, pipeline):
aliases = {}
for mid in pipeline.modules:
for f in pipeline.modules[mid].functions:
fsig = f.getSignature()
for pidx in xrange(len(f.params)):
palias = f.params[pidx].alias
if palias and palias!='':
for f1 in reversed(pipeline.modules[mid].functions):
if f1.getSignature()==fsig:
p = f1.params[pidx]
aliases[palias] = (p.type, expression.parse_expression(str(p.strValue)))
break
return aliases
def run_and_get_results(w_list, parameters=""):
"""run_and_get_results(w_list: list of (locator, version), parameters: str)
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 = locator.load()
if type(workflow) == type("str"):
version = v.get_tag_by_name(workflow).time
elif type(workflow) == type(1):
version = workflow
else:
msg = "Invalid version tag or number: %s" % workflow
raise VistrailsInternalError(msg)
pip = v.getPipeline(workflow)
for e in elements:
pos = e.find("=")
if pos != -1:
key = e[:pos].strip()
value = e[pos + 1 :].strip()
if pip.has_alias(key):
(vttype, pId, _, _) = pip.aliases[key]
parameter = pip.db_get_object(vttype, pId)
ptype = parameter.type
aliases[key] = (ptype, expression.parse_expression(value))
view = DummyView()
interpreter = core.interpreter.default.get_default_interpreter()
run = interpreter.execute(None, pip, locator, version, view, aliases)
result.append(run)
return result
