async def async_test_handle_query(self):
"""Verify valid input leads to a query message."""
query_id = str(uuid.uuid4())
text = "set the bedroom light to red"
query = NluQuery(input=text,
id=query_id,
site_id=self.site_id,
session_id=self.session_id)
results = []
async for result in self.hermes.on_message(query):
results.append(result)
# Check results
intent = Intent(intent_name="SetLightColor", confidence_score=1.0)
slots = [
Slot(
entity="name",
slot_name="name",
value={
"kind": "Unknown",
"value": "bedroom"
},
raw_value="bedroom",
confidence=1.0,
range=SlotRange(start=8, end=15, raw_start=8, raw_end=15),
),
Slot(
entity="color",
slot_name="color",
value={
"kind": "Unknown",
"value": "red"
},
raw_value="red",
confidence=1.0,
range=SlotRange(start=25, end=28, raw_start=25, raw_end=28),
),
]
self.assertEqual(
results,
[
NluIntentParsed(
input=text,
id=query_id,
site_id=self.site_id,
session_id=self.session_id,
intent=intent,
slots=slots,
),
(
NluIntent(
input=text,
id=query_id,
site_id=self.site_id,
session_id=self.session_id,
intent=intent,
slots=slots,
asr_tokens=[NluIntent.make_asr_tokens(text.split())],
raw_input=text,
),
{
"intent_name": intent.intent_name
},
),
],
)
def on_message(self, client, userdata, msg):
"""Received message from MQTT broker."""
try:
_LOGGER.debug("Received %s byte(s) on %s", len(msg.payload),
msg.topic)
if msg.topic == DialogueStartSession.topic():
# Start session
json_payload = json.loads(msg.payload)
if not self._check_siteId(json_payload):
return
# Run in event loop (for TTS)
asyncio.run_coroutine_threadsafe(
self.handle_start(DialogueStartSession(**json_payload)),
self.loop)
elif msg.topic == DialogueContinueSession.topic():
# Continue session
json_payload = json.loads(msg.payload)
if not self._check_siteId(json_payload):
return
# Run in event loop (for TTS)
asyncio.run_coroutine_threadsafe(
self.handle_continue(
DialogueContinueSession(**json_payload)),
self.loop,
)
elif msg.topic == DialogueEndSession.topic():
# End session
json_payload = json.loads(msg.payload)
if not self._check_siteId(json_payload):
return
# Run outside event loop
self.handle_end(DialogueEndSession(**json_payload))
elif msg.topic == TtsSayFinished.topic():
# TTS finished
json_payload = json.loads(msg.payload)
if not self._check_sessionId(json_payload):
return
# Signal event loop
self.loop.call_soon_threadsafe(self.say_finished_event.set)
elif msg.topic == AsrTextCaptured.topic():
# Text captured
json_payload = json.loads(msg.payload)
if not self._check_sessionId(json_payload):
return
# Run outside event loop
self.handle_text_captured(AsrTextCaptured(**json_payload))
elif msg.topic.startswith(NluIntent.topic(intent_name="")):
# Intent recognized
json_payload = json.loads(msg.payload)
if not self._check_sessionId(json_payload):
return
self.handle_recognized(NluIntent(**json_payload))
elif msg.topic.startswith(NluIntentNotRecognized.topic()):
# Intent recognized
json_payload = json.loads(msg.payload)
if not self._check_sessionId(json_payload):
return
# Run in event loop (for TTS)
asyncio.run_coroutine_threadsafe(
self.handle_not_recognized(
NluIntentNotRecognized(**json_payload)),
self.loop,
)
elif msg.topic in self.wakeword_topics:
json_payload = json.loads(msg.payload)
if not self._check_siteId(json_payload):
return
wakeword_id = self.wakeword_topics[msg.topic]
asyncio.run_coroutine_threadsafe(
self.handle_wake(wakeword_id,
HotwordDetected(**json_payload)),
self.loop,
)
except Exception:
_LOGGER.exception("on_message")
async def handle_query(
self, query: NluQuery
) -> typing.AsyncIterable[
typing.Union[
NluIntentParsed,
typing.Tuple[NluIntent, TopicArgs],
NluIntentNotRecognized,
NluError,
]
]:
"""Do intent recognition."""
original_input = query.input
try:
self.maybe_load_engine()
assert self.engine, "Snips engine not loaded. You may need to train."
input_text = query.input
# Fix casing for output event
if self.word_transform:
input_text = self.word_transform(input_text)
# Do parsing
result = self.engine.parse(input_text, query.intent_filter)
intent_name = result.get("intent", {}).get("intentName")
confidence_score = result.get("intent", {}).get("probability")
if query.implicit:
if confidence_score > 0.8:
intent_recognized = intent_name is not None
self.publish(HandleToggleOn(self.site_id))
else:
intent_recognized = False
else:
intent_recognized = intent_name is not None
_LOGGER.debug("Intent recognized and Confidence suficient: %s", intent_recognized)
if intent_recognized:
slots = [
Slot(
slot_name=s["slotName"],
entity=s["entity"],
value=s["value"],
raw_value=s["rawValue"],
range=SlotRange(
start=s["range"]["start"], end=s["range"]["end"]
),
)
for s in result.get("slots", [])
]
# intentParsed
yield NluIntentParsed(
input=query.input,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
intent=Intent(intent_name=intent_name, confidence_score=confidence_score),
slots=slots,
)
# intent
yield (
NluIntent(
input=query.input,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
intent=Intent(intent_name=intent_name, confidence_score=confidence_score),
slots=slots,
asr_tokens=[NluIntent.make_asr_tokens(query.input.split())],
raw_input=original_input,
wakeword_id=query.wakeword_id,
lang=query.lang,
),
{"intent_name": intent_name},
)
else:
# Not recognized
_LOGGER.debug("Intent not Recognized and Implicit: %s", query.implicit)
yield NluIntentNotRecognized(
input=query.input,
implicit=query.implicit,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
)
except Exception as e:
_LOGGER.exception("handle_query")
yield NluError(
site_id=query.site_id,
session_id=query.session_id,
error=str(e),
context=original_input,
)
async def handle_query(
self, query: NluQuery
) -> typing.AsyncIterable[typing.Union[NluIntentParsed, typing.Tuple[
NluIntent, TopicArgs], NluIntentNotRecognized, NluError, ]]:
"""Do intent recognition."""
# Check intent graph
try:
if (not self.intent_graph and self.intent_graph_path
and self.intent_graph_path.is_file()):
_LOGGER.debug("Loading %s", self.intent_graph_path)
with open(self.intent_graph_path, mode="rb") as graph_file:
self.intent_graph = rhasspynlu.gzip_pickle_to_graph(
graph_file)
# Check examples
if (self.intent_graph and self.examples_path
and self.examples_path.is_file()):
def intent_filter(intent_name: str) -> bool:
"""Filter out intents."""
if query.intent_filter:
return intent_name in query.intent_filter
return True
original_text = query.input
# Replace digits with words
if self.replace_numbers:
# Have to assume whitespace tokenization
words = rhasspynlu.replace_numbers(query.input.split(),
self.language)
query.input = " ".join(words)
input_text = query.input
# Fix casing
if self.word_transform:
input_text = self.word_transform(input_text)
recognitions: typing.List[rhasspynlu.intent.Recognition] = []
if input_text:
recognitions = rhasspyfuzzywuzzy.recognize(
input_text,
self.intent_graph,
str(self.examples_path),
intent_filter=intent_filter,
extra_converters=self.extra_converters,
)
else:
_LOGGER.error("No intent graph or examples loaded")
recognitions = []
# Use first recognition only if above threshold
if (recognitions and recognitions[0] and recognitions[0].intent
and (recognitions[0].intent.confidence >=
self.confidence_threshold)):
recognition = recognitions[0]
assert recognition.intent
intent = Intent(
intent_name=recognition.intent.name,
confidence_score=recognition.intent.confidence,
)
slots = [
Slot(
entity=(e.source or e.entity),
slot_name=e.entity,
confidence=1.0,
value=e.value_dict,
raw_value=e.raw_value,
range=SlotRange(
start=e.start,
end=e.end,
raw_start=e.raw_start,
raw_end=e.raw_end,
),
) for e in recognition.entities
]
if query.custom_entities:
# Copy user-defined entities
for entity_name, entity_value in query.custom_entities.items(
):
slots.append(
Slot(
entity=entity_name,
confidence=1.0,
value={"value": entity_value},
))
# intentParsed
yield NluIntentParsed(
input=recognition.text,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
intent=intent,
slots=slots,
)
# intent
yield (
NluIntent(
input=recognition.text,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
intent=intent,
slots=slots,
asr_tokens=[
NluIntent.make_asr_tokens(recognition.tokens)
],
asr_confidence=query.asr_confidence,
raw_input=original_text,
wakeword_id=query.wakeword_id,
lang=(query.lang or self.lang),
custom_data=query.custom_data,
),
{
"intent_name": recognition.intent.name
},
)
else:
# Not recognized
yield NluIntentNotRecognized(
input=query.input,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
custom_data=query.custom_data,
)
except Exception as e:
_LOGGER.exception("handle_query")
yield NluError(
site_id=query.site_id,
session_id=query.session_id,
error=str(e),
context=original_text,
)
async def on_raw_message(self, topic: str, payload: bytes):
"""This method handles messages from the MQTT broker.
Arguments:
topic: The topic of the received MQTT message.
payload: The payload of the received MQTT message.
.. warning:: Don't override this method in your app. This is where all the magic happens in Rhasspy Hermes App.
"""
try:
if HotwordDetected.is_topic(topic):
# hermes/hotword/<wakeword_id>/detected
try:
hotword_detected = HotwordDetected.from_json(payload)
for function_h in self._callbacks_hotword:
await function_h(hotword_detected)
except KeyError as key:
_LOGGER.error(
"Missing key %s in JSON payload for %s: %s", key, topic, payload
)
elif NluIntent.is_topic(topic):
# hermes/intent/<intent_name>
try:
nlu_intent = NluIntent.from_json(payload)
intent_name = nlu_intent.intent.intent_name
if intent_name in self._callbacks_intent:
for function_i in self._callbacks_intent[intent_name]:
await function_i(nlu_intent)
except KeyError as key:
_LOGGER.error(
"Missing key %s in JSON payload for %s: %s", key, topic, payload
)
elif NluIntentNotRecognized.is_topic(topic):
# hermes/nlu/intentNotRecognized
try:
nlu_intent_not_recognized = NluIntentNotRecognized.from_json(
payload
)
for function_inr in self._callbacks_intent_not_recognized:
await function_inr(nlu_intent_not_recognized)
except KeyError as key:
_LOGGER.error(
"Missing key %s in JSON payload for %s: %s", key, topic, payload
)
elif DialogueIntentNotRecognized.is_topic(topic):
# hermes/dialogueManager/intentNotRecognized
try:
dialogue_intent_not_recognized = (
DialogueIntentNotRecognized.from_json(payload)
)
for function_dinr in self._callbacks_dialogue_intent_not_recognized:
await function_dinr(dialogue_intent_not_recognized)
except KeyError as key:
_LOGGER.error(
"Missing key %s in JSON payload for %s: %s", key, topic, payload
)
else:
unexpected_topic = True
if topic in self._callbacks_topic:
for function_1 in self._callbacks_topic[topic]:
await function_1(TopicData(topic, {}), payload)
unexpected_topic = False
else:
for function_2 in self._callbacks_topic_regex:
if hasattr(function_2, "topic_extras"):
topic_extras = getattr(function_2, "topic_extras")
for pattern, named_positions in topic_extras:
if re.match(pattern, topic) is not None:
data = TopicData(topic, {})
parts = topic.split(sep="/")
if named_positions is not None:
for name, position in named_positions.items():
data.data[name] = parts[position]
await function_2(data, payload)
unexpected_topic = False
if unexpected_topic:
_LOGGER.warning("Unexpected topic: %s", topic)
except Exception:
_LOGGER.exception("on_raw_message")
def test_http_nlu_new_slot(self):
"""Test recognition with a new slot"""
response = requests.post(
self.api_url("text-to-intent"),
data="what is the weather like in Germany",
params={"outputFormat": "hermes"},
)
self.check_status(response)
# Shouldn't exist yet
result = response.json()
self.assertEqual(result["type"], "intentNotRecognized")
# Get sentences
response = requests.get(self.api_url("sentences"),
headers={"Accept": "application/json"})
self.check_status(response)
sentences = response.json()
try:
# Add new slot
response = requests.post(self.api_url("slots/location"),
json=["Germany", "France"])
self.check_status(response)
# Add new intent
sentences[
"intents/weather.ini"] = "[GetWeather]\nwhat is the weather like in ($location){location}\n"
# Save sentences
response = requests.post(self.api_url("sentences"), json=sentences)
self.check_status(response)
# Re-train
response = requests.post(self.api_url("train"))
self.check_status(response)
# Should work now
response = requests.post(
self.api_url("text-to-intent"),
data="what is the weather like in Germany",
params={"outputFormat": "hermes"},
)
self.check_status(response)
result = response.json()
self.assertEqual(result["type"], "intent")
nlu_intent = NluIntent.from_dict(result["value"])
# Intent name and slots
self.assertEqual(nlu_intent.intent.intent_name, "GetWeather")
slots_by_name = {slot.slot_name: slot for slot in nlu_intent.slots}
self.assertIn("location", slots_by_name)
self.assertEqual(slots_by_name["location"].value["value"],
"Germany")
finally:
# Remove slot
response = requests.post(
self.api_url("slots/location"),
json=[],
params={"overwrite_all": "true"},
)
self.check_status(response)
# Remove sentences
sentences["intents/weather.ini"] = ""
response = requests.post(self.api_url("sentences"), json=sentences)
self.check_status(response)
# Re-train
response = requests.post(self.api_url("train"))
self.check_status(response)
async def handle_query(
self, query: NluQuery
) -> typing.AsyncIterable[typing.Union[NluIntentParsed, typing.Tuple[
NluIntent, TopicArgs], NluIntentNotRecognized, NluError, ]]:
"""Do intent recognition."""
original_input = query.input
try:
if not self.intent_graph and self.graph_path and self.graph_path.is_file(
):
# Load graph from file
_LOGGER.debug("Loading %s", self.graph_path)
with open(self.graph_path, mode="rb") as graph_file:
self.intent_graph = rhasspynlu.gzip_pickle_to_graph(
graph_file)
if self.intent_graph:
def intent_filter(intent_name: str) -> bool:
"""Filter out intents."""
if query.intent_filter:
return intent_name in query.intent_filter
return True
# Replace digits with words
if self.replace_numbers:
# Have to assume whitespace tokenization
words = rhasspynlu.replace_numbers(query.input.split(),
self.language)
query.input = " ".join(words)
input_text = query.input
# Fix casing for output event
if self.word_transform:
input_text = self.word_transform(input_text)
# Pass in raw query input so raw values will be correct
recognitions = recognize(
query.input,
self.intent_graph,
intent_filter=intent_filter,
word_transform=self.word_transform,
fuzzy=self.fuzzy,
)
else:
_LOGGER.error("No intent graph loaded")
recognitions = []
if recognitions:
# Use first recognition only.
recognition = recognitions[0]
assert recognition is not None
assert recognition.intent is not None
intent = Intent(
intent_name=recognition.intent.name,
confidence_score=recognition.intent.confidence,
)
slots = [
Slot(
entity=(e.source or e.entity),
slot_name=e.entity,
confidence=1.0,
value=e.value_dict,
raw_value=e.raw_value,
range=SlotRange(
start=e.start,
end=e.end,
raw_start=e.raw_start,
raw_end=e.raw_end,
),
) for e in recognition.entities
]
# intentParsed
yield NluIntentParsed(
input=recognition.text,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
intent=intent,
slots=slots,
)
# intent
yield (
NluIntent(
input=recognition.text,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
intent=intent,
slots=slots,
asr_tokens=[
NluIntent.make_asr_tokens(recognition.tokens)
],
raw_input=original_input,
wakeword_id=query.wakeword_id,
lang=query.lang,
),
{
"intent_name": recognition.intent.name
},
)
else:
# Not recognized
yield NluIntentNotRecognized(
input=query.input,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
)
except Exception as e:
_LOGGER.exception("handle_query")
yield NluError(
site_id=query.site_id,
session_id=query.session_id,
error=str(e),
context=original_input,
)
async def handle_intent(
self, intent: NluIntent
) -> typing.AsyncIterable[typing.Union[TtsSay]]:
"""Handle intent with remote server or local command."""
try:
if not self.handle_enabled:
_LOGGER.debug("Intent handling is disabled")
return
tts_text = ""
intent_dict = intent.to_rhasspy_dict()
# Add site_id
intent_dict["site_id"] = intent.site_id
if self.handle_url:
# Remote server
_LOGGER.debug(self.handle_url)
async with self.http_session.post(
self.handle_url, json=intent_dict, ssl=self.ssl_context
) as response:
response.raise_for_status()
response_dict = await response.json()
# Check for speech response
tts_text = response_dict.get("speech", {}).get("text", "")
elif self.handle_command:
intent_json = json.dumps(intent_dict)
# Local handling command
_LOGGER.debug(self.handle_command)
proc = await asyncio.create_subprocess_exec(
*self.handle_command,
stdin=asyncio.subprocess.PIPE,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
output, error = await proc.communicate(intent_json.encode())
if error:
_LOGGER.debug(error.decode())
try:
response_dict = json.loads(output)
# Check for speech response
tts_text = response_dict.get("speech", {}).get("text", "")
except json.JSONDecodeError as e:
if output:
# Only report error if non-empty output
_LOGGER.warning("Failed to parse output as JSON: %s", e)
_LOGGER.warning("Output: %s", output)
else:
_LOGGER.warning("Can't handle intent. No handle URL or command.")
if tts_text:
# Forward to TTS system
yield TtsSay(
text=tts_text,
id=str(uuid4()),
site_id=intent.site_id,
session_id=intent.session_id,
)
except Exception:
_LOGGER.exception("handle_intent")
def test_nlu_intent():
"""Test NluIntent."""
assert NluIntent.is_topic(NluIntent.topic(intent_name=intent_name))
assert (NluIntent.get_intent_name(
NluIntent.topic(intent_name=intent_name)) == intent_name)
async def handle_query(
self, query: NluQuery
) -> typing.AsyncIterable[
typing.Union[
typing.Tuple[NluIntent, TopicArgs],
NluIntentParsed,
NluIntentNotRecognized,
NluError,
]
]:
"""Do intent recognition."""
try:
input_text = query.input
# Fix casing
if self.word_transform:
input_text = self.word_transform(input_text)
if self.nlu_url:
# Use remote server
_LOGGER.debug(self.nlu_url)
params = {}
# Add intent filter
if query.intent_filter:
params["intentFilter"] = ",".join(query.intent_filter)
async with self.http_session.post(
self.nlu_url, data=input_text, params=params, ssl=self.ssl_context
) as response:
response.raise_for_status()
intent_dict = await response.json()
elif self.nlu_command:
# Run external command
_LOGGER.debug(self.nlu_command)
proc = await asyncio.create_subprocess_exec(
*self.nlu_command,
stdin=asyncio.subprocess.PIPE,
stdout=asyncio.subprocess.PIPE,
)
input_bytes = (input_text.strip() + "\n").encode()
output, error = await proc.communicate(input_bytes)
if error:
_LOGGER.debug(error.decode())
intent_dict = json.loads(output)
else:
_LOGGER.warning("Not handling NLU query (no URL or command)")
return
intent_name = intent_dict["intent"].get("name", "")
if intent_name:
# Recognized
tokens = query.input.split()
slots = [
Slot(
entity=e["entity"],
slot_name=e["entity"],
confidence=1,
value=e.get("value_details", {"value": ["value"]}),
raw_value=e.get("raw_value", e["value"]),
range=SlotRange(
start=e.get("start", 0),
end=e.get("end", 1),
raw_start=e.get("raw_start"),
raw_end=e.get("raw_end"),
),
)
for e in intent_dict.get("entities", [])
]
yield NluIntentParsed(
input=query.input,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
intent=Intent(
intent_name=intent_name,
confidence_score=intent_dict["intent"].get("confidence", 1.0),
),
slots=slots,
)
yield (
NluIntent(
input=query.input,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
intent=Intent(
intent_name=intent_name,
confidence_score=intent_dict["intent"].get(
"confidence", 1.0
),
),
slots=slots,
asr_tokens=[NluIntent.make_asr_tokens(tokens)],
raw_input=query.input,
wakeword_id=query.wakeword_id,
lang=query.lang,
),
{"intent_name": intent_name},
)
else:
# Not recognized
yield NluIntentNotRecognized(
input=query.input,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
)
except Exception as e:
_LOGGER.exception("handle_query")
yield NluError(
error=repr(e),
context=repr(query),
site_id=query.site_id,
session_id=query.session_id,
)
async def handle_query(
self, query: NluQuery
) -> typing.AsyncIterable[typing.Union[NluIntentParsed, typing.Tuple[
NluIntent, TopicArgs], NluIntentNotRecognized, NluError, ]]:
"""Do intent recognition."""
try:
original_input = query.input
# Replace digits with words
if self.replace_numbers:
# Have to assume whitespace tokenization
words = rhasspynlu.replace_numbers(query.input.split(),
self.number_language)
query.input = " ".join(words)
input_text = query.input
# Fix casing for output event
if self.word_transform:
input_text = self.word_transform(input_text)
parse_url = urljoin(self.rasa_url, "model/parse")
_LOGGER.debug(parse_url)
async with self.http_session.post(
parse_url,
json={
"text": input_text,
"project": self.rasa_project
},
ssl=self.ssl_context,
) as response:
response.raise_for_status()
intent_json = await response.json()
intent = intent_json.get("intent", {})
intent_name = intent.get("name", "")
if intent_name and (query.intent_filter is None
or intent_name in query.intent_filter):
confidence_score = float(intent.get("confidence", 0.0))
slots = [
Slot(
entity=e.get("entity", ""),
slot_name=e.get("entity", ""),
confidence=float(e.get("confidence", 0.0)),
value={
"kind": "Unknown",
"value": e.get("value", "")
},
raw_value=e.get("value", ""),
range=SlotRange(
start=int(e.get("start", 0)),
end=int(e.get("end", 1)),
raw_start=int(e.get("start", 0)),
raw_end=int(e.get("end", 1)),
),
) for e in intent_json.get("entities", [])
]
if query.custom_entities:
# Copy user-defined entities
for entity_name, entity_value in query.custom_entities.items(
):
slots.append(
Slot(
entity=entity_name,
confidence=1.0,
value={"value": entity_value},
))
# intentParsed
yield NluIntentParsed(
input=input_text,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
intent=Intent(intent_name=intent_name,
confidence_score=confidence_score),
slots=slots,
)
# intent
yield (
NluIntent(
input=input_text,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
intent=Intent(
intent_name=intent_name,
confidence_score=confidence_score,
),
slots=slots,
asr_tokens=[
NluIntent.make_asr_tokens(input_text.split())
],
asr_confidence=query.asr_confidence,
raw_input=original_input,
lang=(query.lang or self.lang),
custom_data=query.custom_data,
),
{
"intent_name": intent_name
},
)
else:
# Not recognized
yield NluIntentNotRecognized(
input=query.input,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
custom_data=query.custom_data,
)
except Exception as e:
_LOGGER.exception("nlu query")
yield NluError(
site_id=query.site_id,
session_id=query.session_id,
error=str(e),
context=query.input,
)
def get_template_values(intent_message: NluIntent) -> dict:
return rhasspy_intent.get_template_values(intent_message.to_rhasspy_dict())
"""Tests for rhasspyhermes_app intent."""
# pylint: disable=protected-access,too-many-function-args
import asyncio
import pytest
from rhasspyhermes.intent import Intent
from rhasspyhermes.nlu import NluIntent
from rhasspyhermes_app import HermesApp
INTENT_NAME = "GetTime"
INTENT_TOPIC = f"hermes/intent/{INTENT_NAME}"
INTENT = Intent(INTENT_NAME, 1.0)
NLU_INTENT = NluIntent("what time is it", INTENT)
INTENT_NAME2 = "GetTemperature"
INTENT_TOPIC2 = f"hermes/intent/{INTENT_NAME2}"
INTENT2 = Intent(INTENT_NAME2, 1.0)
NLU_INTENT2 = NluIntent("what's the temperature", INTENT2)
INTENT_NAME3 = "GetWeather"
INTENT_TOPIC3 = f"hermes/intent/{INTENT_NAME3}"
INTENT3 = Intent(INTENT_NAME3, 1.0)
NLU_INTENT3 = NluIntent("how's the weather", INTENT3)
_LOOP = asyncio.get_event_loop()
@pytest.mark.asyncio
async def test_callbacks_intent(mocker):
"""Test intent callbacks."""
async def handle_query(
self, query: NluQuery
) -> typing.AsyncIterable[typing.Union[NluIntentParsed, typing.Tuple[
NluIntent, TopicArgs], NluIntentNotRecognized, NluError, ]]:
"""Do intent recognition."""
original_input = query.input
try:
self.maybe_load_engine()
assert self.engine, "Snips engine not loaded. You may need to train."
input_text = query.input
# Fix casing for output event
if self.word_transform:
input_text = self.word_transform(input_text)
# Do parsing
result = self.engine.parse(input_text, query.intent_filter)
intent_name = result.get("intent", {}).get("intentName")
if intent_name:
slots = [
Slot(
slot_name=s["slotName"],
entity=s["entity"],
value=s["value"],
raw_value=s["rawValue"],
range=SlotRange(start=s["range"]["start"],
end=s["range"]["end"]),
) for s in result.get("slots", [])
]
if query.custom_entities:
# Copy user-defined entities
for entity_name, entity_value in query.custom_entities.items(
):
slots.append(
Slot(
entity=entity_name,
confidence=1.0,
value={"value": entity_value},
))
# intentParsed
yield NluIntentParsed(
input=query.input,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
intent=Intent(intent_name=intent_name,
confidence_score=1.0),
slots=slots,
)
# intent
yield (
NluIntent(
input=query.input,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
intent=Intent(intent_name=intent_name,
confidence_score=1.0),
slots=slots,
asr_tokens=[
NluIntent.make_asr_tokens(query.input.split())
],
asr_confidence=query.asr_confidence,
raw_input=original_input,
wakeword_id=query.wakeword_id,
lang=query.lang,
custom_data=query.custom_data,
),
{
"intent_name": intent_name
},
)
else:
# Not recognized
yield NluIntentNotRecognized(
input=query.input,
id=query.id,
site_id=query.site_id,
session_id=query.session_id,
custom_data=query.custom_data,
)
except Exception as e:
_LOGGER.exception("handle_query")
yield NluError(
site_id=query.site_id,
session_id=query.session_id,
error=str(e),
context=original_input,
)