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))