def get_state_for_frontend(state, exploration):
"""Returns a representation of the given state for the frontend."""
state_repr = state.as_dict()
modified_state_dict = state.internals_as_dict(human_readable_dests=True)
# TODO(sll): The following is for backwards-compatibility and should be
# deleted later.
rules = {}
for handler in state_repr['widget']['handlers']:
rules[handler['name']] = handler['rules']
for item in rules[handler['name']]:
if item['name'] == 'Default':
item['rule'] = 'Default'
else:
item['rule'] = InteractiveWidget.get(
state.widget.widget_id).get_readable_name(
handler['name'], item['name']
)
state_repr['widget']['rules'] = rules
state_repr['widget']['id'] = state_repr['widget']['widget_id']
state_repr['widget']['sticky'] = state_repr['widget']['sticky']
state_repr['yaml'] = utils.yaml_from_dict(modified_state_dict)
return state_repr
def _pre_put_hook(self):
"""Ensures that the widget and at least one handler for it exists."""
if not self.widget:
self.widget = self.get_default_widget()
elif not self.widget.handlers:
self.widget.handlers = [self.get_default_handler()]
# TODO(sll): Do other validation.
# Add the corresponding AnswerHandler classifiers for easy reference.
widget = InteractiveWidget.get(self.widget.widget_id)
for curr_handler in self.widget.handlers:
for w_handler in widget.handlers:
if w_handler.name == curr_handler.name:
curr_handler.classifier = w_handler.classifier
def get_classifier_info(self, widget_id, handler_name, rule, state_params):
classifier_func = rule.name.replace(' ', '')
first_bracket = classifier_func.find('(')
mutable_rule = InteractiveWidget.get(widget_id).get_readable_name(
handler_name, rule.name)
func_name = classifier_func[: first_bracket]
str_params = classifier_func[first_bracket + 1: -1].split(',')
param_list = []
for index, param in enumerate(str_params):
parsed_param = rule.inputs[param]
if isinstance(parsed_param, basestring) and '{{' in parsed_param:
parsed_param = utils.parse_with_jinja(
parsed_param, state_params)
typed_object = self.get_typed_object(mutable_rule, param)
normalized_param = typed_object.normalize(parsed_param)
param_list.append(normalized_param)
return func_name, param_list
