def get_equation_chart(self, **form_data):
from tvb.basic.traits.parameters_factory import collapse_params
"""
Returns the html which contains the plot with the equation selected by the user for a certain model param.
"""
try:
min_x, max_x, ui_message = self.get_x_axis_range(form_data['min_x'], form_data['max_x'])
form_data = collapse_params(form_data, self.plotted_equations_prefixes)
_, equation = self._compute_equation(form_data)
series_data, display_ui_message = equation.get_series_data(min_range=min_x, max_range=max_x)
all_series = self.get_series_json(series_data, "Spatial")
ui_message = ''
if display_ui_message:
ui_message = self.get_ui_message(["spatial"])
return {'allSeries': all_series, 'prefix': self.plotted_equations_prefixes[0], 'message': ui_message}
except NameError as ex:
self.logger.exception(ex)
return {'allSeries': None, 'errorMsg': "Incorrect parameters for equation passed."}
except SyntaxError as ex:
self.logger.exception(ex)
return {'allSeries': None, 'errorMsg': "Some of the parameters hold invalid characters."}
except Exception as ex:
self.logger.exception(ex)
return {'allSeries': None, 'errorMsg': ex.message}
def get_equation_chart(self, **form_data):
"""
Returns the html which contains the plot with the temporal equation.
"""
try:
form_data = collapse_params(form_data, ['temporal'])
min_x, max_x, ui_message = self.get_x_axis_range(
form_data['min_x'], form_data['max_x'])
equation = Equation.build_equation_from_dict('temporal', form_data)
series_data, display_ui_message = equation.get_series_data(
min_range=min_x, max_range=max_x)
all_series = self.get_series_json(series_data, 'Temporal')
if display_ui_message:
ui_message = self.get_ui_message(["temporal"])
return {
'allSeries': all_series,
'prefix': 'temporal',
'message': ui_message
}
except NameError, ex:
self.logger.exception(ex)
return {
'allSeries': None,
'errorMsg': "Incorrect parameters for equation passed."
}
def get_equation_chart(self, **form_data):
"""
Returns the html which contains the plot with the equation selected by the user for a certain model param.
"""
try:
min_x, max_x, ui_message = self.get_x_axis_range(form_data['min_x'], form_data['max_x'])
form_data = collapse_params(form_data, self.plotted_equations_prefixes)
_, equation = self._compute_equation(form_data)
series_data, display_ui_message = equation.get_series_data(min_range=min_x, max_range=max_x)
all_series = self.get_series_json(series_data, "Spatial")
ui_message = ''
if display_ui_message:
ui_message = self.get_ui_message(["spatial"])
return {'allSeries': all_series, 'prefix': self.plotted_equations_prefixes[0], 'message': ui_message}
except NameError as ex:
self.logger.exception(ex)
return {'allSeries': None, 'errorMsg': "Incorrect parameters for equation passed."}
except SyntaxError as ex:
self.logger.exception(ex)
return {'allSeries': None, 'errorMsg': "Some of the parameters hold invalid characters."}
except Exception as ex:
self.logger.exception(ex)
return {'allSeries': None, 'errorMsg': ex.message}
def apply_equation(self, **kwargs):
"""
Applies an equations for computing a model parameter.
"""
submitted_data = collapse_params(kwargs, ['model_param'])
model_param, equation = self._compute_equation(submitted_data)
context_model_parameters = common.get_from_session(KEY_CONTEXT_MPS)
context_model_parameters.apply_equation(model_param, equation)
common.add2session(KEY_CONTEXT_MPS, context_model_parameters)
template_specification = self.get_surface_model_parameters_data(model_param)
template_specification = self._add_entra_equation_entries(template_specification,
kwargs['min_x'], kwargs['max_x'])
template_specification['equationViewerUrl'] = '/spatial/modelparameters/surface/get_equation_chart'
template_specification['equationsPrefixes'] = json.dumps(self.plotted_equations_prefixes)
return self.fill_default_attributes(template_specification)
def _compute_equation(parameters):
"""
This method will return an equation and the model parameter on
which should be applied the equation.
The equation is constructed based on the parameters collected from the UI.
"""
model_param = parameters[MODEL_PARAM]
equation = parameters[MODEL_PARAM + PARAM_SUFFIX][MODEL_PARAM_EQUATION]
equation_params = parameters[MODEL_PARAM + PARAM_SUFFIX][MODEL_PARAM_EQUATION + PARAM_SUFFIX][equation]
equation_params = collapse_params(equation_params, [])
if PARAMETERS + PARAM_SUFFIX in equation_params:
equation_params = equation_params[PARAMETERS + PARAM_SUFFIX]
else:
equation_params = {}
for param in equation_params:
equation_params[param] = float(equation_params[param])
selected_equation = get_traited_instance_for_name(equation, equations.Equation, {PARAMETERS: equation_params})
return model_param, selected_equation
def get_equation_chart(self, **form_data):
"""
Returns the html which contains the plot with the temporal equation.
"""
try:
form_data = collapse_params(form_data, ["temporal"])
min_x, max_x, ui_message = self.get_x_axis_range(form_data["min_x"], form_data["max_x"])
equation = Equation.build_equation_from_dict("temporal", form_data)
series_data, display_ui_message = equation.get_series_data(min_range=min_x, max_range=max_x)
all_series = self.get_series_json(series_data, "Temporal")
if display_ui_message:
ui_message = self.get_ui_message(["temporal"])
return {"allSeries": all_series, "prefix": "temporal", "message": ui_message}
except NameError, ex:
self.logger.exception(ex)
return {"allSeries": None, "errorMsg": "Incorrect parameters for equation passed."}
def get_equation_chart(self, **form_data):
"""
Returns the html which contains the plot with the temporal equation.
"""
try:
form_data = collapse_params(form_data, ['temporal'])
min_x, max_x, ui_message = self.get_x_axis_range(form_data['min_x'], form_data['max_x'])
equation = Equation.build_equation_from_dict('temporal', form_data)
series_data, display_ui_message = equation.get_series_data(min_range=min_x, max_range=max_x)
json_data = self.get_series_json(series_data, 'Temporal')
all_series = self.build_final_json([json_data])
if display_ui_message:
ui_message = self.get_ui_message(["temporal"])
return {'allSeries': all_series, 'prefix': 'temporal', 'message': ui_message}
except NameError, ex:
self.logger.exception(ex)
return {'allSeries': None, 'errorMsg': "Incorrect parameters for equation passed."}
def get_equation_chart(self, **form_data):
"""
Returns the html which contains the plot with the equation selected by the user for a certain model param.
"""
try:
min_x, max_x, ui_message = self.get_x_axis_range(form_data['min_x'], form_data['max_x'])
form_data = collapse_params(form_data, self.plotted_equations_prefixes)
_, equation = self._compute_equation(form_data)
series_data, display_ui_message = equation.get_series_data(min_range=min_x, max_range=max_x)
json_data = self.get_series_json(series_data, "Spatial")
all_series = self.build_final_json([json_data])
ui_message = ''
if display_ui_message:
ui_message = self.get_ui_message(["spatial"])
return {'allSeries': all_series, 'prefix': self.plotted_equations_prefixes[0], 'message': ui_message}
except NameError, ex:
self.logger.exception(ex)
return {'allSeries': None, 'errorMsg': "Incorrect parameters for equation passed."}
def convert_ui_inputs(self, flat_input_interface, kwargs, metadata_out, validation_required=True):
"""
Convert HTTP POST parameters into Python parameters.
"""
kwa = {}
simple_select_list, to_skip_dict_subargs = [], []
for row in flat_input_interface:
row_attr = row[xml_reader.ATT_NAME]
row_type = row[xml_reader.ATT_TYPE]
## If required attribute was submitted empty no point to continue, so just raise exception
if (validation_required and row.get(xml_reader.ATT_REQUIRED, False)
and row_attr in kwargs and kwargs[row_attr] == ""):
msg = "Parameter %s [%s] is required for %s but no value was submitted! Please relaunch with valid parameters."
raise InvalidParameterException(msg % (row[KEY_LABEL], row[KEY_NAME], self.__class__.__name__))
try:
if row_type == xml_reader.TYPE_DICT:
kwa[row_attr], taken_keys = self._get_dictionary(row, **kwargs)
for key in taken_keys:
if key in kwa:
del kwa[key]
to_skip_dict_subargs.append(key)
continue
## Dictionary subargs that were previously processed should be ignored
if row_attr in to_skip_dict_subargs:
continue
if row_attr not in kwargs:
## DataType sub-attributes are not submitted with GID in their name...
kwa_name = self._find_field_submitted_name(kwargs, row_attr, True)
if kwa_name is None:
## Do not populate attributes not submitted
continue
kwargs[row_attr] = kwargs[kwa_name]
## del kwargs[kwa_name] don't remove the original param, as it is useful for retrieving op.input DTs
elif self._is_parent_not_submitted(row, kwargs):
## Also do not populate sub-attributes from options not selected
del kwargs[row_attr]
continue
if row_type == xml_reader.TYPE_ARRAY:
kwa[row_attr] = self._convert_to_array(kwargs[row_attr], row)
if xml_reader.ATT_MINVALUE in row and xml_reader.ATT_MAXVALUE in row:
self._validate_range_for_array_input(kwa[row_attr], row)
elif row_type == xml_reader.TYPE_LIST:
if not isinstance(kwargs[row_attr], list):
kwa[row_attr] = json.loads(kwargs[row_attr])
elif row_type == xml_reader.TYPE_BOOL:
kwa[row_attr] = bool(kwargs[row_attr])
elif row_type == xml_reader.TYPE_INT:
if kwargs[row_attr] in [None, '', 'None']:
kwa[row_attr] = None
else:
kwa[row_attr] = int(kwargs[row_attr])
if xml_reader.ATT_MINVALUE in row and xml_reader.ATT_MAXVALUE in row:
self._validate_range_for_value_input(kwa[row_attr], row)
elif row_type == xml_reader.TYPE_FLOAT:
if kwargs[row_attr] in ['', 'None']:
kwa[row_attr] = None
else:
kwa[row_attr] = float(kwargs[row_attr])
if xml_reader.ATT_MINVALUE in row and xml_reader.ATT_MAXVALUE in row:
self._validate_range_for_value_input(kwa[row_attr], row)
elif row_type == xml_reader.TYPE_STR:
kwa[row_attr] = kwargs[row_attr]
elif row_type in [xml_reader.TYPE_SELECT, xml_reader.TYPE_MULTIPLE]:
val = kwargs[row_attr]
if row_type == xml_reader.TYPE_MULTIPLE and not isinstance(val, list):
val = [val]
kwa[row_attr] = val
if row_type == xml_reader.TYPE_SELECT:
simple_select_list.append(row_attr)
elif row_type == xml_reader.TYPE_UPLOAD:
kwa[row_attr] = kwargs[row_attr]
else:
## DataType parameter to be processed:
simple_select_list.append(row_attr)
datatype_gid = kwargs[row_attr]
## Load filtered and trimmed attribute (e.g. field is applied if specified):
kwa[row_attr] = self._load_entity(row, datatype_gid, kwargs, metadata_out)
if xml_reader.ATT_FIELD in row:
#Add entity_GID to the parameters to recognize original input
kwa[row_attr + '_gid'] = datatype_gid
except TVBException:
raise
except Exception:
raise InvalidParameterException("Invalid or missing value in field %s [%s]" % (row[KEY_LABEL],
row[KEY_NAME]))
return collapse_params(kwa, simple_select_list)
def convert_ui_inputs(self,
flat_input_interface,
kwargs,
metadata_out,
validation_required=True):
"""
Convert HTTP POST parameters into Python parameters.
"""
kwa = {}
simple_select_list, to_skip_dict_subargs = [], []
for row in flat_input_interface:
row_attr = row[KEY_NAME]
row_type = row[KEY_TYPE]
## If required attribute was submitted empty no point to continue, so just raise exception
if validation_required and row.get(KEY_REQUIRED) and kwargs.get(
row_attr) == "":
msg = "Parameter %s [%s] is required for %s but no value was submitted! Please relaunch with valid parameters."
raise InvalidParameterException(
msg %
(row[KEY_LABEL], row[KEY_NAME], self.__class__.__name__))
try:
if row_type == TYPE_DICT:
kwa[row_attr], taken_keys = self._get_dictionary(
row, **kwargs)
for key in taken_keys:
if key in kwa:
del kwa[key]
to_skip_dict_subargs.append(key)
continue
## Dictionary subargs that were previously processed should be ignored
if row_attr in to_skip_dict_subargs:
continue
if row_attr not in kwargs:
## DataType sub-attributes are not submitted with GID in their name...
kwa_name = self._find_field_submitted_name(
kwargs, row_attr, True)
if kwa_name is None:
## Do not populate attributes not submitted
continue
kwargs[row_attr] = kwargs[kwa_name]
## del kwargs[kwa_name] don't remove the original param, as it is useful for retrieving op.input DTs
elif self._is_parent_not_submitted(row, kwargs):
## Also do not populate sub-attributes from options not selected
del kwargs[row_attr]
continue
if row_type == TYPE_ARRAY:
kwa[row_attr] = self._convert_to_array(
kwargs[row_attr], row)
self._validate_range_for_array_input(kwa[row_attr], row)
elif row_type == TYPE_LIST:
if not isinstance(kwargs[row_attr], list):
kwa[row_attr] = json.loads(kwargs[row_attr])
elif row_type == TYPE_BOOL:
kwa[row_attr] = bool(kwargs[row_attr])
elif row_type == TYPE_INT:
if kwargs[row_attr] in [None, '', 'None']:
kwa[row_attr] = None
else:
kwa[row_attr] = int(kwargs[row_attr])
self._validate_range_for_value_input(
kwa[row_attr], row)
elif row_type == TYPE_FLOAT:
if kwargs[row_attr] in ['', 'None']:
kwa[row_attr] = None
else:
kwa[row_attr] = float(kwargs[row_attr])
self._validate_range_for_value_input(
kwa[row_attr], row)
elif row_type == TYPE_STR:
kwa[row_attr] = kwargs[row_attr]
elif row_type in [TYPE_SELECT, TYPE_MULTIPLE]:
val = kwargs[row_attr]
if row_type == TYPE_MULTIPLE and not isinstance(val, list):
val = [val]
kwa[row_attr] = val
if row_type == TYPE_SELECT:
simple_select_list.append(row_attr)
elif row_type == TYPE_UPLOAD:
kwa[row_attr] = kwargs[row_attr]
else:
## DataType parameter to be processed:
simple_select_list.append(row_attr)
datatype_gid = kwargs[row_attr]
## Load filtered and trimmed attribute (e.g. field is applied if specified):
kwa[row_attr] = self._load_entity(row, datatype_gid,
kwargs, metadata_out)
if KEY_FIELD in row:
# Add entity_GID to the parameters to recognize original input
kwa[row_attr + '_gid'] = datatype_gid
except TVBException:
raise
except Exception:
self.log.exception('convert_ui_inputs failed')
raise InvalidParameterException(
"Invalid or missing value in field %s [%s]" %
(row[KEY_LABEL], row[KEY_NAME]))
return collapse_params(kwa, simple_select_list)
