def retrieve_tracker(sender_id):
"""Get a dump of a conversations tracker including its events."""
if not agent.tracker_store:
return Response("No tracker store available.", status=503)
# parameters
should_ignore_restarts = utils.bool_arg('ignore_restarts',
default=False)
should_include_events = utils.bool_arg('events', default=True)
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 Response(
"Could not retrieve tracker. Most likely "
"because there is no domain set on the agent.",
status=503)
if until_time is not None:
tracker = tracker.travel_back_in_time(float(until_time))
# dump and return tracker
state = tracker.current_state(
should_include_events=should_include_events,
should_ignore_restarts=should_ignore_restarts)
return jsonify(state)
def retrieve_tracker(sender_id):
"""Get a dump of a conversations tracker including its events."""
if not agent.tracker_store:
return Response("No tracker store available.",
status=503)
# parameters
should_ignore_restarts = utils.bool_arg('ignore_restarts',
default=False)
should_include_events = utils.bool_arg('events',
default=True)
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 Response("Could not retrieve tracker. Most likely "
"because there is no domain set on the agent.",
status=503)
if until_time is not None:
tracker = tracker.travel_back_in_time(float(until_time))
# dump and return tracker
state = tracker.current_state(
should_include_events=should_include_events,
should_ignore_restarts=should_ignore_restarts)
return jsonify(state)
def retrieve_tracker(sender_id):
"""Get a dump of a conversations tracker including its events."""
if not agent.tracker_store:
return Response("No tracker store available.",
status=503)
# parameters
default_verbosity = "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 = "ALL"
if "events" in request.args:
include_events = utils.bool_arg('events', default=True)
if not include_events:
default_verbosity = "NONE"
event_verbosity_str = request.args.get(
'include_events', default=default_verbosity).upper()
try:
verbosity = EventVerbosity[event_verbosity_str]
except KeyError:
enum_values = ", ".join([e.name for e in EventVerbosity])
return Response(
"Invalid parameter value for 'events'. Should be "
"one of {}".format(enum_values),
status=404)
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 Response("Could not retrieve tracker. Most likely "
"because there is no domain set on the agent.",
status=503)
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)
async def retrieve_tracker(request: Request, sender_id: Text):
"""Get a dump of a conversation's tracker including its events."""
if not app.agent.tracker_store:
raise ErrorResponse(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.raw_args:
ignore_restarts = utils.bool_arg(request, 'ignore_restarts',
default=False)
if ignore_restarts:
default_verbosity = EventVerbosity.ALL
if "events" in request.raw_args:
include_events = utils.bool_arg(request, 'events',
default=True)
if not include_events:
default_verbosity = EventVerbosity.NONE
verbosity = event_verbosity_parameter(request,
default_verbosity)
# retrieve tracker and set to requested state
tracker = app.agent.tracker_store.get_or_create_tracker(sender_id)
if not tracker:
raise ErrorResponse(503,
"NoDomain",
"Could not retrieve tracker. Most likely "
"because there is no domain set on the agent.")
until_time = utils.float_arg(request, 'until')
if until_time is not None:
tracker = tracker.travel_back_in_time(until_time)
# dump and return tracker
state = tracker.current_state(verbosity)
return response.json(state)
def retrieve_tracker(sender_id):
"""Get a dump of a conversations tracker including its events."""
# parameters
should_ignore_restarts = utils.bool_arg('ignore_restarts',
default=False)
should_include_events = utils.bool_arg('events', default=True)
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 until_time is not None:
tracker = tracker.travel_back_in_time(float(until_time))
# dump and return tracker
state = tracker.current_state(
should_include_events=should_include_events,
should_ignore_restarts=should_ignore_restarts)
return jsonify(state)
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 receive():
sender_id = self._extract_sender(request)
text = self._extract_message(request)
should_use_stream = utils.bool_arg("stream", default=False)
if should_use_stream:
return Response(self.stream_response(on_new_message, text,
sender_id),
content_type='text/event-stream')
else:
collector = CollectingOutputChannel()
on_new_message(UserMessage(text, collector, sender_id))
return jsonify(collector.messages)
async def evaluate_stories(request: Request):
"""Evaluate stories against the currently loaded model."""
import rasa_nlu.utils
tmp_file = rasa_nlu.utils.create_temporary_file(request.body,
mode='w+b')
use_e2e = utils.bool_arg(request, 'e2e', default=False)
try:
evaluation = await test(tmp_file, app.agent, use_e2e=use_e2e)
return response.json(evaluation)
except ValueError as e:
raise ErrorResponse(400, "FailedEvaluation",
"Evaluation could not be created. Error: {}"
"".format(e))
async def receive(request):
sender_id = await self._extract_sender(request)
text = self._extract_message(request)
should_use_stream = utils.bool_arg(request, "stream",
default=False)
if should_use_stream:
return response.stream(
self.stream_response(on_new_message, text, sender_id),
content_type='text/event-stream')
else:
collector = CollectingOutputChannel()
# noinspection PyBroadException
try:
await on_new_message(UserMessage(text, collector, sender_id,
input_channel=self.name()))
except CancelledError:
logger.error("Message handling timed out for "
"user message '{}'.".format(text))
except Exception:
logger.exception("An exception occured while handling "
"user message '{}'.".format(text))
return response.json(collector.messages)
