def respond(sender_id):
request_params = request_parameters()
if 'query' in request_params:
message = request_params.pop('query')
elif 'q' in request_params:
message = request_params.pop('q')
else:
return error(400, "InvalidParameter", "Missing the message parameter.",
{
"parameter": "query",
"in": "query"
})
try:
# Set the output channel
out = CollectingOutputChannel()
# Fetches the appropriate bot response in a json format
responses = agent.handle_text(message,
output_channel=out,
sender_id=sender_id)
return jsonify(responses)
except Exception as e:
logger.exception("Caught an exception during respond.")
return error(500, "ActionException",
"Server failure. Error: {}".format(e))
def log_message(sender_id):
request_params = request.get_json(force=True)
try:
message = request_params["message"]
except KeyError:
message = request_params.get("text")
sender = request_params.get("sender")
parse_data = request_params.get("parse_data")
verbosity = event_verbosity_parameter(EventVerbosity.AFTER_RESTART)
# TODO: implement properly for agent / bot
if sender != "user":
return error(
500, "NotSupported", "Currently, only user messages can be passed "
"to this endpoint. Messages of sender '{}' "
"can not be handled. ".format(sender), {
"parameter": "sender",
"in": "body"
})
try:
usermsg = UserMessage(message, None, sender_id, parse_data)
tracker = agent.log_message(usermsg)
return jsonify(tracker.current_state(verbosity))
except Exception as e:
logger.exception("Caught an exception while logging message.")
return error(500, "MessageException",
"Server failure. Error: {}".format(e))
def continue_training():
request.headers.get("Accept")
epochs = request.args.get("epochs", 30)
batch_size = request.args.get("batch_size", 5)
request_params = request.get_json(force=True)
sender_id = UserMessage.DEFAULT_SENDER_ID
try:
tracker = DialogueStateTracker.from_dict(sender_id, request_params,
agent.domain.slots)
except Exception as e:
return error(400, "InvalidParameter",
"Supplied events are not valid. {}".format(e), {
"parameter": "",
"in": "body"
})
try:
# Fetches the appropriate bot response in a json format
agent.continue_training([tracker],
epochs=epochs,
batch_size=batch_size)
return '', 204
except Exception as e:
logger.exception("Caught an exception during prediction.")
return error(500, "TrainingException",
"Server failure. Error: {}".format(e))
def handle_actions(self, message, action_name):
verbosity = self.event_verbosity_parameter(
EventVerbosity.AFTER_RESTART)
try:
output_channel = CollectingOutputChannel()
dispatcher = Dispatcher(message.sender_id, output_channel,
self.agent.nlg)
tracker = self.message_processor._get_tracker(message.sender_id)
if tracker:
#拿到action实例
action = self.ask_for_action(
action_name, self.message_processor.action_endpoint,
self.ask_for_action)
# action = self._get_action(action_name)
self.message_processor._run_action(action, tracker, dispatcher)
# save tracker state to continue conversation from this state
self.message_processor._save_tracker(tracker)
# retrieve tracker and set to requested state
tracker = self.agent.tracker_store.get_or_create_tracker(
message.sender_id)
state = tracker.current_state(verbosity)
return jsonify({
"tracker": state,
"messages": output_channel.messages
})
except ValueError as e:
return error(400, "ValueError", e)
except Exception as e:
return error(500, "ValueError",
"Server failure. Error: {}".format(e))
def tracker_predict():
""" Given a list of events, predicts the next action"""
sender_id = UserMessage.DEFAULT_SENDER_ID
request_params = request.get_json(force=True)
verbosity = event_verbosity_parameter(EventVerbosity.AFTER_RESTART)
try:
tracker = DialogueStateTracker.from_dict(sender_id, request_params,
agent.domain.slots)
except Exception as e:
return error(400, "InvalidParameter",
"Supplied events are not valid. {}".format(e), {
"parameter": "",
"in": "body"
})
policy_ensemble = agent.policy_ensemble
probabilities, policy = \
policy_ensemble.probabilities_using_best_policy(tracker,
agent.domain)
scores = [{
"action": a,
"score": p
} for a, p in zip(agent.domain.action_names, probabilities)]
return jsonify({
"scores": scores,
"policy": policy,
"tracker": tracker.current_state(verbosity)
})
def load_model():
"""Loads a zipped model, replacing the existing one."""
if 'model' not in request.files:
# model file is missing
return error(400, "InvalidParameter",
"You did not supply a model as part of your request.", {
"parameter": "model",
"in": "body"
})
model_file = request.files['model']
logger.info("Received new model through REST interface.")
zipped_path = tempfile.NamedTemporaryFile(delete=False, suffix=".zip")
zipped_path.close()
model_directory = tempfile.mkdtemp()
model_file.save(zipped_path.name)
logger.debug("Downloaded model to {}".format(zipped_path.name))
zip_ref = zipfile.ZipFile(zipped_path.name, 'r')
zip_ref.extractall(model_directory)
zip_ref.close()
logger.debug("Unzipped model to {}".format(
os.path.abspath(model_directory)))
ensemble = PolicyEnsemble.load(model_directory)
agent.policy_ensemble = ensemble
logger.debug("Finished loading new agent.")
return '', 204
def decorated(*args, **kwargs):
if not agent.is_ready():
return error(
503,
"NoAgent", "No agent loaded. To continue processing, a "
"model of a trained agent needs to be loaded.",
help_url=_docs("/server.html#running-the-http-server"))
return f(*args, **kwargs)
def predict(sender_id):
try:
# Fetches the appropriate bot response in a json format
responses = agent.predict_next(sender_id)
return jsonify(responses)
except Exception as e:
logger.exception("Caught an exception during prediction.")
return error(500, "PredictionException",
"Server failure. Error: {}".format(e))
def execute_action(sender_id):
request_params = request.get_json(force=True)
action_to_execute = request_params.get("action", None)
verbosity = event_verbosity_parameter(EventVerbosity.AFTER_RESTART)
try:
out = CollectingOutputChannel()
agent.execute_action(sender_id, action_to_execute, out)
# retrieve tracker and set to requested state
tracker = agent.tracker_store.get_or_create_tracker(sender_id)
state = tracker.current_state(verbosity)
return jsonify({"tracker": state, "messages": out.messages})
except ValueError as e:
return error(400, "ValueError", e)
except Exception as e:
logger.exception(e)
return error(500, "ValueError", "Server failure. Error: {}".format(e))
def retrieve_tracker(sender_id):
"""Get a dump of a conversations tracker including its events."""
if not agent.tracker_store:
return error(
503, "NoTrackerStore",
"No tracker store available. Make sure to configure "
"a tracker store when starting the server.")
# parameters
default_verbosity = EventVerbosity.AFTER_RESTART
# this is for backwards compatibility
if "ignore_restarts" in request.args:
ignore_restarts = utils.bool_arg('ignore_restarts', default=False)
if ignore_restarts:
default_verbosity = EventVerbosity.ALL
if "events" in request.args:
include_events = utils.bool_arg('events', default=True)
if not include_events:
default_verbosity = EventVerbosity.NONE
verbosity = event_verbosity_parameter(default_verbosity)
until_time = request.args.get('until', None)
# retrieve tracker and set to requested state
tracker = agent.tracker_store.get_or_create_tracker(sender_id)
if not tracker:
return error(
503, "NoDomain", "Could not retrieve tracker. Most likely "
"because there is no domain set on the agent.")
if until_time is not None:
tracker = tracker.travel_back_in_time(float(until_time))
# dump and return tracker
state = tracker.current_state(verbosity)
return jsonify(state)
def evaluate_stories():
"""Evaluate stories against the currently loaded model."""
tmp_file = rasa_nlu.utils.create_temporary_file(request.get_data(),
mode='w+b')
use_e2e = utils.bool_arg('e2e', default=False)
try:
evaluation = run_story_evaluation(tmp_file, agent, use_e2e=use_e2e)
return jsonify(evaluation)
except ValueError as e:
return error(400, "FailedEvaluation",
"Evaluation could not be created. Error: {}"
"".format(e))
def event_verbosity_parameter(default_verbosity):
event_verbosity_str = request.args.get(
'include_events', default=default_verbosity.name).upper()
try:
return EventVerbosity[event_verbosity_str]
except KeyError:
enum_values = ", ".join([e.name for e in EventVerbosity])
abort(
error(
404, "InvalidParameter",
"Invalid parameter value for 'include_events'. "
"Should be one of {}".format(enum_values), {
"parameter": "include_events",
"in": "query"
}))
def get_domain():
"""Get current domain in yaml or json format."""
accepts = request.headers.get("Accept", default="application/json")
if accepts.endswith("json"):
domain = agent.domain.as_dict()
return jsonify(domain)
elif accepts.endswith("yml"):
domain_yaml = agent.domain.as_yaml()
return Response(domain_yaml,
status=200,
content_type="application/x-yml")
else:
return error(
406, "InvalidHeader",
"""Invalid accept header. Domain can be provided
as json ("Accept: application/json")
or yml ("Accept: application/x-yml").
Make sure you've set the appropriate Accept
header.""")
def append_event(sender_id):
"""Append a list of events to the state of a conversation"""
request_params = request.get_json(force=True)
evt = Event.from_parameters(request_params)
tracker = agent.tracker_store.get_or_create_tracker(sender_id)
verbosity = event_verbosity_parameter(EventVerbosity.AFTER_RESTART)
if evt:
tracker.update(evt)
agent.tracker_store.save(tracker)
return jsonify(tracker.current_state(verbosity))
else:
logger.warning("robot_apiend event called, but could not extract a "
"valid event. Request JSON: {}".format(request_params))
return error(
400, "InvalidParameter",
"Couldn't extract a proper event from the request "
"body.", {
"parameter": "",
"in": "body"
})
def draw_main_menu(stdscr, window, menu, menu_bar):
draw_background(stdscr)
(win_h, win_w) = draw_window(stdscr, window, menu.title, menu_bar)
x = 3
y = wrap_text(window, mainwindow_help_text, 1, x, win_w - 6)
y = draw_legend(window, y, x, win_w - 6)
menu_height = win_h - y - 3
lit_border(window, menu_height, win_w - 4, y, 2, raised=False)
y += 1
menu_height -= 2
menu_bottom = menu_height + y
menu_top = y
x = 7
if menu.selection < menu.top:
menu.top = menu.selection
# Check if the menu could be scrolled up
can_scroll_up = False
for i in range(0, menu.top):
if menu[i].can_enable() and menu[i].is_visible():
can_scroll_up = True
break
# Compute which menu items should be visible and scrolling
menu_items = []
can_scroll_down = True
for i in range(menu.top, len(menu.items)):
if menu[i].can_enable() and menu[i].is_visible():
menu_items.append(i)
if len(menu_items) >= menu_height:
if menu.selection > i:
menu_items = menu_items[1:]
if len(menu_items) > 0:
menu.top = menu_items[0]
else:
# Screen is too small to show any items
raise _curses.error("Too small")
can_scroll_up = True
else:
for j in range(i + 1, len(menu.items)):
if menu[j].can_enable() and menu[i].is_visible():
break
else:
can_scroll_down = False
break
else:
can_scroll_down = False
cursor_y = 0
max_width = win_w - x - 3
if can_scroll_up:
window.addstr(menu_top - 1, min(7, win_w - 3), " ^ ", attr["scroll"])
if can_scroll_down:
window.addstr(menu_bottom, min(7, win_w - 3), " v ", attr["scroll"])
for menu_pos in menu_items:
menu_option = menu[menu_pos]
is_selected = False
if menu.selection == menu_pos:
cursor_y = y
is_selected = True
tmp_x = x
remaining_width = max_width
for part in menu[menu_pos].get_styled_text(is_selected, max_width):
if len(part.text) > 0 and remaining_width > 0:
window.addstr(y, tmp_x, part.text[:remaining_width],
attr[part.style])
tmp_x += len(part.text)
remaining_width -= len(part.text)
y += 1
window.move(cursor_y, x + 1)
return menu_height
def userptr(self):
# XXX: This is probably wrong.
obj = lib.panel_userptr(self._pan)
if obj == ffi.NULL:
raise error("no userptr set")
return obj
def userptr(self):
# XXX: This is probably wrong.
obj = lib.panel_userptr(self._pan)
if obj == ffi.NULL:
raise error("no userptr set")
return obj