def in_decoding(self, message: Any, sender: RhasspyActor) -> None:
"""Handle messages in decoding state."""
if isinstance(message, WavTranscription):
message.wakewordId = self.wake_detected_name or "default"
# Fix casing
dict_casing = self.profile.get("speech_to_text.dictionary_casing", "")
if dict_casing == "lower":
message.text = message.text.lower()
elif dict_casing == "upper":
message.text = message.text.upper()
# text -> intent
self._logger.debug("%s (confidence=%s)", message.text, message.confidence)
if self.recorder_class == HTTPAudioRecorder:
# Forward to audio recorder
self.send(self.recorder, message)
# Send to MQTT
payload = json.dumps(
{
"siteId": self.site_id,
"text": message.text,
"likelihood": 1,
"seconds": 0,
"wakeId": message.wakewordId,
"wakewordId": message.wakewordId,
}
).encode()
if self.mqtt is not None:
self.send(
self.mqtt,
MqttPublish(
"rhasspy/speech-to-text/transcription", message.text.encode()
),
)
self.send(self.mqtt, MqttPublish("hermes/asr/textCaptured", payload))
# Forward to observer
if self.observer:
self.send(self.observer, message)
# Pass to intent recognizer
self.send(
self.recognizer,
RecognizeIntent(
message.text, confidence=message.confidence, handle=message.handle
),
)
self.transition("recognizing")
else:
self.handle_any(message, sender)
async def recognize_intent(self,
text: str,
wakeId: str = "") -> IntentRecognized:
"""Recognize an intent from text."""
assert self.actor_system is not None
with self.actor_system.private() as sys:
# Fix casing
dict_casing = self.profile.get("speech_to_text.dictionary_casing",
"")
if dict_casing == "lower":
text = text.lower()
elif dict_casing == "upper":
text = text.upper()
# Replace numbers
if self.profile.get("intent.replace_numbers", True):
language = self.profile.get("language", "")
if not language:
language = None
# 75 -> seventy five
text = numbers_to_words(text, language=language)
result = await sys.async_ask(self.dialogue_manager,
RecognizeIntent(text, handle=False))
assert isinstance(result, IntentRecognized), result
# Add slots
intent_slots = {}
for ev in result.intent.get("entities", []):
intent_slots[ev["entity"]] = ev["value"]
result.intent["slots"] = intent_slots
# Add wake/site ID
result.intent["wakeId"] = wakeId
result.intent["siteId"] = self.profile.get("mqtt.site_id",
"default")
return result
def handle_any(self, message: Any, sender: RhasspyActor) -> None:
"""Handle messages in any state."""
if isinstance(message, ListenForCommand):
# Force voice command
self.handle = message.handle
self.intent_receiver = message.receiver or sender
self.listen_timeout_sec = message.timeout
self.listen_entities = message.entities
self.transition("awake")
elif isinstance(message, GetVoiceCommand):
# Record voice command, but don't do anything with it
self.send(
self.command,
ListenForCommand(message.receiver or sender, timeout=message.timeout),
)
elif isinstance(message, TranscribeWav):
# speech -> text
self.send(
self.decoder,
TranscribeWav(message.wav_data, sender, handle=message.handle),
)
elif isinstance(message, RecognizeIntent):
# text -> intent
self.send(
self.recognizer,
RecognizeIntent(
message.text,
confidence=message.confidence,
receiver=sender,
handle=message.handle,
),
)
elif isinstance(message, HandleIntent):
# intent -> action
self.send(self.handler, HandleIntent(message.intent, sender))
# Forward to MQTT (hermes)
if self.mqtt is not None:
self.send(self.mqtt, IntentRecognized(message.intent))
elif isinstance(message, GetWordPhonemes):
# eSpeak -> CMU
self.send(
self.word_pronouncer, GetWordPhonemes(message.word, receiver=sender)
)
elif isinstance(message, SpeakWord):
# eSpeak -> WAV
self.send(self.word_pronouncer, SpeakWord(message.word, receiver=sender))
elif isinstance(message, GetWordPronunciations):
# word -> [CMU]
self.send(
self.word_pronouncer,
GetWordPronunciations(message.words, n=message.n, receiver=sender),
)
elif isinstance(message, SpeakSentence):
# text -> speech
self.send(
self.speech,
SpeakSentence(
message.sentence,
receiver=sender,
play=message.play,
voice=message.voice,
language=message.language,
),
)
elif isinstance(message, TrainProfile):
# Training
self.reload_actors_after_training = message.reload_actors
self.send(self.wake, StopListeningForWakeWord())
self.training_receiver = message.receiver or sender
self.transition("training_sentences")
# self.send(self.sentence_generator, GenerateSentences())
elif isinstance(message, StartRecordingToBuffer):
# Record WAV
self.send(self.recorder, message)
elif isinstance(message, StopRecordingToBuffer):
# Stop recording WAV
self.send(
self.recorder,
StopRecordingToBuffer(message.buffer_name, message.receiver or sender),
)
elif isinstance(message, StateTransition):
# Track state of every actor
self.handle_transition(message, sender)
elif isinstance(message, GetActorStates):
self.send(sender, self.actor_states)
elif isinstance(message, WakeupMessage):
pass
elif isinstance(message, WavPlayed):
pass
elif isinstance(message, GetProblems):
# Report problems from child actors
self.send(sender, Problems(self.problems))
else:
self.handle_forward(message, sender)