diff --git a/lib/galaxy/tools/__init__.py b/lib/galaxy/tools/__init__.py index 8668e4bf6b33..be9c608a8e03 100755 --- a/lib/galaxy/tools/__init__.py +++ b/lib/galaxy/tools/__init__.py @@ -53,6 +53,7 @@ from galaxy.web import url_for from galaxy.web.form_builder import SelectField from galaxy.util.dictifiable import Dictifiable +from galaxy.work.context import WorkRequestContext from tool_shed.util import common_util from tool_shed.util import shed_util_common as suc @@ -2076,17 +2077,22 @@ def to_json(self, trans, kwd={}, job=None, workflow_mode=False): except Exception, e: raise exceptions.MessageException( '[history_id=%s] Failed to retrieve history. %s.' % ( history_id, str( e ) ) ) - # set workflow mode ( TODO: Should be revised/parsed without trans to tool parameters (basic.py) ) - trans.workflow_building_mode = workflow_mode + # build request context + request_context = WorkRequestContext( + app = trans.app, + user = trans.user, + history = history, + workflow_building_mode = workflow_mode + ) # load job parameters into incoming tool_message = '' if job: try: job_params = job.get_param_values( self.app, ignore_errors=True ) - self.check_and_update_param_values( job_params, trans, update_values=False ) - self._map_source_to_history( trans, self.inputs, job_params, history ) - tool_message = self._compare_tool_version(trans, job) + self.check_and_update_param_values( job_params, request_context, update_values=False ) + self._map_source_to_history( request_context, self.inputs, job_params, history ) + tool_message = self._compare_tool_version( job ) params_to_incoming( kwd, self.inputs, job_params, self.app, to_html=False ) except Exception, e: raise exceptions.MessageException( str( e ) ) @@ -2157,7 +2163,7 @@ def sanitize(dict, key='value'): dict[key] = value # check the current state of a value and update it if necessary - def check_state( trans, input, value, context ): + def check_state( input, value, context ): error = 'State validation failed.' if isinstance( value, galaxy.tools.parameters.basic.DummyDataset ): return [ None, None ] @@ -2167,17 +2173,17 @@ def check_state( trans, input, value, context ): if value.get( '__class__' ) == 'RuntimeValue': return [ value, None ] try: - value, error = check_param( trans, input, value, context, history=history, boolean_fix=True, workflow_building_mode=workflow_mode ) + value, error = check_param( request_context, input, value, context, boolean_fix=True ) except Exception, err: log.error( 'Checking parameter %s failed. %s', input.name, str( err ) ) pass return [ value, error ] # populates state with incoming url parameters - def populate_state(trans, inputs, state, errors, incoming, prefix="", context=None ): + def populate_state( inputs, state, errors, incoming, prefix="", context=None ): context = ExpressionContext(state, context) for input in inputs.itervalues(): - state[input.name] = input.get_initial_value(trans, context) + state[input.name] = input.get_initial_value( request_context, context ) key = prefix + input.name if input.type == 'repeat': group_state = state[input.name] @@ -2191,21 +2197,21 @@ def populate_state(trans, inputs, state, errors, incoming, prefix="", context=No new_state = {} new_state['__index__'] = rep_index group_state.append(new_state) - populate_state(trans, input.inputs, new_state, errors, incoming, prefix=rep_name + "|", context=context) + populate_state( input.inputs, new_state, errors, incoming, prefix=rep_name + "|", context=context ) rep_index += 1 elif input.type == 'conditional': group_state = state[input.name] group_prefix = "%s|" % ( key ) test_param_key = group_prefix + input.test_param.name default_value = incoming.get(test_param_key, group_state.get(input.test_param.name, None)) - value, error = check_state(trans, input.test_param, default_value, context) + value, error = check_state( input.test_param, default_value, context ) if error: errors[test_param_key] = error else: try: - current_case = input.get_current_case(value, trans) + current_case = input.get_current_case( value, request_context ) group_state = state[input.name] = {} - populate_state( trans, input.cases[current_case].inputs, group_state, errors, incoming, prefix=group_prefix, context=context) + populate_state( input.cases[current_case].inputs, group_state, errors, incoming, prefix=group_prefix, context=context ) group_state['__current_case__'] = current_case except Exception: errors[test_param_key] = 'The selected case is unavailable/invalid.' @@ -2214,53 +2220,53 @@ def populate_state(trans, inputs, state, errors, incoming, prefix="", context=No elif input.type == 'section': group_state = state[input.name] group_prefix = "%s|" % ( key ) - populate_state(trans, input.inputs, group_state, errors, incoming, prefix=group_prefix, context=context) + populate_state( input.inputs, group_state, errors, incoming, prefix=group_prefix, context=context ) else: default_value = incoming.get(key, state.get(input.name, None)) - value, error = check_state(trans, input, default_value, context) + value, error = check_state( input, default_value, context ) if error: errors[key] = error state[input.name] = value # builds tool model including all attributes - def iterate(group_inputs, inputs, state_inputs, other_values=None): + def iterate( group_inputs, inputs, state_inputs, other_values=None ): other_values = ExpressionContext( state_inputs, other_values ) for input_index, input in enumerate( inputs.itervalues() ): tool_dict = None group_state = state_inputs.get(input.name, {}) if input.type == 'repeat': - tool_dict = input.to_dict(trans) + tool_dict = input.to_dict( request_context ) group_cache = tool_dict['cache'] = {} for i in range( len( group_state ) ): group_cache[i] = {} iterate( group_cache[i], input.inputs, group_state[i], other_values ) elif input.type == 'conditional': - tool_dict = input.to_dict(trans) + tool_dict = input.to_dict( request_context ) if 'test_param' in tool_dict: test_param = tool_dict['test_param'] - test_param['default_value'] = jsonify(input.test_param.get_initial_value(trans, other_values)) + test_param['default_value'] = jsonify( input.test_param.get_initial_value( request_context, other_values ) ) test_param['value'] = jsonify(group_state.get(test_param['name'], test_param['default_value'])) test_param['text_value'] = input.test_param.value_to_display_text(test_param['value'], self.app) for i in range(len( tool_dict['cases'] ) ): current_state = {} if i == group_state.get('__current_case__', None): current_state = group_state - iterate(tool_dict['cases'][i]['inputs'], input.cases[i].inputs, current_state, other_values) + iterate( tool_dict['cases'][i]['inputs'], input.cases[i].inputs, current_state, other_values ) elif input.type == 'section': - tool_dict = input.to_dict(trans) + tool_dict = input.to_dict( request_context ) iterate( tool_dict['inputs'], input.inputs, group_state, other_values ) else: # expand input dictionary, resolve dynamic parameters try: - tool_dict = input.to_dict(trans, other_values=other_values) + tool_dict = input.to_dict( request_context, other_values=other_values ) except Exception: - tool_dict = input.to_dict(trans) + tool_dict = input.to_dict( request_context ) log.exception('tools::to_json() - Skipping parameter expansion for %s.' % input.name) pass # backup default value try: - tool_dict['default_value'] = input.get_initial_value(trans, other_values) + tool_dict['default_value'] = input.get_initial_value( request_context, other_values ) except Exception: tool_dict['default_value'] = None log.exception('tools::to_json() - Getting initial value failed %s.' % input.name) @@ -2305,14 +2311,14 @@ def sanitize_state(state): # initialize and populate tool state state_inputs = {} state_errors = {} - populate_state(trans, self.inputs, state_inputs, state_errors, params.__dict__) + populate_state( request_context, self.inputs, state_inputs, state_errors, params.__dict__ ) # create basic tool model - tool_model = self.to_dict(trans) + tool_model = self.to_dict( request_context ) tool_model['inputs'] = {} # build tool model and tool state - iterate(tool_model['inputs'], self.inputs, state_inputs, '') + iterate( request_context, tool_model['inputs'], self.inputs, state_inputs, '' ) # sanitize tool state sanitize_state(state_inputs) @@ -2436,7 +2442,7 @@ def mapping_callback( input, value, prefixed_name, prefixed_label ): return map_to_history( value ) visit_input_values( tool_inputs, params, mapping_callback ) - def _compare_tool_version( self, trans, job ): + def _compare_tool_version( self, job ): """ Compares a tool version with the tool version from a job (from ToolRunner). """ diff --git a/lib/galaxy/tools/parameters/__init__.py b/lib/galaxy/tools/parameters/__init__.py index fd63b4363896..bfdb8061dd33 100644 --- a/lib/galaxy/tools/parameters/__init__.py +++ b/lib/galaxy/tools/parameters/__init__.py @@ -6,7 +6,6 @@ from grouping import Conditional, Repeat, Section, UploadDataset from galaxy.util.json import dumps, json_fix, loads from galaxy.util.expressions import ExpressionContext -from galaxy.work.context import WorkRequestContext REPLACE_ON_TRUTHY = object() @@ -61,7 +60,7 @@ def visit_input_values( inputs, input_values, callback, name_prefix="", label_pr input_values[input.name] = new_value -def check_param( trans, param, incoming_value, param_values, source='html', boolean_fix=False, history=None, workflow_building_mode=False ): +def check_param( trans, param, incoming_value, param_values, source='html', boolean_fix=False ): """ Check the value of a single parameter `param`. The value in `incoming_value` is converted from its HTML encoding and validated. @@ -69,12 +68,6 @@ def check_param( trans, param, incoming_value, param_values, source='html', bool previous parameters (this may actually be an ExpressionContext when dealing with grouping scenarios). """ - request_context = WorkRequestContext( - app = trans.app, - user = trans.user, - history = history or trans.history, - workflow_building_mode = workflow_building_mode - ) value = incoming_value error = None try: @@ -84,16 +77,16 @@ def check_param( trans, param, incoming_value, param_values, source='html', bool if value is not None or isinstance( param, DataToolParameter ) or isinstance( param, DataCollectionToolParameter ): # Convert value from HTML representation if source == 'html': - value = param.from_html( value, request_context, param_values ) + value = param.from_html( value, trans, param_values ) else: - value = param.from_json( value, request_context, param_values ) + value = param.from_json( value, trans, param_values ) # Allow the value to be converted if necessary - filtered_value = param.filter_value( value, request_context, param_values ) + filtered_value = param.filter_value( value, trans, param_values ) # Then do any further validation on the value - param.validate( filtered_value, request_context ) + param.validate( filtered_value, trans ) elif value is None and isinstance( param, SelectToolParameter ): # An empty select list or column list - param.validate( value, request_context ) + param.validate( value, trans ) except ValueError, e: error = str( e ) return value, error diff --git a/lib/galaxy/tools/parameters/basic.py b/lib/galaxy/tools/parameters/basic.py index 177653645527..c05db4a90e69 100644 --- a/lib/galaxy/tools/parameters/basic.py +++ b/lib/galaxy/tools/parameters/basic.py @@ -1931,7 +1931,7 @@ def get_initial_value_from_history_prevent_repeats( self, trans, other_values, a happens twice (here and when generating HTML). """ # Can't look at history in workflow mode. Tool shed has no histories. - if trans.workflow_building_mode or trans.webapp.name == 'tool_shed': + if trans.workflow_building_mode or trans.app.name == 'tool_shed': return DummyDataset() history = self._get_history( trans ) dataset_matcher = DatasetMatcher( trans, self, None, other_values )