def webhook():
sender_id = self._extract_sender(request)
text = self._extract_message(request)
collector = CallbackOutput(self.callback_endpoint)
on_new_message(UserMessage(text, collector, sender_id))
return "success"
def test_int_message_id_in_user_message():
from rasa_core.channels import UserMessage
# noinspection PyTypeChecker
message = UserMessage("B text", message_id=987654321)
assert message.message_id == "987654321"
async def message(request: Request):
sender = request.form.get("From", None)
text = request.form.get("Body", None)
out_channel = TwilioOutput(
self.account_sid, self.auth_token, self.twilio_number
)
if sender is not None and message is not None:
try:
# @ signs get corrupted in SMSes by some carriers
text = text.replace("¡", "@")
# await on_new_message(
# UserMessage(
# text, out_channel, sender, input_channel=self.name()
# )
# )
user_msg = UserMessage(text, out_channel, sender)
on_new_message(user_msg)
except Exception as e:
logger.error(
"Exception when trying to handle message.{0}".format(e)
)
logger.debug(e, exc_info=True)
if self.debug_mode:
raise
pass
else:
logger.debug("Invalid message")
return response.text("success")
def test_remote_client(http_app, default_agent, tmpdir):
model_path = tmpdir.join("persisted_model").strpath
default_agent.persist(model_path)
remote_agent = RemoteAgent.load(model_path, EndpointConfig(http_app))
message = UserMessage("""/greet{"name":"Rasa"}""",
output_channel=CollectingOutputChannel())
remote_agent.process_message(message)
tracker = remote_agent.core_client.tracker_json("default")
assert len(tracker.get("events")) == 6
# listen
assert tracker["events"][0]["name"] == "action_listen"
# this should be the utterance
assert tracker["events"][1]["text"] == """/greet{"name":"Rasa"}"""
# set slot event
assert tracker["events"][2]["value"] == "Rasa"
# utter action
assert tracker["events"][3]["name"] == "utter_greet"
# this should be the bot utterance
assert tracker["events"][4]["text"] == "hey there Rasa!"
# listen
assert tracker["events"][5]["name"] == "action_listen"
def test_message_processor(default_processor):
out = CollectingOutputChannel()
default_processor.handle_message(UserMessage('/greet{"name":"Core"}', out))
assert {
'recipient_id': 'default',
'text': 'hey there Core!'
} == out.latest_output()
def handle_message(
self,
text_message, # type: Text
message_preprocessor=None, # type: Optional[Callable[[Text], Text]]
output_channel=None, # type: Optional[OutputChannel]
sender_id=UserMessage.DEFAULT_SENDER_ID # type: Optional[Text]
):
# type: (...) -> Optional[List[Text]]
"""Handle a single message.
If a message preprocessor is passed, the message will be passed to that
function first and the return value is then used as the
input for the dialogue engine.
The return value of this function depends on the `output_channel`. If
the output channel is not set, set to `None`, or set
to `CollectingOutputChannel` this function will return the messages
the bot wants to respond.
:Example:
>>> from rasa_core.agent import Agent
>>> agent = Agent.load("examples/restaurantbot/models/dialogue",
... interpreter="examples/restaurantbot/models/nlu/current")
>>> agent.handle_message("hello")
[u'how can I help you?']
"""
# Creates a new processor for the agent and handles
# the single message
processor = self._create_processor(message_preprocessor)
return processor.handle_message(
UserMessage(text_message, output_channel, sender_id))
def handle_reminder(self, reminder_event, dispatcher):
# type: (ReminderScheduled, Dispatcher) -> None
"""Handle a reminder that is triggered asynchronously."""
tracker = self._get_tracker(dispatcher.sender_id)
if not tracker:
logger.warning("Failed to retrieve or create tracker for sender "
"'{}'.".format(dispatcher.sender_id))
return None
if (reminder_event.kill_on_user_message
and self._has_message_after_reminder(tracker, reminder_event)
or not self._is_reminder_still_valid(tracker, reminder_event)):
logger.debug("Canceled reminder because it is outdated. "
"(event: {} id: {})".format(
reminder_event.action_name, reminder_event.name))
else:
# necessary for proper featurization, otherwise the previous
# unrelated message would influence featurization
tracker.update(UserUttered.empty())
action = self._get_action(reminder_event.action_name)
should_continue = self._run_action(action, tracker, dispatcher)
if should_continue:
user_msg = UserMessage(None, dispatcher.output_channel,
dispatcher.sender_id)
self._predict_and_execute_next_action(user_msg, tracker)
# save tracker state to continue conversation from this state
self._save_tracker(tracker)
def handle_reminder(self, reminder_event, dispatcher):
# type: (ReminderScheduled, Dispatcher) -> None
"""Handle a reminder that is triggered asynchronously."""
def has_message_after_reminder(tracker):
"""If the user sent a message after the reminder got scheduled -
it might be better to cancel it."""
for e in reversed(tracker.events):
if isinstance(e,
ReminderScheduled) and e.name == \
reminder_event.name:
return False
elif isinstance(e, UserUttered):
return True
return True # tracker has probably been restarted
tracker = self._get_tracker(dispatcher.sender_id)
if (reminder_event.kill_on_user_message
and has_message_after_reminder(tracker)):
logger.debug("Canceled reminder because it is outdated. "
"(event: {} id: {})".format(
reminder_event.action_name, reminder_event.name))
else:
# necessary for proper featurization, otherwise the previous
# unrelated message would influence featurization
tracker.update(UserUttered.empty())
action = self.domain.action_for_name(reminder_event.action_name)
should_continue = self._run_action(action, tracker, dispatcher)
if should_continue:
user_msg = UserMessage(None, dispatcher.output_channel,
dispatcher.sender_id)
self._predict_and_execute_next_action(user_msg, tracker)
# save tracker state to continue conversation from this state
self._save_tracker(tracker)
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 log_message(sender_id):
request_params = request.get_json(force=True)
message = request_params.get("text")
sender = request_params.get("sender")
parse_data = request_params.get("parse_data")
# TODO: implement properly for agent / bot
if sender != "user":
return Response(jsonify(error="Currently, only user messages can "
"be passed to this endpoint. "
"Messages of sender '{}' can not be "
"handled. ".format(sender)),
status=500,
content_type="application/json")
try:
usermsg = UserMessage(message, None, sender_id, parse_data)
tracker_state = agent.log_message(usermsg)
return jsonify(tracker_state)
except Exception as e:
logger.exception("Caught an exception while logging message.")
return Response(jsonify(error="Server failure. Error: {}"
"".format(e)),
status=500,
content_type="application/json")
def handle_message(sid, data):
output_channel = SocketOutputChatBot(sio, self.bot_message_evt)
message = UserMessage(data['message'],
output_channel,
sid,
input_channel=self.name())
on_new_message(message)
def message():
sender = request.values.get('From', None)
text = request.values.get('Body', None)
out_channel = TwilioOutput(self.account_sid, self.auth_token,
self.twilio_number)
if sender is not None and message is not None:
try:
# @ signs get corrupted in SMSes by some carriers
text = text.replace('¡', '@')
on_new_message(
UserMessage(text,
out_channel,
sender,
input_channel=self.name()))
except Exception as e:
logger.error("Exception when trying to handle "
"message.{0}".format(e))
logger.error(e, exc_info=True)
if self.debug_mode:
raise
pass
else:
logger.debug("Invalid message")
return "success"
def test_int_sender_id_in_user_message():
from rasa_core.channels import UserMessage
# noinspection PyTypeChecker
message = UserMessage("A text", sender_id=1234567890)
assert message.sender_id == "1234567890"
def start_message_handling(self,
text_message,
sender=None):
# type: (Text, Optional[Text]) -> Dict[Text, Any]
processor = self._create_processor()
return processor.start_message_handling(
UserMessage(text_message, None, sender))
def start_message_handling(self,
text_message,
sender_id=UserMessage.DEFAULT_SENDER_ID):
# type: (Text, Optional[Text]) -> Dict[Text, Any]
processor = self._create_processor()
return processor.start_message_handling(
UserMessage(text_message, None, sender_id))
def _record_messages(self, on_message, max_message_limit=None):
logger.info("Bot loaded. Fake user will automatically respond!")
num_messages = 0
while max_message_limit is None or num_messages < max_message_limit:
tracker = self.tracker_store.retrieve('nlu')
text = self.customer.respond_to_action(tracker)
on_message(UserMessage(text, ConsoleOutputChannel()))
num_messages += 1
def handle_unfollow(self, event):
logger.info("Line Unfollow from %s", event["source"]["userId"])
user_msg = UserMessage(
"/unfollow_event",
None,
event["source"]["userId"],
input_channel=self.name()
)
self.on_new_message(user_msg)
def start_message_handling(self,
text_message,
sender_id=UserMessage.DEFAULT_SENDER_ID):
# type: (Text, Optional[Text]) -> Dict[Text, Any]
"""Start to process a messages, returning the next action to take. """
processor = self._create_processor()
return processor.start_message_handling(
UserMessage(text_message, None, sender_id))
def test_message_id_logging(default_processor):
from rasa_core.trackers import DialogueStateTracker
message = UserMessage("If Meg was an egg would she still have a leg?")
tracker = DialogueStateTracker('1', [])
default_processor._handle_message_with_tracker(message, tracker)
logged_event = tracker.events[-1]
assert logged_event.message_id == message.message_id
assert logged_event.message_id is not None
async def webhook(request):
sender_id = self._extract_sender(request)
text = self._extract_message(request)
collector = CallbackOutput(self.callback_endpoint)
await on_new_message(
UserMessage(text,
collector,
sender_id,
input_channel=self.name()))
return response.text("success")
def handle_follow(self, event):
logger.info("Line Follow from %s", event["source"]["userId"])
out_channel = LineOutput(self.line_api, event["replyToken"])
user_msg = UserMessage(
"/follow_event",
out_channel,
event["source"]["userId"],
input_channel=self.name()
)
self.on_new_message(user_msg)
out_channel.send_reply()
def handle_things_unlink(self, event):
logger.info("Line Things Unlink from %s", event["source"]["userId"])
out_channel = LineOutput(self.line_api, event["replyToken"])
user_msg = UserMessage(
"/things_unlink{\"things_deviceId\": \"%s\"}" % event["things"]["deviceId"],
out_channel,
event["source"]["userId"],
input_channel=self.name()
)
self.on_new_message(user_msg)
out_channel.send_reply()
def handle_postback(self, event):
logger.info("Line Postback: %s from %s",
event["postback"]["data"], event["source"]["userId"])
out_channel = LineOutput(self.line_api, event["replyToken"])
user_msg = UserMessage(
event["postback"]["data"],
out_channel,
event["source"]["userId"],
input_channel=self.name()
)
self.on_new_message(user_msg)
out_channel.send_reply()
def start_message_handling(
self,
text_message, # type: Text
sender_id=UserMessage.DEFAULT_SENDER_ID # type: Optional[Text]
):
# type: (...) -> Dict[Text, Any]
"""Start to process a messages, returning the next action to take. """
# Creates a new processor for the agent and starts the
# message handling
processor = self._create_processor()
return processor.start_message_handling(
UserMessage(text_message, None, sender_id))
def run_fake_user(input_channel, max_training_samples=10, serve_forever=True):
logger.info("Starting to train policy")
agent = Agent(RASA_CORE_DOMAIN_PATH,
policies=[MemoizationPolicy(), KerasPolicy()],
interpreter=RegexInterpreter())
agent.train_online(RASA_CORE_TRAINING_DATA_PATH,
input_channel=input_channel,
epochs=RASA_CORE_EPOCHS,
max_training_samples=max_training_samples)
while serve_forever:
agent.handle_message(UserMessage(back, ConsoleOutputChannel()))
return agent
def test_message_processor(default_domain, capsys):
story_filename = "data/dsl_stories/stories_defaultdomain.md"
ensemble = SimplePolicyEnsemble([ScoringPolicy()])
interpreter = RegexInterpreter()
PolicyTrainer(ensemble, default_domain,
BinaryFeaturizer()).train(story_filename, max_history=3)
tracker_store = InMemoryTrackerStore(default_domain)
processor = MessageProcessor(interpreter, ensemble, default_domain,
tracker_store)
processor.handle_message(UserMessage("_greet", ConsoleOutputChannel()))
out, _ = capsys.readouterr()
assert "hey there!" in out
def test_message_processor(default_domain, capsys):
story_filename = "data/dsl_stories/stories_defaultdomain.md"
ensemble = SimplePolicyEnsemble([ScoringPolicy()])
interpreter = RegexInterpreter()
PolicyTrainer(ensemble, default_domain,
BinaryFeaturizer()).train(story_filename, max_history=3)
tracker_store = InMemoryTrackerStore(default_domain)
processor = MessageProcessor(interpreter, ensemble, default_domain,
tracker_store)
out = CollectingOutputChannel()
processor.handle_message(UserMessage("_greet[name=Core]", out))
assert ("default", "hey there Core!") == out.latest_output()
def test_http_parsing():
message = UserMessage('lunch?')
httpretty.register_uri(httpretty.GET, 'https://interpreter.com/parse')
endpoint = EndpointConfig('https://interpreter.com')
httpretty.enable()
inter = RasaNLUHttpInterpreter(endpoint=endpoint)
try:
MessageProcessor(inter, None, None, None, None)._parse_message(message)
except KeyError:
pass # logger looks for intent and entities, so we except
query = httpretty.last_request.querystring
httpretty.disable()
assert query['message_id'][0] == message.message_id
def log_message(self,
message: UserMessage) -> Optional[DialogueStateTracker]:
# preprocess message if necessary
if self.message_preprocessor is not None:
message.text = self.message_preprocessor(message.text)
# we have a Tracker instance for each user
# which maintains conversation state
tracker = self._get_tracker(message.sender_id)
if tracker:
self._handle_message_with_tracker(message, tracker)
# save tracker state to continue conversation from this state
self._save_tracker(tracker)
else:
logger.warning("Failed to retrieve or create tracker for sender "
"'{}'.".format(message.sender_id))
return tracker
async def test_http_parsing():
message = UserMessage('lunch?')
endpoint = EndpointConfig('https://interpreter.com')
with aioresponses() as mocked:
mocked.post('https://interpreter.com/parse', repeat=True, status=200)
inter = RasaNLUHttpInterpreter(endpoint=endpoint)
try:
await MessageProcessor(inter, None, None, None,
None)._parse_message(message)
except KeyError:
pass # logger looks for intent and entities, so we except
r = latest_request(mocked, 'POST', "https://interpreter.com/parse")
assert r
assert json_of_latest_request(r)['message_id'] == message.message_id
