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)
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)
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),
)