def insert_module_annotations(self, module, a_dict):
for k,v in a_dict.iteritems():
a_id = self.log.id_scope.getNewId(Annotation.vtType)
annotation = Annotation(id=a_id,
key=k,
value=v)
if hasattr(module, 'is_group'):
module.group_exec.add_annotation(annotation)
else:
module.module_exec.add_annotation(annotation)
def insert_workflow_exec_annotations(self, a_dict):
"""insert_workflow_exec_annotations(a_dict)-> None
This will create an annotation for each pair in a_dict in
self.workflow_exec"""
if self.workflow_exec:
for k,v in a_dict.iteritems():
a_id = self.log.id_scope.getNewId(Annotation.vtType)
annotation = Annotation(id=a_id,
key=k,
value=v)
self.workflow_exec.add_annotation(annotation)
def create_ops(self, id_scope=IdScope()):
from core.vistrail.module import Module
from core.vistrail.module_function import ModuleFunction
from core.vistrail.module_param import ModuleParam
from core.vistrail.annotation import Annotation
if id_scope is None:
id_scope = IdScope(
remap={
AddOp.vtType: 'operation',
ChangeOp.vtType: 'operation',
DeleteOp.vtType: 'operation'
})
m = Module(id=id_scope.getNewId(Module.vtType),
name='Float',
package='edu.utah.sci.vistrails.basic')
add_op = AddOp(id=id_scope.getNewId(AddOp.vtType),
what=Module.vtType,
objectId=m.id,
data=m)
function = ModuleFunction(id=id_scope.getNewId(ModuleFunction.vtType),
name='value')
change_op = ChangeOp(id=id_scope.getNewId(ChangeOp.vtType),
what=ModuleFunction.vtType,
oldObjId=2,
newObjId=function.real_id,
parentObjId=m.id,
parentObjType=Module.vtType,
data=function)
param = ModuleParam(id=id_scope.getNewId(ModuleParam.vtType),
type='Float',
val='1.0')
delete_op = DeleteOp(id=id_scope.getNewId(DeleteOp.vtType),
what=ModuleParam.vtType,
objectId=param.real_id,
parentObjId=function.real_id,
parentObjType=ModuleFunction.vtType)
annotation = Annotation(id=id_scope.getNewId(Annotation.vtType),
key='foo',
value='bar')
add_annotation = AddOp(id=id_scope.getNewId(AddOp.vtType),
what=Annotation.vtType,
objectId=m.id,
data=annotation)
return [add_op, change_op, delete_op, add_annotation]
def finish_module_execution(self, module, error, errorTrace=None,
suspended=False):
module.module_exec.ts_end = core.system.current_time()
if suspended:
module.module_exec.completed = -2
module.module_exec.error = error
elif not error:
module.module_exec.completed = 1
else:
module.module_exec.completed = -1
module.module_exec.error = error
if errorTrace:
a_id = self.log.id_scope.getNewId(Annotation.vtType)
annotation = Annotation(id=a_id,
key="errorTrace",
value=errorTrace)
module.module_exec.add_annotation(annotation)
del module.module_exec
if module.is_fold_module:
return True
def replace_generic(controller, pipeline, old_module, new_module,
function_remap={}, src_port_remap={},
dst_port_remap={}, annotation_remap={}):
ops = []
ops.extend(controller.delete_module_list_ops(pipeline, [old_module.id]))
for annotation in old_module.annotations:
if annotation.key not in annotation_remap:
annotation_key = annotation.key
else:
remap = annotation_remap[annotation.key]
if remap is None:
# don't add the annotation back in
continue
elif type(remap) != type(""):
ops.extend(remap(annotation))
continue
else:
annotation_key = remap
new_annotation = \
Annotation(id=controller.id_scope.getNewId(Annotation.vtType),
key=annotation_key,
value=annotation.value)
new_module.add_annotation(new_annotation)
if not old_module.is_group() and not old_module.is_abstraction():
for port_spec in old_module.port_spec_list:
if port_spec.type == 'input':
if port_spec.name not in dst_port_remap:
spec_name = port_spec.name
else:
remap = dst_port_remap[port_spec.name]
if remap is None:
continue
elif type(remap) != type(""):
ops.extend(remap(port_spec))
continue
else:
spec_name = remap
elif port_spec.type == 'output':
if port_spec.name not in src_port_remap:
spec_name = port_spec.name
else:
remap = src_port_remap[port_spec.name]
if remap is None:
continue
elif type(remap) != type(""):
ops.extend(remap(port_spec))
continue
else:
spec_name = remap
new_spec = port_spec.do_copy(True, controller.id_scope, {})
new_spec.name = spec_name
new_module.add_port_spec(new_spec)
for function in old_module.functions:
if function.name not in function_remap:
function_name = function.name
else:
remap = function_remap[function.name]
if remap is None:
# don't add the function back in
continue
elif type(remap) != type(""):
ops.extend(remap(function, new_module))
continue
else:
function_name = remap
if len(function.parameters) > 0:
new_param_vals, aliases = zip(*[(p.strValue, p.alias)
for p in function.parameters])
else:
new_param_vals = []
aliases = []
new_function = controller.create_function(new_module,
function_name,
new_param_vals,
aliases)
new_module.add_function(new_function)
# add the new module
ops.append(('add', new_module))
create_new_connection = UpgradeWorkflowHandler.create_new_connection
for _, conn_id in pipeline.graph.edges_from(old_module.id):
old_conn = pipeline.connections[conn_id]
if old_conn.source.name not in src_port_remap:
source_name = old_conn.source.name
else:
remap = src_port_remap[old_conn.source.name]
if remap is None:
# don't add this connection back in
continue
elif type(remap) != type(""):
ops.extend(remap(old_conn, new_module))
continue
else:
source_name = remap
old_dst_module = pipeline.modules[old_conn.destination.moduleId]
new_conn = create_new_connection(controller,
new_module,
source_name,
old_dst_module,
old_conn.destination)
ops.append(('add', new_conn))
for _, conn_id in pipeline.graph.edges_to(old_module.id):
old_conn = pipeline.connections[conn_id]
if old_conn.destination.name not in dst_port_remap:
destination_name = old_conn.destination.name
else:
remap = dst_port_remap[old_conn.destination.name]
if remap is None:
# don't add this connection back in
continue
elif type(remap) != type(""):
ops.extend(remap(old_conn, new_module))
continue
else:
destination_name = remap
old_src_module = pipeline.modules[old_conn.source.moduleId]
new_conn = create_new_connection(controller,
old_src_module,
old_conn.source,
new_module,
destination_name)
ops.append(('add', new_conn))
return [core.db.action.create_action(ops)]
