def schedule_repeating_event(self, handler, when, frequency,
data=None, name=None, context=None):
"""Schedule a repeating event.
Arguments:
handler: method to be called
when (datetime): time (in system timezone) for first
calling the handler, or None to
initially trigger <frequency> seconds
from now
frequency (float/int): time in seconds between calls
data (dict, optional): data to send when the handler is called
name (str, optional): reference name, must be unique
context (dict, optional): context (dict, optional): message
context to send when the handler
is called
"""
message = dig_for_message()
context = context or message.context if message else {}
return self.event_scheduler.schedule_repeating_event(
handler,
when,
frequency,
data,
name,
context=context
)
def speak(self, utterance, expect_response=False, wait=False, meta=None):
"""Speak a sentence.
Arguments:
utterance (str): sentence mycroft should speak
expect_response (bool): set to True if Mycroft should listen
for a response immediately after
speaking the utterance.
wait (bool): set to True to block while the text
is being spoken.
meta: Information of what built the sentence.
"""
# registers the skill as being active
meta = meta or {}
meta['skill'] = self.name
self.enclosure.register(self.name)
data = {'utterance': utterance,
'expect_response': expect_response,
'meta': meta}
message = dig_for_message()
m = message.forward("speak", data) if message \
else Message("speak", data)
self.bus.emit(m)
if wait:
wait_while_speaking()
def speak(self, utterance, *args, **kwargs):
if self._current_iot_request:
message = dig_for_message()
self.bus.emit(message.forward(_BusKeys.SPEAK,
data={"skill_id": self.skill_id,
IOT_REQUEST_ID:
self._current_iot_request,
"speak_args": args,
"speak_kwargs": kwargs,
"speak": utterance}))
else:
super().speak(utterance, *args, **kwargs)
def converse(self, utterances, lang="en-us"):
if self.conversing:
message = dig_for_message()
if message:
message = message.reply("node_red.converse",
{"utterance": utterances[0]})
else:
message = Message("node_red.converse",
{"utterance": utterances[0]})
if not message.context.get("platform",
"").startswith("NodeRedMind"):
self.bus.emit(message)
return self.wait_for_node()
return False
def wait_for_node(self):
start = time.time()
self.success = False
self.waiting_for_node = True
while self.waiting_for_node and \
time.time() - start < float(self.settings["timeout"]):
time.sleep(0.1)
if self.waiting_for_node:
message = dig_for_message()
if not message:
message = Message("node_red.timeout")
else:
message.reply("node_red.timeout")
self.bus.emit(message)
self.waiting_for_node = False
return self.success
def wait_for_something(self):
self.log.debug("{name}: waiting".format(name=self.skill_name))
start = time.time()
self.success = False
self.waiting = True
while self.waiting and \
time.time() - start < float(self.settings["timeout"]):
time.sleep(0.1)
if self.waiting:
message = dig_for_message()
if not message:
message = Message(self.namespace + ".timeout")
else:
message.reply(self.namespace + ".timeout")
self.bus.emit(message)
self.waiting = False
self.log.debug("{name}: wait ended".format(name=self.skill_name))
return self.success
def _register_words(self, words: [str], word_type: str):
"""
Emit a message to the controller skill to register vocab.
Emits a message on the bus containing the type and
the words. The message will be picked up by the
controller skill, and the vocabulary will be registered
to that skill.
Args:
words:
word_type:
"""
if words:
message = dig_for_message()
self.bus.emit(
message.forward(_BusKeys.REGISTER,
data={
"skill_id": self.skill_id,
"type": word_type,
"words": list(words)
}))
def schedule_event(self, handler, when, data=None, name=None,
context=None):
"""Schedule a single-shot event.
Arguments:
handler: method to be called
when (datetime/int/float): datetime (in system timezone) or
number of seconds in the future when the
handler should be called
data (dict, optional): data to send when the handler is called
name (str, optional): reference name
NOTE: This will not warn or replace a
previously scheduled event of the same
name.
context (dict, optional): context (dict, optional): message
context to send when the handler
is called
"""
message = dig_for_message()
context = context or message.context if message else {}
return self.event_scheduler.schedule_event(handler, when, data, name,
context=context)
