class MockSkillsLoader(object): """Load a skill and set up emitter """ def __init__(self, skills_root): self.load_log = None 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(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 load_skills(self): skills, self.load_log = load_skills(self.emitter, self.skills_root) self.skills = [s for s in skills if s] self.ps.train(Message('', data=dict(single_thread=True))) return self.emitter.emitter # kick out the underlying emitter def unload_skills(self): unload_skills(self.skills)
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 _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 __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 _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.load_log = None 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(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)