def __to_incoming(self, state, **kwds): new_incoming = {} params_to_incoming(new_incoming, self.tool.inputs, state.inputs, self.app) new_incoming["tool_state"] = self.__state_to_string(state) new_incoming.update(kwds) return new_incoming
def __to_incoming( self, state, **kwds ): new_incoming = {} params_to_incoming( new_incoming, self.tool.inputs, state.inputs, self.app ) # Copy meta parameters over lost by params_to_incoming... for key, value in state.inputs.iteritems(): if key.endswith( "|__multirun__" ): new_incoming[ key ] = value new_incoming[ "tool_state" ] = self.__state_to_string( state ) new_incoming.update( kwds ) return new_incoming
def __to_incoming(self, state, **kwds): new_incoming = {} params_to_incoming(new_incoming, self.tool.inputs, state.inputs, self.app) # Copy meta parameters over lost by params_to_incoming... for key, value in state.inputs.iteritems(): if key.endswith("|__multirun__"): new_incoming[key] = value new_incoming["tool_state"] = self.__state_to_string(state) new_incoming.update(kwds) return new_incoming
def render_body(context, **pageargs): context.caller_stack._push_frame() try: __M_locals = __M_dict_builtin(pageargs=pageargs) h = context.get("h", UNDEFINED) tool = context.get("tool", UNDEFINED) module = context.get("module", UNDEFINED) job = context.get("job", UNDEFINED) trans = context.get("trans", UNDEFINED) self = context.get("self", UNDEFINED) __M_writer = context.writer() # SOURCE LINE 1 ## TEMPORARY: create tool dictionary in mako while both tool forms are in use. ## This avoids making two separate requests since the classic form requires the mako anyway. from galaxy.tools.parameters import params_to_incoming incoming = {} params_to_incoming(incoming, tool.inputs, module.state.inputs, trans.app, to_html=False) self.form_config = tool.to_json(trans, incoming, is_workflow=True) self.form_config.update( { "id": tool.id, "job_id": trans.security.encode_id(job.id) if job else None, "history_id": trans.security.encode_id(trans.history.id), "container": "#right-content", } ) __M_locals_builtin_stored = __M_locals_builtin() __M_locals.update( __M_dict_builtin( [ (__M_key, __M_locals_builtin_stored[__M_key]) for __M_key in ["params_to_incoming", "incoming"] if __M_key in __M_locals_builtin_stored ] ) ) # SOURCE LINE 14 __M_writer(u"\n") # SOURCE LINE 15 __M_writer(unicode(h.dumps(self.form_config))) return "" finally: context.caller_stack._pop_frame()
def _workflow_to_dict_run(self, trans, stored): """ Builds workflow dictionary used by run workflow form """ workflow = stored.latest_workflow if len(workflow.steps) == 0: raise exceptions.MessageException( 'Workflow cannot be run because it does not have any steps.') if attach_ordered_steps(workflow, workflow.steps): raise exceptions.MessageException( 'Workflow cannot be run because it contains cycles.') trans.workflow_building_mode = workflow_building_modes.USE_HISTORY module_injector = WorkflowModuleInjector(trans) has_upgrade_messages = False step_version_changes = [] missing_tools = [] errors = {} for step in workflow.steps: try: module_injector.inject(step, steps=workflow.steps, exact_tools=False) except exceptions.ToolMissingException: if step.tool_id not in missing_tools: missing_tools.append(step.tool_id) continue if step.upgrade_messages: has_upgrade_messages = True if step.type == 'tool' or step.type is None: if step.module.version_changes: step_version_changes.extend(step.module.version_changes) step_errors = step.module.get_errors() if step_errors: errors[step.id] = step_errors if missing_tools: workflow.annotation = self.get_item_annotation_str( trans.sa_session, trans.user, workflow) raise exceptions.MessageException('Following tools missing: %s' % ', '.join(missing_tools)) workflow.annotation = self.get_item_annotation_str( trans.sa_session, trans.user, workflow) step_order_indices = {} for step in workflow.steps: step_order_indices[step.id] = step.order_index step_models = [] for i, step in enumerate(workflow.steps): step_model = None if step.type == 'tool': incoming = {} tool = trans.app.toolbox.get_tool( step.tool_id, tool_version=step.tool_version) params_to_incoming(incoming, tool.inputs, step.state.inputs, trans.app) step_model = tool.to_json( trans, incoming, workflow_building_mode=workflow_building_modes.USE_HISTORY) step_model['post_job_actions'] = [{ 'short_str': ActionBox.get_short_str(pja), 'action_type': pja.action_type, 'output_name': pja.output_name, 'action_arguments': pja.action_arguments } for pja in step.post_job_actions] else: inputs = step.module.get_runtime_inputs( connections=step.output_connections) step_model = { 'inputs': [input.to_dict(trans) for input in inputs.values()] } step_model['step_type'] = step.type step_model['step_label'] = step.label step_model['step_name'] = step.module.get_name() step_model['step_version'] = step.module.get_version() step_model['step_index'] = step.order_index step_model['output_connections'] = [{ 'input_step_index': step_order_indices.get(oc.input_step_id), 'output_step_index': step_order_indices.get(oc.output_step_id), 'input_name': oc.input_name, 'output_name': oc.output_name } for oc in step.output_connections] if step.annotations: step_model['annotation'] = step.annotations[0].annotation if step.upgrade_messages: step_model['messages'] = step.upgrade_messages step_models.append(step_model) return { 'id': trans.app.security.encode_id(stored.id), 'history_id': trans.app.security.encode_id(trans.history.id) if trans.history else None, 'name': stored.name, 'steps': step_models, 'step_version_changes': step_version_changes, 'has_upgrade_messages': has_upgrade_messages, 'workflow_resource_parameters': self._workflow_resource_parameters(trans, stored, workflow), }
def rerun(self, trans, id=None, from_noframe=None, **kwd): """ Given a HistoryDatasetAssociation id, find the job and that created the dataset, extract the parameters, and display the appropriate tool form with parameters already filled in. """ if not id: error("'id' parameter is required") try: id = int(id) except: # it's not an un-encoded id, try to parse as encoded try: id = trans.security.decode_id(id) except: error("Invalid value for 'id' parameter") # Get the dataset object data = trans.sa_session.query( trans.app.model.HistoryDatasetAssociation).get(id) #only allow rerunning if user is allowed access to the dataset. if not (trans.user_is_admin() or trans.app.security_agent.can_access_dataset( trans.get_current_user_roles(), data.dataset)): error("You are not allowed to access this dataset") # Get the associated job, if any. job = data.creating_job if not job: raise Exception( "Failed to get job information for dataset hid %d" % data.hid) # Get the tool object tool_id = job.tool_id tool_version = job.tool_version try: tool_version_select_field, tools, tool = self.__get_tool_components( tool_id, tool_version=tool_version, get_loaded_tools_by_lineage=False, set_selected=True) if (tool.id == job.tool_id or tool.old_id == job.tool_id) and tool.version == job.tool_version: tool_id_version_message = '' elif tool.id == job.tool_id: if job.tool_version == None: # For some reason jobs don't always keep track of the tool version. tool_id_version_message = '' else: tool_id_version_message = 'This job was initially run with tool version "%s", which is not currently available. ' % job.tool_version if len(tools) > 1: tool_id_version_message += 'You can rerun the job with the selected tool or choose another derivation of the tool.' else: tool_id_version_message += 'You can rerun the job with this tool version, which is a derivation of the original tool.' else: if len(tools) > 1: tool_id_version_message = 'This job was initially run with tool version "%s", which is not currently available. ' % job.tool_version tool_id_version_message += 'You can rerun the job with the selected tool or choose another derivation of the tool.' else: tool_id_version_message = 'This job was initially run with tool id "%s", version "%s", which is not ' % ( job.tool_id, job.tool_version) tool_id_version_message += 'currently available. You can rerun the job with this tool, which is a derivation of the original tool.' assert tool is not None, 'Requested tool has not been loaded.' except: # This is expected so not an exception. tool_id_version_message = '' error( "This dataset was created by an obsolete tool (%s). Can't re-run." % tool_id) # Can't rerun upload, external data sources, et cetera. Workflow compatible will proxy this for now if not tool.is_workflow_compatible: error("The '%s' tool does not currently support rerunning." % tool.name) # Get the job's parameters try: params_objects = job.get_param_values(trans.app, ignore_errors=True) except: raise Exception("Failed to get parameters for dataset id %d " % data.id) upgrade_messages = tool.check_and_update_param_values( params_objects, trans, update_values=False) # Need to remap dataset parameters. Job parameters point to original # dataset used; parameter should be the analygous dataset in the # current history. history = trans.get_history() hda_source_dict = {} # Mapping from HDA in history to source HDAs. for hda in history.datasets: source_hda = hda.copied_from_history_dataset_association while source_hda: #should this check library datasets as well? #FIXME: could be multiple copies of a hda in a single history, this does a better job of matching on cloned histories, #but is still less than perfect when eg individual datasets are copied between histories if source_hda not in hda_source_dict or source_hda.hid == hda.hid: hda_source_dict[source_hda] = hda source_hda = source_hda.copied_from_history_dataset_association # Unpack unvalidated values to strings, they'll be validated when the # form is submitted (this happens when re-running a job that was # initially run by a workflow) #This needs to be done recursively through grouping parameters def rerun_callback(input, value, prefixed_name, prefixed_label): if isinstance(value, UnvalidatedValue): return str(value) if isinstance(input, DataToolParameter): if isinstance(value, list): values = [] for val in value: if is_hashable(val): if val in history.datasets: values.append(val) elif val in hda_source_dict: values.append(hda_source_dict[val]) return values if is_hashable( value ) and value not in history.datasets and value in hda_source_dict: return hda_source_dict[value] visit_input_values(tool.inputs, params_objects, rerun_callback) # Create a fake tool_state for the tool, with the parameters values state = tool.new_state(trans) state.inputs = params_objects # If the job failed and has dependencies, allow dependency remap if job.state == job.states.ERROR: try: if [ hda.dependent_jobs for hda in [jtod.dataset for jtod in job.output_datasets] if hda.dependent_jobs ]: state.rerun_remap_job_id = trans.app.security.encode_id( job.id) except: # Job has no outputs? pass #create an incoming object from the original job's dataset-modified param objects incoming = {} params_to_incoming(incoming, tool.inputs, params_objects, trans.app) incoming["tool_state"] = galaxy.util.object_to_string( state.encode(tool, trans.app)) template, vars = tool.handle_input( trans, incoming, old_errors=upgrade_messages) #update new state with old parameters # Is the "add frame" stuff neccesary here? add_frame = AddFrameData() add_frame.debug = trans.debug if from_noframe is not None: add_frame.wiki_url = trans.app.config.wiki_url add_frame.from_noframe = True return trans.fill_template( template, history=history, toolbox=self.get_toolbox(), tool_version_select_field=tool_version_select_field, tool=tool, util=galaxy.util, add_frame=add_frame, tool_id_version_message=tool_id_version_message, **vars)
def rerun( self, trans, id=None, from_noframe=None, **kwd ): """ Given a HistoryDatasetAssociation id, find the job and that created the dataset, extract the parameters, and display the appropriate tool form with parameters already filled in. """ if not id: error( "'id' parameter is required" ); try: id = int( id ) except: # it's not an un-encoded id, try to parse as encoded try: id = trans.security.decode_id( id ) except: error( "Invalid value for 'id' parameter" ) # Get the dataset object data = trans.sa_session.query( trans.app.model.HistoryDatasetAssociation ).get( id ) #only allow rerunning if user is allowed access to the dataset. if not ( trans.user_is_admin() or trans.app.security_agent.can_access_dataset( trans.get_current_user_roles(), data.dataset ) ): error( "You are not allowed to access this dataset" ) # Get the associated job, if any. job = data.creating_job if not job: raise Exception("Failed to get job information for dataset hid %d" % data.hid) # Get the tool object tool_id = job.tool_id tool_version = job.tool_version try: tool_version_select_field, tools, tool = self.__get_tool_components( tool_id, tool_version=tool_version, get_loaded_tools_by_lineage=False, set_selected=True ) if ( tool.id == job.tool_id or tool.old_id == job.tool_id ) and tool.version == job.tool_version: tool_id_version_message = '' elif tool.id == job.tool_id: if job.tool_version == None: # For some reason jobs don't always keep track of the tool version. tool_id_version_message = '' else: tool_id_version_message = 'This job was initially run with tool version "%s", which is not currently available. ' % job.tool_version if len( tools ) > 1: tool_id_version_message += 'You can rerun the job with the selected tool or choose another derivation of the tool.' else: tool_id_version_message += 'You can rerun the job with this tool version, which is a derivation of the original tool.' else: if len( tools ) > 1: tool_id_version_message = 'This job was initially run with tool version "%s", which is not currently available. ' % job.tool_version tool_id_version_message += 'You can rerun the job with the selected tool or choose another derivation of the tool.' else: tool_id_version_message = 'This job was initially run with tool id "%s", version "%s", which is not ' % ( job.tool_id, job.tool_version ) tool_id_version_message += 'currently available. You can rerun the job with this tool, which is a derivation of the original tool.' assert tool is not None, 'Requested tool has not been loaded.' except: # This is expected so not an exception. tool_id_version_message = '' error( "This dataset was created by an obsolete tool (%s). Can't re-run." % tool_id ) # Can't rerun upload, external data sources, et cetera. Workflow compatible will proxy this for now if not tool.is_workflow_compatible: error( "The '%s' tool does not currently support rerunning." % tool.name ) # Get the job's parameters try: params_objects = job.get_param_values( trans.app, ignore_errors = True ) except: raise Exception( "Failed to get parameters for dataset id %d " % data.id ) upgrade_messages = tool.check_and_update_param_values( params_objects, trans, update_values=False ) # Need to remap dataset parameters. Job parameters point to original # dataset used; parameter should be the analygous dataset in the # current history. history = trans.get_history() hda_source_dict = {} # Mapping from HDA in history to source HDAs. for hda in history.datasets: source_hda = hda.copied_from_history_dataset_association while source_hda:#should this check library datasets as well? #FIXME: could be multiple copies of a hda in a single history, this does a better job of matching on cloned histories, #but is still less than perfect when eg individual datasets are copied between histories if source_hda not in hda_source_dict or source_hda.hid == hda.hid: hda_source_dict[ source_hda ] = hda source_hda = source_hda.copied_from_history_dataset_association # Unpack unvalidated values to strings, they'll be validated when the # form is submitted (this happens when re-running a job that was # initially run by a workflow) #This needs to be done recursively through grouping parameters def rerun_callback( input, value, prefixed_name, prefixed_label ): if isinstance( value, UnvalidatedValue ): return str( value ) if isinstance( input, DataToolParameter ): if isinstance(value,list): values = [] for val in value: if is_hashable( val ): if val in history.datasets: values.append( val ) elif val in hda_source_dict: values.append( hda_source_dict[ val ]) return values if is_hashable( value ) and value not in history.datasets and value in hda_source_dict: return hda_source_dict[ value ] visit_input_values( tool.inputs, params_objects, rerun_callback ) # Create a fake tool_state for the tool, with the parameters values state = tool.new_state( trans ) state.inputs = params_objects # If the job failed and has dependencies, allow dependency remap if job.state == job.states.ERROR: try: if [ hda.dependent_jobs for hda in [ jtod.dataset for jtod in job.output_datasets ] if hda.dependent_jobs ]: state.rerun_remap_job_id = trans.app.security.encode_id(job.id) except: # Job has no outputs? pass #create an incoming object from the original job's dataset-modified param objects incoming = {} params_to_incoming( incoming, tool.inputs, params_objects, trans.app ) incoming[ "tool_state" ] = galaxy.util.object_to_string( state.encode( tool, trans.app ) ) template, vars = tool.handle_input( trans, incoming, old_errors=upgrade_messages ) #update new state with old parameters # Is the "add frame" stuff neccesary here? add_frame = AddFrameData() add_frame.debug = trans.debug if from_noframe is not None: add_frame.wiki_url = trans.app.config.wiki_url add_frame.from_noframe = True return trans.fill_template( template, history=history, toolbox=self.get_toolbox(), tool_version_select_field=tool_version_select_field, tool=tool, util=galaxy.util, add_frame=add_frame, tool_id_version_message=tool_id_version_message, **vars )
def get_config_form(self): if self.tool: self.add_dummy_datasets() incoming = {} params_to_incoming(incoming, self.tool.inputs, self.state.inputs, self.trans.app) return self.tool.to_json(self.trans, incoming, workflow_building_mode=True)
class ToolRunner(BaseUIController): # Hack to get biomart to work, ideally, we could pass tool_id to biomart and receive it back @web.expose def biomart(self, trans, tool_id='biomart', **kwd): """Catches the tool id and redirects as needed""" return self.index(trans, tool_id=tool_id, **kwd) # test to get hapmap to work, ideally, we could pass tool_id to hapmap biomart and receive it back @web.expose def hapmapmart(self, trans, tool_id='hapmapmart', **kwd): """Catches the tool id and redirects as needed""" return self.index(trans, tool_id=tool_id, **kwd) @web.expose def default(self, trans, tool_id=None, **kwd): """Catches the tool id and redirects as needed""" return self.index(trans, tool_id=tool_id, **kwd) def __get_tool_components(self, tool_id, tool_version=None, get_loaded_tools_by_lineage=False, set_selected=False): return self.get_toolbox().get_tool_components( tool_id, tool_version, get_loaded_tools_by_lineage, set_selected) @web.expose def index(self, trans, tool_id=None, from_noframe=None, **kwd): # No tool id passed, redirect to main page if tool_id is None: return trans.response.send_redirect( url_for(controller="root", action="welcome")) # When the tool form is initially loaded, the received kwd will not include a 'refresh' # entry (which only is included when another option is selected in the tool_version_select_field), # so the default selected option should be the most recent version of the tool. The following # check will mae sure this occurs. refreshed_on_change = kwd.get('refresh', False) tool_version_select_field, tools, tool = self.__get_tool_components( tool_id, tool_version=None, get_loaded_tools_by_lineage=False, set_selected=refreshed_on_change) # No tool matching the tool id, display an error (shouldn't happen) if not tool or not tool.allow_user_access(trans.user): log.error("index called with tool id '%s' but no such tool exists", tool_id) trans.log_event("Tool id '%s' does not exist" % tool_id) trans.response.status = 404 return trans.show_error_message("Tool '%s' does not exist." % (escape(tool_id))) if tool.require_login and not trans.user: message = "You must be logged in to use this tool." status = "info" redirect = url_for(controller='tool_runner', action='index', tool_id=tool_id, **kwd) return trans.response.send_redirect( url_for(controller='user', action='login', cntrller='user', message=message, status=status, redirect=redirect)) def _validated_params_for(kwd): params = galaxy.util.Params( kwd, sanitize=False ) # Sanitize parameters when substituting into command line via input wrappers # do param translation here, used by datasource tools if tool.input_translator: tool.input_translator.translate(params) return params params = _validated_params_for(kwd) # We may be visiting Galaxy for the first time ( e.g., sending data from UCSC ), # so make sure to create a new history if we've never had one before. history = tool.get_default_history_by_trans(trans, create=True) try: template, vars = tool.handle_input(trans, params.__dict__) except KeyError: # This error indicates (or at least can indicate) there was a # problem with the stored tool_state - it is incompatible with # this variant of the tool - possibly because the tool changed # or because the tool version changed. del kwd["tool_state"] params = _validated_params_for(kwd) template, vars = tool.handle_input(trans, params.__dict__) if len(params) > 0: trans.log_event("Tool params: %s" % (str(params)), tool_id=tool_id) add_frame = AddFrameData() add_frame.debug = trans.debug if from_noframe is not None: add_frame.wiki_url = trans.app.config.wiki_url add_frame.from_noframe = True return trans.fill_template( template, history=history, toolbox=self.get_toolbox(), tool_version_select_field=tool_version_select_field, tool=tool, util=galaxy.util, add_frame=add_frame, form_input_auto_focus=True, **vars) @web.expose def rerun(self, trans, id=None, from_noframe=None, job_id=None, **kwd): """ Given a HistoryDatasetAssociation id, find the job and that created the dataset, extract the parameters, and display the appropriate tool form with parameters already filled in. """ if job_id: try: job_id = trans.security.decode_id(job_id) job = trans.sa_session.query(trans.app.model.Job).get(job_id) except: error("Invalid value for 'job_id' parameter") if not trans.user_is_admin(): for data_assoc in job.output_datasets: # only allow rerunning if user is allowed access to the dataset. if not trans.app.security_agent.can_access_dataset( trans.get_current_user_roles(), data_assoc.dataset.dataset): error("You are not allowed to rerun this job") param_error_text = "Failed to get parameters for job id %d " % job_id else: if not id: error("'id' parameter is required") try: id = int(id) except: # it's not an un-encoded id, try to parse as encoded try: id = trans.security.decode_id(id) except: error("Invalid value for 'id' parameter") # Get the dataset object data = trans.sa_session.query( trans.app.model.HistoryDatasetAssociation).get(id) # only allow rerunning if user is allowed access to the dataset. if not (trans.user_is_admin() or trans.app.security_agent.can_access_dataset( trans.get_current_user_roles(), data.dataset)): error("You are not allowed to access this dataset") # Get the associated job, if any. job = data.creating_job if not job: raise Exception( "Failed to get job information for dataset hid %d" % data.hid) param_error_text = "Failed to get parameters for dataset id %d " % data.id # Get the tool object tool_id = job.tool_id tool_version = job.tool_version try: tool_version_select_field, tools, tool = self.__get_tool_components( tool_id, tool_version=tool_version, get_loaded_tools_by_lineage=False, set_selected=True) if (tool.id == job.tool_id or tool.old_id == job.tool_id) and tool.version == job.tool_version: tool_id_version_message = '' elif tool.id == job.tool_id: if job.tool_version is None: # For some reason jobs don't always keep track of the tool version. tool_id_version_message = '' else: tool_id_version_message = 'This job was initially run with tool version "%s", which is not currently available. ' % job.tool_version if len(tools) > 1: tool_id_version_message += 'You can rerun the job with the selected tool or choose another derivation of the tool.' else: tool_id_version_message += 'You can rerun the job with this tool version, which is a derivation of the original tool.' else: if len(tools) > 1: tool_id_version_message = 'This job was initially run with tool version "%s", which is not currently available. ' % job.tool_version tool_id_version_message += 'You can rerun the job with the selected tool or choose another derivation of the tool.' else: tool_id_version_message = 'This job was initially run with tool id "%s", version "%s", which is not ' % ( job.tool_id, job.tool_version) tool_id_version_message += 'currently available. You can rerun the job with this tool, which is a derivation of the original tool.' assert tool is not None, 'Requested tool has not been loaded.' except: # This is expected so not an exception. tool_id_version_message = '' error( "This dataset was created by an obsolete tool (%s). Can't re-run." % tool_id) if not tool.allow_user_access(trans.user): error("The requested tool is unknown.") # Can't rerun upload, external data sources, et cetera. Workflow compatible will proxy this for now if not tool.is_workflow_compatible: error("The '%s' tool does not currently support rerunning." % tool.name) # Get the job's parameters try: params_objects = job.get_param_values(trans.app, ignore_errors=True) except: raise Exception(param_error_text) upgrade_messages = tool.check_and_update_param_values( params_objects, trans, update_values=False) # Need to remap dataset parameters. Job parameters point to original # dataset used; parameter should be the analygous dataset in the # current history. history = trans.get_history() hda_source_dict = {} # Mapping from HDA in history to source HDAs. for hda in history.datasets: source_hda = hda.copied_from_history_dataset_association while source_hda: # should this check library datasets as well? # FIXME: could be multiple copies of a hda in a single history, this does a better job of matching on cloned histories, # but is still less than perfect when eg individual datasets are copied between histories if source_hda not in hda_source_dict or source_hda.hid == hda.hid: hda_source_dict[source_hda] = hda source_hda = source_hda.copied_from_history_dataset_association # Ditto for dataset collections. hdca_source_dict = {} for hdca in history.dataset_collections: source_hdca = hdca.copied_from_history_dataset_collection_association while source_hdca: if source_hdca not in hdca_source_dict or source_hdca.hid == hdca.hid: hdca_source_dict[source_hdca] = hdca source_hdca = source_hdca.copied_from_history_dataset_collection_association # Unpack unvalidated values to strings, they'll be validated when the # form is submitted (this happens when re-running a job that was # initially run by a workflow) # This needs to be done recursively through grouping parameters def rerun_callback(input, value, prefixed_name, prefixed_label): if isinstance(value, UnvalidatedValue): try: return input.to_html_value(value.value, trans.app) except Exception, e: # Need to determine when (if ever) the to_html_value call could fail. log.debug( "Failed to use input.to_html_value to determine value of unvalidated parameter, defaulting to string: %s" % (e)) return str(value) if isinstance(input, DataToolParameter): if isinstance(value, list): values = [] for val in value: if is_hashable(val): if val in history.datasets: values.append(val) elif val in hda_source_dict: values.append(hda_source_dict[val]) return values if is_hashable( value ) and value not in history.datasets and value in hda_source_dict: return hda_source_dict[value] elif isinstance(input, DataCollectionToolParameter): if is_hashable( value ) and value not in history.dataset_collections and value in hdca_source_dict: return hdca_source_dict[value] visit_input_values(tool.inputs, params_objects, rerun_callback) # Create a fake tool_state for the tool, with the parameters values state = tool.new_state(trans) state.inputs = params_objects # If the job failed and has dependencies, allow dependency remap if job.state == job.states.ERROR: try: if [ hda.dependent_jobs for hda in [jtod.dataset for jtod in job.output_datasets] if hda.dependent_jobs ]: state.rerun_remap_job_id = trans.app.security.encode_id( job.id) except: # Job has no outputs? pass # create an incoming object from the original job's dataset-modified param objects incoming = {} params_to_incoming(incoming, tool.inputs, params_objects, trans.app) incoming["tool_state"] = galaxy.util.object_to_string( state.encode(tool, trans.app)) template, vars = tool.handle_input( trans, incoming, old_errors=upgrade_messages ) # update new state with old parameters # Is the "add frame" stuff neccesary here? add_frame = AddFrameData() add_frame.debug = trans.debug if from_noframe is not None: add_frame.wiki_url = trans.app.config.wiki_url add_frame.from_noframe = True return trans.fill_template( template, history=history, toolbox=self.get_toolbox(), tool_version_select_field=tool_version_select_field, tool=tool, job=job, util=galaxy.util, add_frame=add_frame, tool_id_version_message=tool_id_version_message, **vars)
def _workflow_to_dict_run(self, trans, stored): """ Builds workflow dictionary used by run workflow form """ workflow = stored.latest_workflow if len(workflow.steps) == 0: raise exceptions.MessageException('Workflow cannot be run because it does not have any steps.') if attach_ordered_steps(workflow, workflow.steps): raise exceptions.MessageException('Workflow cannot be run because it contains cycles.') trans.workflow_building_mode = workflow_building_modes.USE_HISTORY module_injector = WorkflowModuleInjector(trans) has_upgrade_messages = False step_version_changes = [] missing_tools = [] errors = {} for step in workflow.steps: try: module_injector.inject(step, steps=workflow.steps, exact_tools=False) except exceptions.ToolMissingException: if step.tool_id not in missing_tools: missing_tools.append(step.tool_id) continue if step.upgrade_messages: has_upgrade_messages = True if step.type == 'tool' or step.type is None: if step.module.version_changes: step_version_changes.extend(step.module.version_changes) step_errors = step.module.get_errors() if step_errors: errors[step.id] = step_errors if missing_tools: workflow.annotation = self.get_item_annotation_str(trans.sa_session, trans.user, workflow) raise exceptions.MessageException('Following tools missing: %s' % missing_tools) workflow.annotation = self.get_item_annotation_str(trans.sa_session, trans.user, workflow) step_order_indices = {} for step in workflow.steps: step_order_indices[step.id] = step.order_index step_models = [] for i, step in enumerate(workflow.steps): step_model = None if step.type == 'tool': incoming = {} tool = trans.app.toolbox.get_tool(step.tool_id, tool_version=step.tool_version) params_to_incoming(incoming, tool.inputs, step.state.inputs, trans.app) step_model = tool.to_json(trans, incoming, workflow_building_mode=workflow_building_modes.USE_HISTORY) step_model['post_job_actions'] = [{ 'short_str' : ActionBox.get_short_str(pja), 'action_type' : pja.action_type, 'output_name' : pja.output_name, 'action_arguments' : pja.action_arguments } for pja in step.post_job_actions] else: inputs = step.module.get_runtime_inputs(connections=step.output_connections) step_model = { 'inputs' : [input.to_dict(trans) for input in inputs.values()] } step_model['step_type'] = step.type step_model['step_label'] = step.label step_model['step_name'] = step.module.get_name() step_model['step_version'] = step.module.get_version() step_model['step_index'] = step.order_index step_model['output_connections'] = [{ 'input_step_index' : step_order_indices.get(oc.input_step_id), 'output_step_index' : step_order_indices.get(oc.output_step_id), 'input_name' : oc.input_name, 'output_name' : oc.output_name } for oc in step.output_connections] if step.annotations: step_model['annotation'] = step.annotations[0].annotation if step.upgrade_messages: step_model['messages'] = step.upgrade_messages step_models.append(step_model) return { 'id': trans.app.security.encode_id(stored.id), 'history_id': trans.app.security.encode_id(trans.history.id) if trans.history else None, 'name': stored.name, 'steps': step_models, 'step_version_changes': step_version_changes, 'has_upgrade_messages': has_upgrade_messages, 'workflow_resource_parameters': self._workflow_resource_parameters(trans, stored, workflow), }
job = data.creating_job if not job: trans.response.status = 500 return { 'error': 'Creating job not found.' } except Exception, exception: trans.response.status = 500 return { 'error': 'Failed to get job information.' } # load job parameters into incoming tool_message = '' if job: try: job_params = job.get_param_values( trans.app, ignore_errors = True ) job_messages = tool.check_and_update_param_values( job_params, trans, update_values=False ) tool_message = self._compare_tool_version(trans, tool, job) params_to_incoming( kwd, tool.inputs, job_params, trans.app ) except Exception, exception: trans.response.status = 500 return { 'error': str( exception ) } # create parameter object params = galaxy.util.Params( kwd, sanitize = False ) # convert value to jsonifiable value def convert(v): # check if value is numeric isnumber = False try: float(v) isnumber = True except Exception:
def get_config_form( self ): if self.tool: self.add_dummy_datasets() incoming = {} params_to_incoming( incoming, self.tool.inputs, self.state.inputs, self.trans.app ) return self.tool.to_json( self.trans, incoming, workflow_building_mode=True )