async def test_get_story(
rasa_app: SanicASGITestClient,
conversation_events: List[Event],
until_time: Optional[float],
fetch_all_sessions: Optional[bool],
expected: Text,
):
conversation_id = "some-conversation-ID"
tracker_store = InMemoryTrackerStore(Domain.empty())
tracker = DialogueStateTracker.from_events(conversation_id, conversation_events)
tracker_store.save(tracker)
rasa_app.app.agent.tracker_store = tracker_store
url = f"/conversations/{conversation_id}/story?"
query = {}
if fetch_all_sessions is not None:
query["all_sessions"] = fetch_all_sessions
if until_time is not None:
query["until"] = until_time
_, response = await rasa_app.get(url + urllib.parse.urlencode(query))
assert response.status == 200
assert response.content.decode().strip() == expected
def test_inmemory_tracker_store(pair):
filename, domainpath = pair
domain = Domain.load(domainpath)
tracker = tracker_from_dialogue_file(filename, domain)
tracker_store = InMemoryTrackerStore(domain)
tracker_store.save(tracker)
restored = tracker_store.retrieve(tracker.sender_id)
assert restored == tracker
def test_tracker_store_remembers_max_history(default_domain: Domain):
store = InMemoryTrackerStore(default_domain)
tr = store.get_or_create_tracker("myuser", max_event_history=42)
tr.update(Restarted())
store.save(tr)
tr2 = store.retrieve("myuser")
assert tr._max_event_history == tr2._max_event_history == 42
async def test_get_story_does_not_update_conversation_session(
rasa_app: SanicASGITestClient, monkeypatch: MonkeyPatch
):
conversation_id = "some-conversation-ID"
# domain with short session expiration time of one second
domain = Domain.empty()
domain.session_config = SessionConfig(
session_expiration_time=1 / 60, carry_over_slots=True
)
monkeypatch.setattr(rasa_app.app.agent, "domain", domain)
# conversation contains one session that has expired
now = time.time()
conversation_events = [
ActionExecuted(ACTION_SESSION_START_NAME, timestamp=now - 10),
SessionStarted(timestamp=now - 9),
UserUttered("hi", {"name": "greet"}, timestamp=now - 8),
ActionExecuted("utter_greet", timestamp=now - 7),
]
tracker = DialogueStateTracker.from_events(conversation_id, conversation_events)
# the conversation session has expired
assert rasa_app.app.agent.create_processor()._has_session_expired(tracker)
tracker_store = InMemoryTrackerStore(domain)
tracker_store.save(tracker)
monkeypatch.setattr(rasa_app.app.agent, "tracker_store", tracker_store)
_, response = await rasa_app.get(f"/conversations/{conversation_id}/story")
assert response.status == 200
# expected story is returned
assert (
response.content.decode().strip()
== """version: "2.0"
stories:
- story: some-conversation-ID
steps:
- intent: greet
user: |-
hi
- action: utter_greet"""
)
# the tracker has the same number of events as were initially added
assert len(tracker.events) == len(conversation_events)
# the last event is still the same as before
assert tracker.events[-1].timestamp == conversation_events[-1].timestamp
def marker_trackerstore() -> TrackerStore:
"""Sets up a TrackerStore with 5 trackers in it."""
domain = Domain.empty()
store = InMemoryTrackerStore(domain)
for i in range(5):
tracker = DialogueStateTracker(str(i), None)
tracker.update_with_events([UserUttered(str(j)) for j in range(10)],
domain)
store.save(tracker)
return store
def test_get_or_create():
slot_key = 'location'
slot_val = 'Easter Island'
store = InMemoryTrackerStore(domain)
tracker = store.get_or_create_tracker(UserMessage.DEFAULT_SENDER_ID)
ev = SlotSet(slot_key, slot_val)
tracker.update(ev)
assert tracker.get_slot(slot_key) == slot_val
store.save(tracker)
again = store.get_or_create_tracker(UserMessage.DEFAULT_SENDER_ID)
assert again.get_slot(slot_key) == slot_val
def test_restart_after_retrieval_from_tracker_store(default_domain: Domain):
store = InMemoryTrackerStore(default_domain)
tr = store.get_or_create_tracker("myuser")
synth = [ActionExecuted("action_listen") for _ in range(4)]
for e in synth:
tr.update(e)
tr.update(Restarted())
latest_restart = tr.idx_after_latest_restart()
store.save(tr)
tr2 = store.retrieve("myuser")
latest_restart_after_loading = tr2.idx_after_latest_restart()
assert latest_restart == latest_restart_after_loading
def test_markers_cli_results_save_correctly(tmp_path: Path):
domain = Domain.empty()
store = InMemoryTrackerStore(domain)
for i in range(5):
tracker = DialogueStateTracker(str(i), None)
tracker.update_with_events([SlotSet(str(j), "slot") for j in range(5)],
domain)
tracker.update(ActionExecuted(ACTION_SESSION_START_NAME))
tracker.update(UserUttered("hello"))
tracker.update_with_events(
[SlotSet(str(5 + j), "slot") for j in range(5)], domain)
store.save(tracker)
tracker_loader = MarkerTrackerLoader(store, "all")
results_path = tmp_path / "results.csv"
markers = OrMarker(markers=[
SlotSetMarker("2", name="marker1"),
SlotSetMarker("7", name="marker2")
])
markers.evaluate_trackers(tracker_loader.load(), results_path)
with open(results_path, "r") as results:
result_reader = csv.DictReader(results)
senders = set()
for row in result_reader:
senders.add(row["sender_id"])
if row["marker"] == "marker1":
assert row["session_idx"] == "0"
assert int(row["event_idx"]) >= 2
assert row["num_preceding_user_turns"] == "0"
if row["marker"] == "marker2":
assert row["session_idx"] == "1"
assert int(row["event_idx"]) >= 3
assert row["num_preceding_user_turns"] == "1"
assert len(senders) == 5
async def test_update_conversation_with_events(
rasa_app: SanicASGITestClient,
monkeypatch: MonkeyPatch,
initial_tracker_events: List[Event],
events_to_append: List[Event],
expected_events: List[Event],
):
conversation_id = "some-conversation-ID"
domain = Domain.empty()
tracker_store = InMemoryTrackerStore(domain)
monkeypatch.setattr(rasa_app.app.agent, "tracker_store", tracker_store)
if initial_tracker_events:
tracker = DialogueStateTracker.from_events(
conversation_id, initial_tracker_events
)
tracker_store.save(tracker)
fetched_tracker = await rasa.server.update_conversation_with_events(
conversation_id, rasa_app.app.agent.create_processor(), domain, events_to_append
)
assert list(fetched_tracker.events) == expected_events
class RasaServiceLocal(MqttService):
""" Load RASA model and tracker directly and use to handle intent and routing messages"""
def __init__(self, config, loop):
"""constructor"""
super(RasaServiceLocal, self).__init__(config, loop)
self.config = config
self.subscribe_to = 'hermod/+/rasa/get_domain,hermod/+/rasa/set_slots' \
+ ',hermod/+/dialog/ended,hermod/+/dialog/init,hermod/+/nlu/externalparse,' \
+ 'hermod/+/nlu/parse,hermod/+/intent,hermod/+/intent,hermod/+/dialog/started'
model_path = get_model(
config['services']['RasaServiceLocal'].get('model_path'))
endpoint = EndpointConfig(
config['services']['RasaServiceLocal'].get('rasa_actions_url'))
domain = 'domain.yml'
self.tracker_store = InMemoryTrackerStore(domain)
regex_interpreter = RegexInterpreter()
self.text_interpreter = RasaNLUInterpreter(model_path + '/nlu')
self.agent = Agent.load(model_path,
action_endpoint=endpoint,
tracker_store=self.tracker_store,
interpreter=regex_interpreter)
async def connect_hook(self):
"""mqtt connected callback"""
# SUBSCRIBE
for sub in self.subscribe_to.split(","):
await self.client.subscribe(sub)
await self.client.publish('hermod/rasa/ready', json.dumps({}))
async def on_message(self, message):
"""handle mqtt message"""
topic = "{}".format(message.topic)
parts = topic.split("/")
site = parts[1]
payload_string = str(message.payload, encoding='utf-8')
payload = {}
text = ''
try:
payload = json.loads(payload_string)
except json.JSONDecodeError:
pass
if topic == 'hermod/' + site + '/rasa/set_slots':
if payload:
await self.set_slots(site, payload)
elif topic == 'hermod/' + site + '/nlu/parse':
if payload:
await self.client.publish('hermod/' + site \
+ '/display/startwaiting', json.dumps({}))
text = payload.get('query')
await self.nlu_parse_request(site, text, payload)
await self.client.publish(
'hermod/' + site + '/display/stopwaiting', json.dumps({}))
elif topic == 'hermod/' + site + '/nlu/externalparse':
if payload:
text = payload.get('query')
await self.nlu_external_parse_request(site, text, payload)
elif topic == 'hermod/' + site + '/intent':
if payload:
await self.client.publish('hermod/' + site \
+ '/display/startwaiting', json.dumps({}))
await self.handle_intent(site, payload)
await self.client.publish('hermod/' + \
site + '/display/stopwaiting', json.dumps({}))
elif topic == 'hermod/' + site + '/tts/finished':
await self.client.unsubscribe('hermod/' + site + '/tts/finished')
await self.finish(site, payload)
elif topic == 'hermod/' + site + '/dialog/started':
await self.reset_tracker(site)
elif topic == 'hermod/' + site + '/ ':
# save dialog init data to slots for custom actions
tracker = self.tracker_store.get_or_create_tracker(site)
tracker.update(SlotSet("hermod_client", json.dumps(payload)))
self.tracker_store.save(tracker)
elif topic == 'hermod/' + site + '/rasa/get_domain':
await self.send_domain(site)
elif topic == 'hermod/' + site + '/core/ended':
await self.send_story(site, payload)
async def send_story(self, site, payload):
"""send conversation history for a site"""
# text = payload.get('text', '')
tracker = self.tracker_store.get_or_create_tracker(site)
response = tracker.export_stories()
await self.client.publish('hermod/' + site + \
'/rasa/story', json.dumps({'id': payload.get('id', ''), 'story': response}))
async def send_domain(self, site):
"""send domain for a site"""
await self.client.publish('hermod/' + site + \
'/rasa/domain', json.dumps(self.agent.domain.as_dict()))
async def reset_tracker(self, site):
"""reset conversation history for a site"""
pass
# self.log('RESSET tracker '+site)
# tracker = self.tracker_store.get_or_create_tracker(site)
# tracker._reset()
async def handle_intent(self, site, payload):
"""handle intent message"""
await self.client.publish('hermod/' + site + '/core/started',
json.dumps(payload))
if payload:
intent_name = payload.get('intent', {}).get('name', '')
entities_json = {}
entities = payload.get('entities', [])
for entity in entities:
entities_json[entity.get('entity')] = entity.get('value')
intent_json = "/" + intent_name + json.dumps(entities_json)
messages = []
responses = await self.agent.handle_text(intent_json, sender_id=site, \
output_channel=None)
for response in responses:
messages.append(response.get("text"))
if messages:
message = '. '.join(messages)
await self.client.subscribe('hermod/' + site + '/tts/finished')
await self.client.publish(
'hermod/' + site + '/tts/say',
json.dumps({
"text": message,
"id": payload.get('id', '')
}))
else:
await self.finish(site, payload)
else:
await self.finish(site, payload)
async def set_slots(self, site, payload):
"""set tracker slots"""
tracker = self.tracker_store.get_or_create_tracker(site)
if payload:
for slot in payload.get('slots', []):
tracker.update(SlotSet(slot.get('slot'), slot.get('value')))
self.tracker_store.save(tracker)
await self.client.publish('hermod/' + site + '/dialog/slots', \
json.dumps(tracker.current_slot_values()))
async def send_slots(self, site):
"""send a message with current tracker slots for site"""
tracker = self.tracker_store.get_or_create_tracker(site)
slots = tracker.current_slot_values()
await self.client.publish('hermod/' + site + '/dialog/slots',
json.dumps(slots))
async def finish(self, site, payload):
""" finish intent callback """
tracker = self.tracker_store.get_or_create_tracker(site)
slots = tracker.current_slot_values()
if slots.get('hermod_force_continue', False) == 'true':
tracker.update(SlotSet("hermod_force_continue", None))
tracker.update(SlotSet("hermod_force_end", None))
self.tracker_store.save(tracker)
await self.client.publish(
'hermod/' + site + '/dialog/continue',
json.dumps({"id": payload.get("id", "")}))
elif slots.get('hermod_force_end', False) == 'true':
tracker.update(SlotSet("hermod_force_continue", None))
tracker.update(SlotSet("hermod_force_end", None))
self.tracker_store.save(tracker)
await self.client.publish(
'hermod/' + site + '/dialog/end',
json.dumps({"id": payload.get("id", "")}))
else:
if self.config.get('keep_listening') == "true":
await self.client.publish(
'hermod/' + site + '/dialog/continue',
json.dumps({"id": payload.get("id", "")}))
else:
await self.client.publish(
'hermod/' + site + '/dialog/end',
json.dumps({"id": payload.get("id", "")}))
await self.send_slots(site)
await self.client.publish('hermod/' + site + '/core/ended',
json.dumps(payload))
async def nlu_parse_request(self, site, text, payload):
""" parse text into NLU json and send as message"""
response = await self.text_interpreter.parse(text)
response['id'] = payload.get('id', '')
await self.client.publish('hermod/' + site + '/nlu/intent',
json.dumps(response))
async def nlu_external_parse_request(self, site, text, payload):
""" parse text into NLU json and send as message without invoking hermod flow"""
response = await self.text_interpreter.parse(text)
response['id'] = payload.get('id', '')
await self.client.publish('hermod/' + site + '/nlu/externalintent',
json.dumps(response))
