def __init__(self, ws):
self.intent_map = {}
self.skills_map = {}
self.vocab_map = {}
IntentService.__init__(self, ws)
self.emitter.on("mycroft.skills.loaded", self.handle_skill_load)
self.emitter.on("mycroft.skills.shutdown", self.handle_skill_shutdown)
def _starting_up():
"""
Start loading skills.
Starts
- reloading of skills when needed
- a timer to check for internet connection
- a timer for updating skills every hour
- adapt intent service
- padatious intent service
"""
global ws, skill_reload_thread, event_scheduler
ws.on('intent_failure', FallbackSkill.make_intent_failure_handler(ws))
# Create skill_manager listener and invoke the first time
ws.on('skill_manager', skills_manager)
ws.on('mycroft.internet.connected', install_default_skills)
ws.emit(Message('skill_manager', {}))
# Create the Intent manager, which converts utterances to intents
# This is the heart of the voice invoked skill system
PadatiousService(ws)
IntentService(ws)
event_scheduler = EventScheduler(ws)
# Create a thread that monitors the loaded skills, looking for updates
skill_reload_thread = WatchSkills()
skill_reload_thread.daemon = True
skill_reload_thread.start()
# Wait until skills have been loaded once before starting to check
# network connection
skill_reload_thread.wait_loaded_priority()
check_connection()
def _starting_up():
"""
Start loading skills.
Starts
- SkillManager to load/reloading of skills when needed
- a timer to check for internet connection
- adapt intent service
- padatious intent service
"""
global ws, skill_manager, event_scheduler
ws.on('intent_failure', FallbackSkill.make_intent_failure_handler(ws))
# Create the Intent manager, which converts utterances to intents
# This is the heart of the voice invoked skill system
service = IntentService(ws)
PadatiousService(ws, service)
event_scheduler = EventScheduler(ws)
# Create a thread that monitors the loaded skills, looking for updates
skill_manager = SkillManager(ws)
skill_manager.daemon = True
skill_manager.start()
# Wait until skills have been loaded once before starting to check
# network connection
skill_manager.wait_loaded_priority()
check_connection()
def _register_intent_services(bus):
"""Start up the all intent services and connect them as needed.
Arguments:
bus: messagebus client to register the services on
"""
service = IntentService(bus)
# Register handler to trigger fallback system
bus.on('mycroft.skills.fallback',
FallbackSkill.make_intent_failure_handler(bus))
return service
def __init__(self, port=6989, *args, **kwargs):
super().__init__(*args, **kwargs)
self.bus_port = port
intentbus = FakeBus()
intentbus.on("message", self.handle_intent_service_message)
self.intent_service = IntentService(intentbus)
self.intent2skill = {}
self.permission_overrides = {}
self.ee = ExecutorEventEmitter()
self.ee.on("localhive.skill", self.handle_skill_message)
self.ee.on("localhive.utterance", self.intent_service.handle_utterance)
def _starting_up():
"""
Start loading skills.
Starts
- SkillManager to load/reloading of skills when needed
- a timer to check for internet connection
- adapt intent service
- padatious intent service
"""
global bus, skill_manager, event_scheduler, connect_to_mycroft_backend
bus.on('intent_failure', FallbackSkill.make_intent_failure_handler(bus))
# Create the Intent manager, which converts utterances to intents
# This is the heart of the voice invoked skill system
service = IntentService(bus)
try:
PadatiousService(bus, service)
except Exception as e:
LOG.exception('Failed to create padatious handlers '
'({})'.format(repr(e)))
event_scheduler = EventScheduler(bus)
# Create a thread that monitors the loaded skills, looking for updates
try:
skill_manager = SkillManager(bus)
except MsmException:
# skill manager couldn't be created, wait for network connection and
# retry
LOG.info(
'Msm is uninitialized and requires network connection',
'to fetch skill information\n'
'Waiting for network connection...')
while not connected():
time.sleep(30)
skill_manager = SkillManager(bus)
skill_manager.daemon = True
# Wait until priority skills have been loaded before checking
# network connection
# print(skill_manager.msm.repo.get_default_skill_names())
skill_manager.load_priority()
skill_manager.start()
bus.emit(Message('skill.manager.initialised'))
if connect_to_mycroft_backend:
check_connection()
else:
check_connection_without_backend()
def __init__(self, skills_root):
self.skills_root = skills_root
self.emitter = InterceptEmitter()
from mycroft.skills.intent_service import IntentService
from mycroft.skills.padatious_service import PadatiousService
self.ih = IntentService(self.emitter)
self.ps = PadatiousService(self.emitter, self.ih)
self.skills = None
self.emitter.on(
'intent_failure',
FallbackSkill.make_intent_failure_handler(self.emitter))
def make_response(_):
data = dict(result=False)
self.emitter.emit(Message('skill.converse.response', data))
self.emitter.on('skill.converse.request', make_response)
def _load_skills():
global ws, loaded_skills, last_modified_skill, skills_directories, \
skill_reload_thread
# Create skill_manager listener and invoke the first time
ws.on('skill_manager', skills_manager)
ws.emit(Message("skill_manager", {}))
# Create the Intent manager, which converts utterances to intents
# This is the heart of the voice invoked skill system
IntentService(ws)
# Create a thread that monitors the loaded skills, looking for updates
skill_reload_thread = Timer(0, _watch_skills)
skill_reload_thread.daemon = True
skill_reload_thread.start()
def __init__(self, skills_root):
self.load_log = None
self.skills_root = skills_root
self.emitter = InterceptEmitter()
from mycroft.skills.intent_service import IntentService
self.ih = IntentService(self.emitter)
self.skills = None
self.emitter.on(
'mycroft.skills.fallback',
FallbackSkill.make_intent_failure_handler(self.emitter))
def make_response(message):
skill_id = message.data.get('skill_id', '')
data = dict(result=False, skill_id=skill_id)
self.emitter.emit(Message('skill.converse.response', data))
self.emitter.on('skill.converse.request', make_response)
def __init__(self, skills_root):
self.skills_root = skills_root
self.emitter = RegistrationOnlyEmitter()
from mycroft.skills.intent_service import IntentService
self.ih = IntentService(self.emitter)
def setUp(self):
bus = mock.Mock()
self.intent_service = IntentService(bus)
self.intent_service.add_active_skill('atari_skill')
self.intent_service.add_active_skill('c64_skill')
class ConversationTest(TestCase):
def setUp(self):
bus = mock.Mock()
self.intent_service = IntentService(bus)
self.intent_service.add_active_skill('atari_skill')
self.intent_service.add_active_skill('c64_skill')
def test_converse(self):
"""Check that the _converse method reports if the utterance is handled.
Also check that the skill that handled the query is moved to the
top of the active skill list.
"""
def response(message, return_msg_type):
c64 = Message(return_msg_type, {'skill_id': 'c64_skill',
'result': False})
atari = Message(return_msg_type, {'skill_id': 'atari_skill',
'result': True})
msgs = {'c64_skill': c64, 'atari_skill': atari}
return msgs[message.data['skill_id']]
self.intent_service.bus.wait_for_response.side_effect = response
hello = ['hello old friend']
utterance_msg = Message('recognizer_loop:utterance',
data={'lang': 'en-US',
'utterances': hello})
result = self.intent_service._converse(hello, 'en-US', utterance_msg)
# Check that the active skill list was updated to set the responding
# Skill first.
first_active_skill = self.intent_service.active_skills[0][0]
self.assertEqual(first_active_skill, 'atari_skill')
# Check that a skill responded that it could handle the message
self.assertTrue(result)
def test_converse_error(self):
"""Check that all skill IDs in the active_skills list are called.
even if there's an error.
"""
def response(message, return_msg_type):
c64 = Message(return_msg_type, {'skill_id': 'c64_skill',
'result': False})
amiga = Message(return_msg_type,
{'skill_id': 'amiga_skill',
'error': 'skill id does not exist'})
atari = Message(return_msg_type, {'skill_id': 'atari_skill',
'result': False})
msgs = {'c64_skill': c64,
'atari_skill': atari,
'amiga_skill': amiga}
return msgs[message.data['skill_id']]
self.intent_service.add_active_skill('amiga_skill')
self.intent_service.bus.wait_for_response.side_effect = response
hello = ['hello old friend']
utterance_msg = Message('recognizer_loop:utterance',
data={'lang': 'en-US',
'utterances': hello})
result = self.intent_service._converse(hello, 'en-US', utterance_msg)
# Check that the active skill list was updated to set the responding
# Skill first.
# Check that a skill responded that it couldn't handle the message
self.assertFalse(result)
# Check that each skill in the list of active skills were called
call_args = self.intent_service.bus.wait_for_response.call_args_list
sent_skill_ids = [call[0][0].data['skill_id'] for call in call_args]
self.assertEqual(sent_skill_ids,
['amiga_skill', 'c64_skill', 'atari_skill'])
def test_reset_converse(self):
"""Check that a blank stt sends the reset signal to the skills."""
def response(message, return_msg_type):
c64 = Message(return_msg_type,
{'skill_id': 'c64_skill',
'error': 'skill id does not exist'})
atari = Message(return_msg_type, {'skill_id': 'atari_skill',
'result': False})
msgs = {'c64_skill': c64, 'atari_skill': atari}
return msgs[message.data['skill_id']]
reset_msg = Message('mycroft.speech.recognition.unknown',
data={'lang': 'en-US'})
self.intent_service.bus.wait_for_response.side_effect = response
self.intent_service.reset_converse(reset_msg)
# Check send messages
wait_for_response_mock = self.intent_service.bus.wait_for_response
c64_message = wait_for_response_mock.call_args_list[0][0][0]
self.assertTrue(check_converse_request(c64_message, 'c64_skill'))
atari_message = wait_for_response_mock.call_args_list[1][0][0]
self.assertTrue(check_converse_request(atari_message, 'atari_skill'))
first_active_skill = self.intent_service.active_skills[0][0]
self.assertEqual(first_active_skill, 'atari_skill')
class ConversationTest(TestCase):
def setUp(self):
bus = mock.Mock()
self.intent_service = IntentService(bus)
self.intent_service.add_active_skill('atari_skill')
self.intent_service.add_active_skill('c64_skill')
def test_converse(self):
"""Check that the _converse method reports if the utterance is handled.
Also check that the skill that handled the query is moved to the
top of the active skill list.
"""
result = None
def runner(utterances, lang, message):
nonlocal result
result = self.intent_service._converse(utterances, lang, message)
hello = ['hello old friend']
utterance_msg = Message('recognizer_loop:utterance',
data={
'lang': 'en-US',
'utterances': hello
})
t = Thread(target=runner, args=(hello, 'en-US', utterance_msg))
t.start()
time.sleep(0.5)
self.intent_service.handle_converse_response(
Message('converse.response', {
'skill_id': 'c64_skill',
'result': False
}))
time.sleep(0.5)
self.intent_service.handle_converse_response(
Message('converse.response', {
'skill_id': 'atari_skill',
'result': True
}))
t.join()
# Check that the active skill list was updated to set the responding
# Skill first.
first_active_skill = self.intent_service.active_skills[0][0]
self.assertEqual(first_active_skill, 'atari_skill')
# Check that a skill responded that it could handle the message
self.assertTrue(result)
def test_reset_converse(self):
"""Check that a blank stt sends the reset signal to the skills."""
print(self.intent_service.active_skills)
reset_msg = Message('mycroft.speech.recognition.unknown',
data={'lang': 'en-US'})
t = Thread(target=self.intent_service.reset_converse,
args=(reset_msg, ))
t.start()
time.sleep(0.5)
self.intent_service.handle_converse_error(
Message('converse.error', {
'skill_id': 'c64_skill',
'error': 'skill id does not exist'
}))
time.sleep(0.5)
self.intent_service.handle_converse_response(
Message('converse.response', {
'skill_id': 'atari_skill',
'result': False
}))
# Check send messages
c64_message = self.intent_service.bus.emit.call_args_list[0][0][0]
self.assertTrue(check_converse_request(c64_message, 'c64_skill'))
atari_message = self.intent_service.bus.emit.call_args_list[1][0][0]
self.assertTrue(check_converse_request(atari_message, 'atari_skill'))
def setUp(self):
self.intent_service = IntentService(mock.Mock())
class TestIntentServiceApi(TestCase):
def setUp(self):
self.intent_service = IntentService(mock.Mock())
def setup_simple_adapt_intent(self):
msg = create_vocab_msg('testKeyword', 'test')
self.intent_service.handle_register_vocab(msg)
intent = IntentBuilder('skill:testIntent').require('testKeyword')
msg = Message('register_intent', intent.__dict__)
self.intent_service.handle_register_intent(msg)
def test_get_adapt_intent(self):
self.setup_simple_adapt_intent()
# Check that the intent is returned
msg = Message('intent.service.adapt.get', data={'utterance': 'test'})
self.intent_service.handle_get_adapt(msg)
reply = get_last_message(self.intent_service.bus)
self.assertEqual(reply.data['intent']['intent_type'],
'skill:testIntent')
def test_get_adapt_intent_no_match(self):
"""Check that if the intent doesn't match at all None is returned."""
self.setup_simple_adapt_intent()
# Check that no intent is matched
msg = Message('intent.service.adapt.get', data={'utterance': 'five'})
self.intent_service.handle_get_adapt(msg)
reply = get_last_message(self.intent_service.bus)
self.assertEqual(reply.data['intent'], None)
def test_get_intent(self):
"""Check that the registered adapt intent is triggered."""
self.setup_simple_adapt_intent()
# Check that the intent is returned
msg = Message('intent.service.adapt.get', data={'utterance': 'test'})
self.intent_service.handle_get_intent(msg)
reply = get_last_message(self.intent_service.bus)
self.assertEqual(reply.data['intent']['intent_type'],
'skill:testIntent')
def test_get_intent_no_match(self):
"""Check that if the intent doesn't match at all None is returned."""
self.setup_simple_adapt_intent()
# Check that no intent is matched
msg = Message('intent.service.intent.get', data={'utterance': 'five'})
self.intent_service.handle_get_intent(msg)
reply = get_last_message(self.intent_service.bus)
self.assertEqual(reply.data['intent'], None)
def test_get_intent_manifest(self):
"""Check that if the intent doesn't match at all None is returned."""
self.setup_simple_adapt_intent()
# Check that no intent is matched
msg = Message('intent.service.intent.get', data={'utterance': 'five'})
self.intent_service.handle_get_intent(msg)
reply = get_last_message(self.intent_service.bus)
self.assertEqual(reply.data['intent'], None)
def test_get_adapt_intent_manifest(self):
"""Make sure the manifest returns a list of Intent Parser objects."""
self.setup_simple_adapt_intent()
msg = Message('intent.service.adapt.manifest.get')
self.intent_service.handle_adapt_manifest(msg)
reply = get_last_message(self.intent_service.bus)
self.assertEqual(reply.data['intents'][0]['name'],
'skill:testIntent')
def test_get_adapt_vocab_manifest(self):
self.setup_simple_adapt_intent()
msg = Message('intent.service.adapt.vocab.manifest.get')
self.intent_service.handle_vocab_manifest(msg)
reply = get_last_message(self.intent_service.bus)
value = reply.data['vocab'][0]['start']
keyword = reply.data['vocab'][0]['end']
self.assertEqual(keyword, 'testKeyword')
self.assertEqual(value, 'test')
def test_get_no_match_after_detach(self):
"""Check that a removed intent doesn't match."""
self.setup_simple_adapt_intent()
# Check that no intent is matched
msg = Message('detach_intent',
data={'intent_name': 'skill:testIntent'})
self.intent_service.handle_detach_intent(msg)
msg = Message('intent.service.adapt.get', data={'utterance': 'test'})
self.intent_service.handle_get_adapt(msg)
reply = get_last_message(self.intent_service.bus)
self.assertEqual(reply.data['intent'], None)
def test_get_no_match_after_detach_skill(self):
"""Check that a removed skill's intent doesn't match."""
self.setup_simple_adapt_intent()
# Check that no intent is matched
msg = Message('detach_intent',
data={'skill_id': 'skill'})
self.intent_service.handle_detach_skill(msg)
msg = Message('intent.service.adapt.get', data={'utterance': 'test'})
self.intent_service.handle_get_adapt(msg)
reply = get_last_message(self.intent_service.bus)
self.assertEqual(reply.data['intent'], None)
def load_skill(self):
if self.enable_intent:
IntentService(self.ws)
skill_descriptor = create_skill_descriptor(self.dir)
self.skill = load_skill(skill_descriptor, self.ws, hash(self.dir))
