def __module_from_dict( self, trans, step_dict, secure ):
""" Create a WorkflowStep model object and corresponding module
representing type-specific functionality from the incoming dictionary.
"""
step = model.WorkflowStep()
# TODO: Consider handling position inside module.
step.position = step_dict['position']
if "uuid" in step_dict and step_dict['uuid'] != "None":
step.uuid = step_dict["uuid"]
if "label" in step_dict:
step.label = step_dict["label"]
step_type = step_dict.get("type", None)
if step_type == "subworkflow":
subworkflow = self.__load_subworkflow_from_step_dict(
trans, step_dict
)
step_dict["subworkflow"] = subworkflow
module = module_factory.from_dict( trans, step_dict, secure=secure )
module.save_to_step( step )
annotation = step_dict[ 'annotation' ]
if annotation:
annotation = sanitize_html( annotation, 'utf-8', 'text/html' )
self.add_item_annotation( trans.sa_session, trans.get_user(), step, annotation )
# Stick this in the step temporarily
step.temp_input_connections = step_dict['input_connections']
return module, step
def __module_from_dict(self, trans, step_dict, exact_tools=False):
""" Create a WorkflowStep model object and corresponding module
representing type-specific functionality from the incoming dictionary.
"""
step = model.WorkflowStep()
# TODO: Consider handling position inside module.
step.position = step_dict['position']
if "uuid" in step_dict and step_dict['uuid'] != "None":
step.uuid = step_dict["uuid"]
if "label" in step_dict:
step.label = step_dict["label"]
step_type = step_dict.get("type", None)
if step_type == "subworkflow":
subworkflow = self.__load_subworkflow_from_step_dict(
trans, step_dict)
step_dict["subworkflow"] = subworkflow
module = module_factory.from_dict(trans,
step_dict,
exact_tools=exact_tools)
module.save_to_step(step)
annotation = step_dict['annotation']
if annotation:
annotation = sanitize_html(annotation, 'utf-8', 'text/html')
self.add_item_annotation(trans.sa_session, trans.get_user(), step,
annotation)
# Stick this in the step temporarily
step.temp_input_connections = step_dict['input_connections']
return module, step
def build_module(self, trans, payload={}):
"""
POST /api/workflows/build_module
Builds module models for the workflow editor.
"""
inputs = payload.get('inputs', {})
trans.workflow_building_mode = workflow_building_modes.ENABLED
module = module_factory.from_dict(trans, payload)
if 'tool_state' not in payload:
module_state = {}
populate_state(trans,
module.get_inputs(),
inputs,
module_state,
check=False)
module.recover_state(module_state)
return {
'label': inputs.get('__label', ''),
'annotation': inputs.get('__annotation', ''),
'name': module.get_name(),
'tool_state': module.get_state(),
'inputs': module.get_all_inputs(connectable_only=True),
'outputs': module.get_all_outputs(),
'config_form': module.get_config_form(),
'post_job_actions': module.get_post_job_actions(inputs)
}
def build_module(self, trans, payload={}):
"""
POST /api/workflows/build_module
Builds module details including a tool model for the workflow editor.
"""
tool_id = payload.get("tool_id", None)
tool_version = payload.get("tool_version", None)
tool_inputs = payload.get("inputs", None)
annotation = payload.get("annotation", "")
# load tool
tool = self._get_tool(tool_id, tool_version=tool_version, user=trans.user)
# initialize module
trans.workflow_building_mode = True
module = module_factory.from_dict(trans, {"type": "tool", "tool_id": tool.id, "tool_state": None})
# create tool model and default tool state (if missing)
tool_model = module.tool.to_json(trans, tool_inputs, is_workflow=True)
module.state.inputs = copy.deepcopy(tool_model["state_inputs"])
return {
"tool_model": tool_model,
"tool_state": module.get_state(),
"data_inputs": module.get_data_inputs(),
"data_outputs": module.get_data_outputs(),
"tool_errors": module.get_errors(),
"form_html": module.get_config_form(),
"annotation": annotation,
"post_job_actions": module.get_post_job_actions(tool_inputs),
}
def __module_from_dict( self, trans, step_dict, secure ):
""" Create a WorkflowStep model object and corresponding module
representing type-specific functionality from the incoming dictionary.
"""
step = model.WorkflowStep()
# TODO: Consider handling position inside module.
step.position = step_dict['position']
if "uuid" in step_dict and step_dict['uuid'] != "None":
step.uuid = step_dict["uuid"]
if "label" in step_dict:
step.label = step_dict["label"]
module = module_factory.from_dict( trans, step_dict, secure=secure )
module.save_to_step( step )
workflow_outputs_dicts = step_dict.get("workflow_outputs", [])
for workflow_output_dict in workflow_outputs_dicts:
output_name = workflow_output_dict["output_name"]
workflow_output = model.WorkflowOutput(
step,
output_name,
)
step.workflow_outputs.append(workflow_output)
annotation = step_dict[ 'annotation' ]
if annotation:
annotation = sanitize_html( annotation, 'utf-8', 'text/html' )
self.add_item_annotation( trans.sa_session, trans.get_user(), step, annotation )
# Stick this in the step temporarily
step.temp_input_connections = step_dict['input_connections']
return module, step
def build_module( self, trans, payload={}):
"""
POST /api/workflows/build_module
Builds module details including a tool model for the workflow editor.
"""
tool_id = payload.get( 'tool_id', None )
tool_version = payload.get( 'tool_version', None )
tool_inputs = payload.get( 'inputs', None )
annotation = payload.get( 'annotation', '' )
# load tool
tool = self._get_tool( tool_id, tool_version=tool_version, user=trans.user )
# initialize module
trans.workflow_building_mode = True
module = module_factory.from_dict( trans, {
'type' : 'tool',
'tool_id' : tool.id,
'tool_state' : None
} )
# create tool model and default tool state (if missing)
tool_model = module.tool.to_json(trans, tool_inputs, is_workflow=True)
module.state.inputs = copy.deepcopy(tool_model['state_inputs'])
return {
'tool_model' : tool_model,
'tool_state' : module.get_state(),
'data_inputs' : module.get_data_inputs(),
'data_outputs' : module.get_data_outputs(),
'tool_errors' : module.get_errors(),
'form_html' : module.get_config_form(),
'annotation' : annotation,
'post_job_actions' : module.get_post_job_actions(tool_inputs)
}
def __get_tool_extensions(self, trans, tool_id):
"""
Get the input and output extensions of a tool
"""
payload = {'type': 'tool', 'tool_id': tool_id, '_': 'true'}
inputs = payload.get('inputs', {})
trans.workflow_building_mode = workflow_building_modes.ENABLED
module = module_factory.from_dict(trans, payload)
if 'tool_state' not in payload:
module_state = {}
populate_state(trans,
module.get_inputs(),
inputs,
module_state,
check=False)
module.recover_state(module_state)
inputs = module.get_all_inputs(connectable_only=True)
outputs = module.get_all_outputs()
input_extensions = list()
output_extensions = list()
for i_ext in inputs:
input_extensions.extend(i_ext['extensions'])
for o_ext in outputs:
output_extensions.extend(o_ext['extensions'])
return input_extensions, output_extensions
def build_module( self, trans, payload={}):
"""
POST /api/workflows/build_module
Builds module details including a tool model for the workflow editor.
"""
tool_id = payload.get( 'tool_id', None )
tool_version = payload.get( 'tool_version', None )
tool_inputs = payload.get( 'inputs', None )
annotation = payload.get( 'annotation', '' )
# load tool
tool = self._get_tool( tool_id, tool_version=tool_version, user=trans.user )
# initialize module
trans.workflow_building_mode = True
module = module_factory.from_dict( trans, {
'type' : 'tool',
'tool_id' : tool.id,
'tool_state' : None
} )
# create tool model and default tool state (if missing)
tool_model = module.tool.to_json(trans, tool_inputs, is_dynamic=False)
module.state.inputs = copy.deepcopy(tool_model['state_inputs'])
return {
'tool_model' : tool_model,
'tool_state' : module.get_state(),
'data_inputs' : module.get_data_inputs(),
'data_outputs' : module.get_data_outputs(),
'tool_errors' : module.get_errors(),
'form_html' : module.get_config_form(),
'annotation' : annotation,
'post_job_actions' : module.get_post_job_actions(tool_inputs)
}
def __module_from_dict(self, trans, step_dict, secure):
""" Create a WorkflowStep model object and corrsponding module representing
type-specific functionality from the incoming dicitionary.
"""
step = model.WorkflowStep()
# TODO: Consider handling position inside module.
step.position = step_dict['position']
if "uuid" in step_dict:
step.uuid = step_dict["uuid"]
if "label" in step_dict:
step.label = step_dict["label"]
module = module_factory.from_dict(trans, step_dict, secure=secure)
module.save_to_step(step)
annotation = step_dict['annotation']
if annotation:
annotation = sanitize_html(annotation, 'utf-8', 'text/html')
self.add_item_annotation(trans.sa_session, trans.get_user(), step,
annotation)
# Stick this in the step temporarily
step.temp_input_connections = step_dict['input_connections']
return module, step
def __module_from_dict(self, trans, steps, steps_by_external_id, step_dict,
**kwds):
""" Create a WorkflowStep model object and corresponding module
representing type-specific functionality from the incoming dictionary.
"""
step = model.WorkflowStep()
# TODO: Consider handling position inside module.
step.position = step_dict['position']
if step_dict.get("uuid", None) and step_dict['uuid'] != "None":
step.uuid = step_dict["uuid"]
if "label" in step_dict:
step.label = step_dict["label"]
step_type = step_dict.get("type", None)
if step_type == "subworkflow":
subworkflow = self.__load_subworkflow_from_step_dict(
trans, step_dict)
step_dict["subworkflow"] = subworkflow
module = module_factory.from_dict(trans, step_dict, **kwds)
self.__set_default_label(step, module, step_dict.get('tool_state'))
module.save_to_step(step)
annotation = step_dict['annotation']
if annotation:
annotation = sanitize_html(annotation, 'utf-8', 'text/html')
self.add_item_annotation(trans.sa_session, trans.get_user(), step,
annotation)
# Stick this in the step temporarily
step.temp_input_connections = step_dict['input_connections']
# Create the model class for the step
steps.append(step)
steps_by_external_id[step_dict['id']] = step
if 'workflow_outputs' in step_dict:
workflow_outputs = step_dict['workflow_outputs']
found_output_names = set([])
for workflow_output in workflow_outputs:
# Allow workflow outputs as list of output_names for backward compatiblity.
if not isinstance(workflow_output, dict):
workflow_output = {"output_name": workflow_output}
output_name = workflow_output["output_name"]
if output_name in found_output_names:
raise exceptions.ObjectAttributeInvalidException(
"Duplicate workflow outputs with name [%s] found." %
output_name)
if not output_name:
raise exceptions.ObjectAttributeInvalidException(
"Workflow output with empty name encountered.")
found_output_names.add(output_name)
uuid = workflow_output.get("uuid", None)
label = workflow_output.get("label", None)
m = step.create_or_update_workflow_output(
output_name=output_name,
uuid=uuid,
label=label,
)
trans.sa_session.add(m)
return module, step
def __module_from_dict( self, trans, steps, steps_by_external_id, step_dict, **kwds ):
""" Create a WorkflowStep model object and corresponding module
representing type-specific functionality from the incoming dictionary.
"""
step = model.WorkflowStep()
# TODO: Consider handling position inside module.
step.position = step_dict['position']
if step_dict.get("uuid", None) and step_dict['uuid'] != "None":
step.uuid = step_dict["uuid"]
if "label" in step_dict:
step.label = step_dict["label"]
step_type = step_dict.get("type", None)
if step_type == "subworkflow":
subworkflow = self.__load_subworkflow_from_step_dict(
trans, step_dict
)
step_dict["subworkflow"] = subworkflow
module = module_factory.from_dict( trans, step_dict, **kwds )
self.__set_default_label( step, module, step_dict.get( 'tool_state' ) )
module.save_to_step( step )
annotation = step_dict[ 'annotation' ]
if annotation:
annotation = sanitize_html( annotation, 'utf-8', 'text/html' )
self.add_item_annotation( trans.sa_session, trans.get_user(), step, annotation )
# Stick this in the step temporarily
step.temp_input_connections = step_dict['input_connections']
# Create the model class for the step
steps.append( step )
steps_by_external_id[ step_dict[ 'id' ] ] = step
if 'workflow_outputs' in step_dict:
workflow_outputs = step_dict['workflow_outputs']
found_output_names = set([])
for workflow_output in workflow_outputs:
# Allow workflow outputs as list of output_names for backward compatiblity.
if not isinstance(workflow_output, dict):
workflow_output = {"output_name": workflow_output}
output_name = workflow_output["output_name"]
if output_name in found_output_names:
raise exceptions.ObjectAttributeInvalidException("Duplicate workflow outputs with name [%s] found." % output_name)
if not output_name:
raise exceptions.ObjectAttributeInvalidException("Workflow output with empty name encountered.")
found_output_names.add(output_name)
uuid = workflow_output.get("uuid", None)
label = workflow_output.get("label", None)
m = step.create_or_update_workflow_output(
output_name=output_name,
uuid=uuid,
label=label,
)
trans.sa_session.add(m)
return module, step
def build_module(self, trans, payload={}):
"""
POST /api/workflows/build_module
Builds module models for the workflow editor.
"""
inputs = payload.get('inputs', {})
module = module_factory.from_dict(trans, payload)
module_state = {}
populate_state(trans, module.get_inputs(), inputs, module_state, check=False)
module.recover_state(module_state)
return {
'label' : inputs.get('__label', ''),
'annotation' : inputs.get('__annotation', ''),
'name' : module.get_name(),
'tool_state' : module.get_state(),
'data_inputs' : module.get_data_inputs(),
'data_outputs' : module.get_data_outputs(),
'config_form' : module.get_config_form(),
'post_job_actions' : module.get_post_job_actions(inputs)
}
def build_module( self, trans, payload={} ):
"""
POST /api/workflows/build_module
Builds module models for the workflow editor.
"""
inputs = payload.get( 'inputs', {} )
module = module_factory.from_dict( trans, payload )
module_state = {}
populate_state( trans, module.get_inputs(), inputs, module_state, check=False )
module.recover_state( module_state )
return {
'label' : inputs.get( '__label', '' ),
'annotation' : inputs.get( '__annotation', '' ),
'name' : module.get_name(),
'tool_state' : module.get_state(),
'data_inputs' : module.get_data_inputs(),
'data_outputs' : module.get_data_outputs(),
'config_form' : module.get_config_form(),
'post_job_actions' : module.get_post_job_actions( inputs )
}
def build_module(self, trans, payload={}):
"""
POST /api/workflows/build_module
Builds module models for the workflow editor.
"""
inputs = payload.get('inputs', {})
trans.workflow_building_mode = workflow_building_modes.ENABLED
module = module_factory.from_dict(trans, payload)
if 'tool_state' not in payload:
module_state = {}
populate_state(trans, module.get_inputs(), inputs, module_state, check=False)
module.recover_state(module_state)
return {
'label' : inputs.get('__label', ''),
'annotation' : inputs.get('__annotation', ''),
'name' : module.get_name(),
'tool_state' : module.get_state(),
'inputs' : module.get_all_inputs(connectable_only=True),
'outputs' : module.get_all_outputs(),
'config_form' : module.get_config_form(),
'post_job_actions' : module.get_post_job_actions(inputs)
}
def _workflow_from_dict(self, trans, data, source=None):
"""
RPARK: copied from galaxy.webapps.galaxy.controllers.workflows.py
Creates a workflow from a dict. Created workflow is stored in the database and returned.
"""
# Put parameters in workflow mode
trans.workflow_building_mode = True
# Create new workflow from incoming dict
workflow = model.Workflow()
# If there's a source, put it in the workflow name.
if source:
name = "%s (imported from %s)" % (data["name"], source)
else:
name = data["name"]
workflow.name = name
# Assume no errors until we find a step that has some
workflow.has_errors = False
# Create each step
steps = []
# The editor will provide ids for each step that we don't need to save,
# but do need to use to make connections
steps_by_external_id = {}
# Keep track of tools required by the workflow that are not available in
# the local Galaxy instance. Each tuple in the list of missing_tool_tups
# will be ( tool_id, tool_name, tool_version ).
missing_tool_tups = []
# First pass to build step objects and populate basic values
for key, step_dict in data["steps"].iteritems():
# Create the model class for the step
step = model.WorkflowStep()
steps.append(step)
steps_by_external_id[step_dict["id"]] = step
# FIXME: Position should be handled inside module
step.position = step_dict["position"]
module = module_factory.from_dict(trans, step_dict, secure=False)
if module.type == "tool" and module.tool is None:
# A required tool is not available in the local Galaxy instance.
missing_tool_tup = (step_dict["tool_id"], step_dict["name"], step_dict["tool_version"])
if missing_tool_tup not in missing_tool_tups:
missing_tool_tups.append(missing_tool_tup)
module.save_to_step(step)
if step.tool_errors:
workflow.has_errors = True
# Stick this in the step temporarily
step.temp_input_connections = step_dict["input_connections"]
# Save step annotation.
# annotation = step_dict[ 'annotation' ]
# if annotation:
# annotation = sanitize_html( annotation, 'utf-8', 'text/html' )
# ------------------------------------------ #
# RPARK REMOVING: user annotation b/c of API
# self.add_item_annotation( trans.sa_session, trans.get_user(), step, annotation )
# ------------------------------------------ #
# Unpack and add post-job actions.
post_job_actions = step_dict.get("post_job_actions", {})
for name, pja_dict in post_job_actions.items():
model.PostJobAction(
pja_dict["action_type"], step, pja_dict["output_name"], pja_dict["action_arguments"]
)
# Second pass to deal with connections between steps
for step in steps:
# Input connections
for input_name, conn_dict in step.temp_input_connections.iteritems():
if conn_dict:
conn = model.WorkflowStepConnection()
conn.input_step = step
conn.input_name = input_name
conn.output_name = conn_dict["output_name"]
conn.output_step = steps_by_external_id[conn_dict["id"]]
del step.temp_input_connections
# Order the steps if possible
attach_ordered_steps(workflow, steps)
# Connect up
stored = model.StoredWorkflow()
stored.name = workflow.name
workflow.stored_workflow = stored
stored.latest_workflow = workflow
stored.user = trans.user
# Persist
trans.sa_session.add(stored)
trans.sa_session.flush()
return stored, missing_tool_tups
def _workflow_from_dict(self, trans, data, source=None):
"""
RPARK: copied from galaxy.webapps.galaxy.controllers.workflows.py
Creates a workflow from a dict. Created workflow is stored in the database and returned.
"""
# Put parameters in workflow mode
trans.workflow_building_mode = True
# Create new workflow from incoming dict
workflow = model.Workflow()
# If there's a source, put it in the workflow name.
if source:
name = "%s (imported from %s)" % (data['name'], source)
else:
name = data['name']
workflow.name = name
# Assume no errors until we find a step that has some
workflow.has_errors = False
# Create each step
steps = []
# The editor will provide ids for each step that we don't need to save,
# but do need to use to make connections
steps_by_external_id = {}
# Keep track of tools required by the workflow that are not available in
# the local Galaxy instance. Each tuple in the list of missing_tool_tups
# will be ( tool_id, tool_name, tool_version ).
missing_tool_tups = []
# First pass to build step objects and populate basic values
for key, step_dict in data['steps'].iteritems():
# Create the model class for the step
step = model.WorkflowStep()
steps.append(step)
steps_by_external_id[step_dict['id']] = step
# FIXME: Position should be handled inside module
step.position = step_dict['position']
module = module_factory.from_dict(trans, step_dict, secure=False)
if module.type == 'tool' and module.tool is None:
# A required tool is not available in the local Galaxy instance.
missing_tool_tup = (step_dict['tool_id'], step_dict['name'],
step_dict['tool_version'])
if missing_tool_tup not in missing_tool_tups:
missing_tool_tups.append(missing_tool_tup)
module.save_to_step(step)
if step.tool_errors:
workflow.has_errors = True
# Stick this in the step temporarily
step.temp_input_connections = step_dict['input_connections']
# Save step annotation.
#annotation = step_dict[ 'annotation' ]
#if annotation:
#annotation = sanitize_html( annotation, 'utf-8', 'text/html' )
# ------------------------------------------ #
# RPARK REMOVING: user annotation b/c of API
#self.add_item_annotation( trans.sa_session, trans.get_user(), step, annotation )
# ------------------------------------------ #
# Unpack and add post-job actions.
post_job_actions = step_dict.get('post_job_actions', {})
for name, pja_dict in post_job_actions.items():
model.PostJobAction(pja_dict['action_type'], step,
pja_dict['output_name'],
pja_dict['action_arguments'])
# Second pass to deal with connections between steps
for step in steps:
# Input connections
for input_name, conn_dict in step.temp_input_connections.iteritems(
):
if conn_dict:
conn = model.WorkflowStepConnection()
conn.input_step = step
conn.input_name = input_name
conn.output_name = conn_dict['output_name']
conn.output_step = steps_by_external_id[conn_dict['id']]
del step.temp_input_connections
# Order the steps if possible
attach_ordered_steps(workflow, steps)
# Connect up
stored = model.StoredWorkflow()
stored.name = workflow.name
workflow.stored_workflow = stored
stored.latest_workflow = workflow
stored.user = trans.user
# Persist
trans.sa_session.add(stored)
trans.sa_session.flush()
return stored, missing_tool_tups
