class Conversation(object): def __init__(self, persona, speaker, profile): self.persona = persona self.speaker = speaker self.profile = profile self.notifier = Notifier(profile) self.brain = Brain(speaker, profile) def handleForever(self): while True: notifications = self.notifier.getAllNotifications() for notif in notifications: self.speaker.say(notif) threshold, transcribed = self.speaker.passiveListen(self.persona) if not threshold or not transcribed: continue input = self.speaker.activeListenToAllOptions(threshold) if input: self.brain.query(self.profile, transcribed)
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) person = None while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) authen = self.mic.authentication_activated() if authen is False: auth = test5.Authentication(0, self.mic) auth.authenticate() person = auth.Person_ret() print(person) authen = self.mic.authentication_activated() print(authen) if authen is False: continue self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: print("ok d5al") self.brain.query(input, person) else: self.mic.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile, isPassiveEnabled): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) self.isPassiveEnabled = isPassiveEnabled def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed, passivePhrases = \ self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) if self.isPassiveEnabled is True and len(passivePhrases) != 0: input = passivePhrases self._logger.debug("Checking for passive phrase '%s' with " + "threshold: %r", input, threshold) else: self._logger.debug("Started to listen actively with " + "threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with " + "threshold: %r", threshold) if input: self.brain.query(input) else: self.mic.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile): self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def delegateInput(self, text): """A wrapper for querying brain.""" # check if input is meant to start the music module if any(x in text.upper() for x in ["SPOTIFY", "MUSIC"]): # check if mpd client is running try: client = MPDClient() client.timeout = None client.idletimeout = None client.connect("localhost", 6600) except: self.mic.say( "I'm sorry. It seems that Spotify is not enabled. Please read the documentation to learn how to configure Spotify." ) return self.mic.say( "Please give me a moment, I'm loading your Spotify playlists.") music_mode = MusicMode(self.persona, self.mic) music_mode.handleForever() return self.brain.query(text) def handleForever(self): """Delegates user input to the handling function when activated.""" while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: print notif try: threshold, transcribed = self.mic.passiveListen(self.persona) except NoDisturbanceDetectedException: print "No disturbance detected" continue if threshold: input = self.mic.activeListen(threshold) if input: self.delegateInput(input) else: self.mic.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile, house): self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile, house) self.notifier = Notifier(profile, house) self.house = house def delegateInput(self, text): """A wrapper for querying brain.""" # check if input is meant to start the music module if any(x in text.upper() for x in ["SPOTIFY", "MUSIC"]): # check if mpd client is running try: client = MPDClient() client.timeout = None client.idletimeout = None client.connect("localhost", 6600) except: self.mic.say( "I'm sorry. It seems that Spotify is not enabled. Please read the documentation to learn how to configure Spotify.") return self.mic.say("Please give me a moment, I'm loading your Spotify playlists.") music_mode = MusicMode(self.persona, self.mic) music_mode.handleForever() return self.brain.query(text) def handleForever(self): """Delegates user input to the handling function when activated.""" while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: print notif self.mic.say(notif) try: threshold, transcribed = self.mic.passiveListen(self.persona) except: continue if threshold: input = self.mic.activeListen(threshold) if input: self.delegateInput(input) else: self.mic.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) # Word we listen for to self terminate TERMINATE = 'GOODBYE' self._logger.debug("Started listening for keyword '%s' or '%s'", self.persona, TERMINATE) threshold, transcribed = self.mic.passiveListen(self.persona, TERMINATE) self._logger.debug("Stopped listening for keyword '%s' or '%s'", self.persona, TERMINATE) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) # Terminate on goodbye if transcribed == TERMINATE: friendly.goodbye(self.mic, self.profile) sys.exit(0) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input) else: self.mic.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while on == True: nu() # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input) else: messages = ["what?", "what did you say", "Say that again?", "speak the f**k up", "i cant f*****g hear you", "blah blah blah", "did you say something?"] message = random.choice(messages) zip2() self.mic.say(message)
class Conversation(object): def __init__(self, persona, mic, server, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) self.server = server def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) if 'jasper.server.enabled' in self.profile and self.profile['jasper.server.enabled']: inputDevice = self.server self._logger.debug("Listening to tcp socket with Jasper server") else: inputDevice = self.mic self._logger.debug("Listening to attached microphone") self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = inputDevice.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = inputDevice.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input) else: inputDevice.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: # Print notifications until empty try: notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input) else: self.mic.say("Pardon?") except KeyboardInterrupt: print "Keyboard Interrupt!" try: sys.exit(0) except SystemExit: os._exit(0)
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) try_num =0 while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) #msg = xbee.Receive() #this is where we get our serial data during downtime if input: self.brain.query(input) else: self.mic.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) self.shutdown = False def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while not self.shutdown: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) self.mic.say(random.choice(["your wish is my command", "what is thy bidding, my master", "I live to serve"])) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input) else: self.mic.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input) else: self.mic.say("Je vous demande pardon monsieur, j'ai mal compris")
class Conversation(object): def __init__(self, persona, mic, profile): self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def delegateInput(self, text): """A wrapper for querying brain.""" # check if input is meant to start the music module ''' if any(x in text.upper() for x in ["SPOTIFY","MUSIC"]): self.mic.say("Please give me a moment, I'm loading your Spotify playlists.") music_mode = MusicMode(self.persona, self.mic) music_mode.handleForever() return ''' self.brain.query(text) def handleForever(self): """Delegates user input to the handling function when activated.""" while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: print notif try: threshold, transcribed = self.mic.passiveListen(self.persona) except: continue if threshold: input = self.mic.activeListen(threshold) if input: self.delegateInput(input) else: self.mic.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile): self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def delegateInput(self, text): """A wrapper for querying brain.""" # check if input is meant to start the music module if any(x in text.upper() for x in ["SPOTIFY","MUSIC"]): self.mic.say("Please give me a moment, I'm loading your Spotify playlists.") music_mode = MusicMode(self.persona, self.mic) music_mode.handleForever() return self.brain.query(text) def handleForever(self): """Delegates user input to the handling function when activated.""" while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: print notif try: threshold, transcribed = self.mic.passiveListen(self.persona) except: continue if threshold: input = self.mic.activeListen(threshold) if input: self.delegateInput(input) else: self.mic.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) global last_checked last_checked = -1 def fetch_siri_command(self, mail): global last_checked mail.list() mail.select("Notes") result, uidlist = mail.search(None, "ALL") latest_email_id = uidlist[0].split()[-1] if latest_email_id == last_checked: return last_checked = latest_email_id result, data = mail.fetch(latest_email_id, "(RFC822)") voice_command = email.message_from_string(data[0][1].decode('utf-8')) c = str(voice_command.get_payload()).lower().strip() return c def main(self): global username global password x = 0 mail = imaplib.IMAP4_SSL('imap.gmail.com', 993) mail.login(username, password) self.fetch_siri_command(mail) x = 1 while x: try: c = str(self.fetch_siri_command(mail)) if c != "None": print("You said " + c) self.brain.query(c, "siri") except Exception as exc: print("Received an exception while running: {exc}" "\nRestarting...".format(**locals())) time.sleep(1) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) thread.start_new_thread(self.main, ()) while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input, "stt") else: self.mic.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def delegateInput(self, texts): """A wrapper for querying brain.""" # check if input is meant to start the music module for text in texts: if any(x in text.upper() for x in ["SPOTIFY", "MUSIC"]): self._logger.debug("Preparing to start music module") # check if mpd client is running try: client = MPDClient() client.timeout = None client.idletimeout = None client.connect("localhost", 6600) except: self._logger.critical("Can't connect to mpd client, cannot start music mode.", exc_info=True) self.mic.say( "I'm sorry. It seems that Spotify is not enabled. Please read the documentation to learn how to configure Spotify.") return self.mic.say("Please give me a moment, I'm loading your Spotify playlists.") self._logger.debug("Starting music mode") music_mode = MusicMode(self.persona, self.mic) music_mode.handleForever() self._logger.debug("Exiting music mode") return self.brain.query(texts) def handleForever(self): """Delegates user input to the handling function when activated.""" self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.delegateInput(input) else: self.mic.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) # Load the aiml module self.aimlkernel = aiml.Kernel() # Load the aiml files folder = "/home/pi/jasper/client/modules/aiml/alice/" for file in os.listdir(folder): if file.endswith(".aiml"): self.aimlkernel.learn(folder+file) print(folder+file) folder = "/home/pi/jasper/client/modules/aiml/standard/" for file in os.listdir(folder): if file.endswith(".aiml"): self.aimlkernel.learn(folder+file) print(folder+file) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input) else: self.mic.say("Pardon?") # Call behaviour tree self._logger.debug("Calling next on the behaviour tree") print("Calling next on the behaviour tree") self.brain.tick()
class Conversation(object): def __init__(self, persona, mic, profile, pygm): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.pygm = pygm self.profile = profile self.brain = Brain(mic, profile, pygm) self.notifier = Notifier(profile) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while self.pygm.on == True: for event in pygame.event.get(): if event.type == pygame.QUIT: on = False if event.type == pygame.KEYDOWN: if event.key == pygame.K_RIGHT: self.pygm.on = False if event.type == pygame.MOUSEBUTTONDOWN: self.pygm.on = False self.pygm.blitimg(image, size, black, x, y) # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input) else: self.pygm.blittxt('???', 400, red, black) messages = [ "what?", "what did you say", "Say that again?", "speak the f**k up", "i cant f*****g hear you", "blah blah blah", "did you say something?" ] message = random.choice(messages) self.mic.say(message) pygame.quit()
class Conversation(object): def __init__(self, mic, profile, logger): self.persona = profile['persona'] self.mic = mic self.profile = profile self.brain = Brain(mic, profile, logger) self.notifier = Notifier(profile, logger) self.logger = logger def delegateInput(self, text): """A wrapper for querying brain.""" got_hit = False # check if input is meant to start the music module if any(x in text.upper() for x in ["SPOTIFY", "MUSIC"]): # check if mpd client is running try: client = MPDClient() client.timeout = None client.idletimeout = None client.connect("localhost", 6600) except: self.logger.warning("Failed to init MPDClient") self.mic.say( "Wybacz, ale najwyraźniej usługa Spotify nie działa") return self.logger.info("waiting for Spotify playlist") self.mic.say("Poczekaj chwilę, wczytuję listę utworów Spotify") music_mode = MusicMode(self.persona, self.mic, self.logger) music_mode.handleForever() return else: if " następnie " in lowerUTF8(text): l_text = text.split(" następnie ") for text in l_text: new_got_hit = self.brain.query(text) got_hit = got_hit or new_got_hit else: got_hit = self.brain.query(text) return got_hit def handleForever(self): """Delegates user input to the handling function when activated.""" initial_threshold = None #self.mic.fetchThreshold(RATE=48000, CHUNK=8192, THRESHOLD_TIME=4, AVERAGE_TIME=4) repeat = True while repeat: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: notif = str_formater.unicodeToUTF8(notif, self.logger) self.logger.info("Got new notification: %s" % notif) #self.mic.say(notif) try: threshold, transcribed = self.mic.passiveListen() except KeyboardInterrupt: threshold = None repeat = False except: self.logger.critical("fatal error processing passive listen", exc_info=True) continue if threshold: if transcribed: input = transcribed else: input = self.mic.activeListen(initial_threshold, RATE=44100, CHUNK=8196, LISTEN_TIME=6, AVERAGE_TIME=5) input = str_formater.unicodeToUTF8(input, self.logger) self.logger.debug("got input %s" % (input)) if input: if any(x in input.upper() for x in ["KONIEC"]): repeat = False self.logger.info("Quiting after voice request") self.mic.say("Kończę pracę. Do usłyszenia.") #elif any(x in input.upper().replace('ł','Ł') for x in ["PRZEŁADUJ"]): elif any(x in upperUTF8(input) for x in ["PRZEŁADUJ"]): self.brain.reload_modules() elif any(x in upperUTF8(input) for x in ["ECHO"]): self.mic.say(input) #self.mic.play(input) else: self.delegateInput(input) else: self.mic.say("Powtórz proszę.")
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) self.wxbot = None def is_proper_time(self): """ whether it's the proper time to gather notifications without disturb user """ if 'do_not_bother' not in self.profile: return True else: if self.profile['do_not_bother']['enable']: if 'since' not in self.profile['do_not_bother'] or \ 'till' not in self.profile['do_not_bother']: return True else: since = self.profile['do_not_bother']['since'] till = self.profile['do_not_bother']['till'] current = time.localtime(time.time()).tm_hour if till > since: return not current in range(since, till) else: return not (current in range(since, 25) or current in range(-1, till)) else: return True def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: # Print notifications until empty if self.is_proper_time(): notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self.mic.say(str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input, self.wxbot) else: self.mic.say("什么?")
class Conversation(object): def __init__(self, mic, profile, logger): self.persona = profile['persona'] self.mic = mic self.profile = profile self.brain = Brain(mic, profile, logger) self.notifier = Notifier(profile, logger) self.logger = logger def delegateInput(self, text): """A wrapper for querying brain.""" got_hit = False # check if input is meant to start the music module if any(x in text.upper() for x in ["SPOTIFY", "MUSIC"]): # check if mpd client is running try: client = MPDClient() client.timeout = None client.idletimeout = None client.connect("localhost", 6600) except: self.logger.warning("Failed to init MPDClient") self.mic.say("Wybacz, ale najwyraźniej usługa Spotify nie działa") return self.logger.info("waiting for Spotify playlist") self.mic.say("Poczekaj chwilę, wczytuję listę utworów Spotify") music_mode = MusicMode(self.persona, self.mic, self.logger) music_mode.handleForever() return else: if " następnie " in lowerUTF8(text): l_text = text.split(" następnie ") for text in l_text: new_got_hit = self.brain.query(text) got_hit = got_hit or new_got_hit else: got_hit = self.brain.query(text) return got_hit def handleForever(self): """Delegates user input to the handling function when activated.""" initial_threshold = None #self.mic.fetchThreshold(RATE=48000, CHUNK=8192, THRESHOLD_TIME=4, AVERAGE_TIME=4) repeat = True while repeat: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: notif = str_formater.unicodeToUTF8(notif, self.logger) self.logger.info("Got new notification: %s" % notif ) #self.mic.say(notif) try: threshold, transcribed = self.mic.passiveListen() except KeyboardInterrupt: threshold = None repeat = False except: self.logger.critical("fatal error processing passive listen", exc_info=True) continue if threshold: if transcribed: input = transcribed else: input = self.mic.activeListen(initial_threshold, RATE=44100, CHUNK=8196, LISTEN_TIME=6, AVERAGE_TIME=5) input = str_formater.unicodeToUTF8(input, self.logger) self.logger.debug("got input %s" % (input)) if input: if any(x in input.upper() for x in ["KONIEC"]): repeat = False self.logger.info("Quiting after voice request") self.mic.say("Kończę pracę. Do usłyszenia.") #elif any(x in input.upper().replace('ł','Ł') for x in ["PRZEŁADUJ"]): elif any(x in upperUTF8(input) for x in ["PRZEŁADUJ"]): self.brain.reload_modules() elif any(x in upperUTF8(input) for x in ["ECHO"]): self.mic.say(input) #self.mic.play(input) else: self.delegateInput(input) else: self.mic.say("Powtórz proszę.")
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) self.radioPaused = False def determineIntent(self, input): if (len(input) == 0): return {} print input[0] parameters = {"q" : input[0].lower()} r = requests.post('https://api.wit.ai/message?v=20150524', headers={ 'Authorization': 'Bearer TBYTRFCCBMHAKHHDKDCR7JTPMKNSVLOS', 'accept': 'application/json'}, params=parameters) print r.url try: r.raise_for_status() text = r.json()['outcomes'] self._logger.info(len(r.json()["outcomes"])) except requests.exceptions.HTTPError: self._logger.critical('Request failed with response: %r', r.text, exc_info=True) return [] except requests.exceptions.RequestException: self._logger.critical('Request failed.', exc_info=True) return [] except ValueError as e: self._logger.critical('Cannot parse response: %s', e.args[0]) return [] except KeyError: self._logger.critical('Cannot parse response.', exc_info=True) return [] else: transcribed = text[0] self._logger.info('Intent: %r', transcribed) return transcribed def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue # Pause the radio if House.radioPlaying(): self.radioPaused = True self._logger.info("Pausing radio...") House.stopRadio() self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if (len(input) > 1): intent = input[1] input = [input[0]] else: intent = self.determineIntent(input) if input: self.brain.query(input,intent) else: self.mic.say("Pardon?") # Resume if necessary if self.radioPaused == True: self.radioPaused = False self._logger.info("Resuming radio...") House.startRadio()
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) found = (transcribed + [''])[0] if 'AMOS' not in found: continue if 'BOUNCE' in found or 'BALANCE' in found: print("BOUNCEING...") bounce() if 'REC' in found or 'RECORD' in found or 'START' in found: print("RECORDING...") record() if 'STOP' in found or 'END' in found: print("STOPPING...") stop_req() if 'DUPLICATE' in found or 'COPY' in found: print("COPYING...") copy_track() if 'FRONT' in found or 'BEGINING' in found or 'FRONT' in found: print("BRINGING BEGIN...") bring_begin() if 'CONFIRM' in found or 'YES' in found or 'ENTER' in found or 'CONTINUE' in found: print("CONFIRMING...") confirm() self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input) else: self.mic.say("Pardon?")
class Conversation(object): def __init__(self, persona, mic, profile, pygm): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.pygm = pygm self.profile = profile self.brain = Brain(mic, profile, pygm) self.notifier = Notifier(profile) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while self.pygm.on == True: for event in pygame.event.get(): if event.type == pygame.QUIT: on = False if event.type == pygame.KEYDOWN: if event.key == pygame.K_RIGHT: self.pygm.on = False if event.type == pygame.MOUSEBUTTONDOWN: self.pygm.on = False self.pygm.blitimg(image, size, black, x, y) # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input) else: self.pygm.blittxt('???', 400, red, black) messages = ["what?", "what did you say", "Say that again?", "speak the f**k up", "i cant f*****g hear you", "blah blah blah", "did you say something?"] message = random.choice(messages) self.mic.say(message) pygame.quit()
class Conversation(object): def __init__(self, persona, mic, profile): self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def delegateInput(self, text, FoundPersona=True): """A wrapper for querying brain.""" if FoundPersona: # check if input is meant to start the music module if any(x in text.upper() for x in ["SPOTIFY", "MUSIC"]): self.mic.say( "Please give me a moment, I'm loading your Spotify playlists." ) music_mode = MusicMode(self.persona, self.mic) music_mode.handleForever() return # Timer module needs to have the notifier instance. # so this module has a different format that the normal ones. # The notifier module will also check more quickly for a timer event. # this will ensure that timer events occur inline with normal program flow # and will call the timer module first # Timer.isValid (text) # Timer.handle(text, self.mic, self.profile, self.notifier): # the handle will now be able to call function in notifier to push on queue. print("testing if timer is valid") if Timer.isValid(text): print("timer is valid") try: Timer.handle(text, self.mic, self.profile, self.notifier) return except: self.mic.say( "I'm sorry. I had some trouble with the timer module. Please try again later." ) return # Query the brain to check if other modules are ok. self.brain.query(text) else: self.brain.passivequery(text) def handleForever(self): """Delegates user input to the handling function when activated.""" while True: # Announce notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self.mic.say(notif) # print notif # GPIO On # GPIO.output(16, GPIO.LOW) try: threshold, transcribed = self.mic.passiveListen(self.persona) except: continue # Off # GPIO.output(16, GPIO.HIGH) # If threshold is false and transcribed value is a string. # then I should look at values if not threshold: if isinstance(transcribed, list): if len(transcribed) == 2: self.delegateInput(transcribed[0], False) print(transcribed[0], ' we did not detect erica') print("in Handleforever") if threshold: input = self.mic.activeListen(threshold) print(input) if input: self.delegateInput(input) else: self.mic.say( "Pardon?. I did not recognize that command. try to say it louder" )
class Conversation(object): def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) # Add reveil now = datetime.now() if now.hour == 8 and now.minute == 35 and now.weekday() < 5: self.mic.say("Debout là dedans c'est l'heure") self._logger.info("Reveil") music = self.getRandomMusic() self._logger.debug("Start playing" + music[0]) call(["mpsyt", "playurl", music[1]]) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input) else: self.mic.say("Pardon?") def getRandomMusic(self, filename=jasperpath.data('text', 'YOUTUBE.txt')): youtubeFile = open(filename, "r") musics = [] start = "" end = "" for line in youtubeFile.readlines(): line = line.replace("\n", "") if start == "": start = line continue if end == "": end = line continue musics.append((start, end)) start = "" end = "" musics.append((start, end)) music = random.choice(musics) return music
class Conversation(object): def off_pressed(self, input_pin): '''Removes dependencies and terminates the script''' self.mic.say("2001 Quote") GPIO.remove_event_detect(3) GPIO.remove_event_detect(5) os.system("sudo service motion stop") raise SystemExit("Quit button pressed") def reset_pressed(self, input_pin): '''Removes dependecies and restarts the script''' self.mic.say("Toby, I'm scared.") GPIO.remove_event_detect(3) GPIO.remove_event_detect(5) os.execl(sys.executable, sys.executable, *sys.argv) def __init__(self, persona, mic, profile): self._logger = logging.getLogger(__name__) self.persona = persona self.mic = mic self.profile = profile self.brain = Brain(mic, profile) self.notifier = Notifier(profile) GPIO.setmode(GPIO.BOARD) GPIO.setup(5, GPIO.IN, pull_up_down=GPIO.PUD_UP) #Reset switch GPIO.setup(3, GPIO.IN, pull_up_down=GPIO.PUD_UP) #Off switch GPIO.add_event_detect(3, GPIO.BOTH, callback=self.off_pressed) GPIO.add_event_detect(5, GPIO.BOTH, callback=self.reset_pressed) def handleForever(self): """ Delegates user input to the handling function when activated. """ self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: # Print notifications until empty notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) threshold, transcribed = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if not transcribed or not threshold: self._logger.info("Nothing has been said or transcribed.") continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug("Started to listen actively with threshold: %r", threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug("Stopped to listen actively with threshold: %r", threshold) if input: self.brain.query(input) else: self.mic.say("Pardon?")