Example #1
0
class Bot(object):
    def __init__(self):
        self.nlg = NLG(user_name=my_name)
        self.speech = Speech(launch_phrase=launch_phrase, debugger_enabled=debugger_enabled)
        self.knowledge = Knowledge(weather_api_token)
        self.vision = Vision(camera=camera)

    def start(self):
        """
        Main loop. Waits for the launch phrase, then decides an action.
        :return:
        """
        while True:
            requests.get("http://localhost:8080/clear")
            if self.vision.recognize_face():
                print "Found face"
                if use_launch_phrase:
                    recognizer, audio = self.speech.listen_for_audio()
                    if self.speech.is_call_to_action(recognizer, audio):
                        self.__acknowledge_action()
                        self.decide_action()

                            
                else:

                    self.decide_action()

                        

    def decide_action(self):
        """
        Recursively decides an action based on the intent.
        :return:
        """
        recognizer, audio = self.speech.listen_for_audio()

        # received audio data, now we'll recognize it using Google Speech Recognition
        speech = self.speech.google_speech_recognition(recognizer, audio)
        #speech = "can you show me a map of Pune"
        #print speech

        if speech is not None:
            try:
                r = requests.get('https://api.wit.ai/message?v=20160918&q=%s' % speech,
                                 headers={"Authorization": wit_ai_token})
                print r.text
                json_resp = json.loads(r.text)
                entities = None
                intent = None
                Status_Type = None
                if 'entities' in json_resp and 'Intent' in json_resp['entities']:
                    entities = json_resp['entities']
                    intent = json_resp['entities']['Intent'][0]["value"]

                print intent
                if 'Status_Type' in json_resp['entities'] :
                    entities = json_resp['entities']
                    Status_Type = json_resp['entities']['Status_Type'][0]["value"]
                    

                #print Status_Type
                if Status_Type is not None:
                   self.__module_action(entities)
                   return 

               

                if intent == 'greeting':
                    self.__text_action(self.nlg.greet())
                elif intent == 'snow white':
                    self.__text_action(self.nlg.snow_white())
                elif intent == 'weather':
                    self.__weather_action(entities)
                elif intent == 'news':
                    self.__news_action()
                elif intent == 'maps':
                    self.__maps_action(entities)
                elif intent == 'youtube':
                    self.__youtube_action(entities)
                    #if self.vision.recognize_face():
                       # print "Found face"
                elif intent == 'zomato':
                    self.__zomato_action(entities)
                elif intent == 'uber':
                    self.__uber_action(entities)        
                elif intent == 'holidays':
                    self.__holidays_action()
                elif intent == 'appearance':
                    self.__appearance_action()
                elif intent == 'user status':
                    self.__user_status_action(entities)
                elif intent == 'user name':
                    self.__user_name_action()
                elif intent == 'personal status':
                    self.__personal_status_action()
                elif intent == 'joke':
                    self.__joke_action()
                elif intent == 'insult':
                    self.__insult_action()
                    return
                elif intent == 'appreciation':
                    self.__appreciation_action()
                    return
                  
                
                elif intent is None:
                    self.__hound_action(speech)
                    return
 

                else:
                     self.__text_action("I'm sorry, I don't know about that yet.")
                     return

                #time.sleep(20)
                

            except Exception as e:
                print "Failed wit!"
                print(e)
                traceback.print_exc()
                self.__text_action("I'm sorry, I couldn't understand what you meant by that")
                return

            self.decide_action()

    def __joke_action(self):
        joke = self.nlg.joke()

        if joke is not None:
            self.__text_action(joke)
        else:
            self.__text_action("I couldn't find any jokes")

    def __user_status_action(self, nlu_entities=None):
        attribute = None

        if (nlu_entities is not None) and ("Status_Type" in nlu_entities):
            attribute = nlu_entities['Status_Type'][0]['value']

        self.__text_action(self.nlg.user_status(attribute=attribute))

    def __user_name_action(self):
        if self.nlg.user_name is None:
            self.__text_action("I don't know your name. You can configure it in bot.py")

        self.__text_action(self.nlg.user_name)

    def __appearance_action(self):
        requests.get("http://localhost:8080/face")

    def __appreciation_action(self):
        self.__text_action(self.nlg.appreciation())

    def __acknowledge_action(self):
        self.__text_action(self.nlg.acknowledge())

    def __insult_action(self):
        self.__text_action(self.nlg.insult())

    def __personal_status_action(self):
        self.__text_action(self.nlg.personal_status())

    def __text_action(self, text=None):
        if text is not None:
            requests.get("http://localhost:8080/statement?text=%s" % text)
            self.speech.synthesize_text(text)

    def __news_action(self):
        headlines = self.knowledge.get_news()

        if headlines:
            requests.post("http://localhost:8080/news", data=json.dumps({"articles":headlines}))
            self.speech.synthesize_text(self.nlg.news("past"))
            interest = self.nlg.article_interest(headlines)
            if interest is not None:
                self.speech.synthesize_text(interest)
        else:
            self.__text_action("I had some trouble finding news for you")

    def __weather_action(self, nlu_entities=None):

        current_dtime = datetime.datetime.now()
        skip_weather = False # used if we decide that current weather is not important

        weather_obj = self.knowledge.find_weather()
        temperature = weather_obj['temperature']
        icon = weather_obj['icon']
        wind_speed = weather_obj['windSpeed']

        weather_speech = self.nlg.weather(temperature, current_dtime, "present")
        forecast_speech = None

        if nlu_entities is not None:
            if 'datetime' in nlu_entities:
                if 'grain' in nlu_entities['datetime'][0] and nlu_entities['datetime'][0]['grain'] == 'day':
                    dtime_str = nlu_entities['datetime'][0]['value'] # 2016-09-26T00:00:00.000-07:00
                    dtime = dateutil.parser.parse(dtime_str)
                    if current_dtime.date() == dtime.date(): # hourly weather
                        forecast_obj = {'forecast_type': 'hourly', 'forecast': weather_obj['daily_forecast']}
                        forecast_speech = self.nlg.forecast(forecast_obj)
                    elif current_dtime.date() < dtime.date(): # sometime in the future ... get the weekly forecast/ handle specific days
                        forecast_obj = {'forecast_type': 'daily', 'forecast': weather_obj['weekly_forecast']}
                        forecast_speech = self.nlg.forecast(forecast_obj)
                        skip_weather = True
            if 'Weather_Type' in nlu_entities:
                weather_type = nlu_entities['Weather_Type'][0]['value']
                print weather_type
                if weather_type == "current":
                    forecast_obj = {'forecast_type': 'current', 'forecast': weather_obj['current_forecast']}
                    forecast_speech = self.nlg.forecast(forecast_obj)
                elif weather_type == 'today':
                    forecast_obj = {'forecast_type': 'hourly', 'forecast': weather_obj['daily_forecast']}
                    forecast_speech = self.nlg.forecast(forecast_obj)
                elif weather_type == 'tomorrow' or weather_type == '3 day' or weather_type == '7 day':
                    forecast_obj = {'forecast_type': 'daily', 'forecast': weather_obj['weekly_forecast']}
                    forecast_speech = self.nlg.forecast(forecast_obj)
                    skip_weather = True


        weather_data = {"temperature": temperature, "icon": icon, 'windSpeed': wind_speed, "hour": datetime.datetime.now().hour}
        requests.post("http://localhost:8080/weather", data=json.dumps(weather_data))

        if not skip_weather:
            self.speech.synthesize_text(weather_speech)

        if forecast_speech is not None:
            self.speech.synthesize_text(forecast_speech)

    def __maps_action(self, nlu_entities=None):

        location = None
        map_type = None
        if nlu_entities is not None:
            if 'location' in nlu_entities:
                location = nlu_entities['location'][0]["value"]
                #location = nlu_entities['search_query'][0]["value"]
            else:
                location = nlu_entities['search_query'][0]["value"]
            if "Map_Type" in nlu_entities:
                map_type = nlu_entities['Map_Type'][0]["value"]

        if location is not None:
            maps_url = self.knowledge.get_map_url(location, map_type)
            maps_action = "Sure. Here's a map of %s." % location
            body = {'url': maps_url}
            requests.post("http://localhost:8080/image", data=json.dumps(body))
            self.speech.synthesize_text(maps_action)
        else:
            self.__text_action("I'm sorry, I couldn't understand what location you wanted.")

    def __youtube_action(self, nlu_entities=None):
        video = None
        DEVELOPER_KEY = ""  #add developer key 
        YOUTUBE_API_SERVICE_NAME = "youtube"
        YOUTUBE_API_VERSION = "v3"
        

        
        if nlu_entities is not None:
            if 'search_query' in nlu_entities:
                video = nlu_entities['search_query'][0]["value"]

        if video is not None:
            youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
            developerKey=DEVELOPER_KEY)
            search_response = youtube.search().list(
            q=video,
            part="id,snippet",
            ).execute()

            
            for search_result in search_response.get("items"):


                if search_result["id"]["kind"] == "youtube#video":
                    id= search_result["id"]["videoId"]
                    ch_title =  search_result["snippet"]["channelTitle"]
                   
                    title =  search_result["snippet"]["title"]
                    break;
                thumb = search_result["snippet"]["thumbnails"]["medium"]    

                


            for search_result in search_response.get("items"):


                thumb = search_result["snippet"]["thumbnails"]["medium"] 
                   
                break;
                   
           
            print id
            #print thumb
            videou = "https://www.youtube.com/embed/" + id + "?autoplay=1&controls=1"
            #print videou
           
            youtube_action = "Sure. Here's a video of %s." % video
            body = {'url': videou, 'channel': ch_title, 'thumb':thumb, 'titles':title}
            requests.post("http://localhost:8080/video", data=json.dumps(body))
            self.speech.synthesize_text(youtube_action)
            time.sleep(8)
            
           
           
        else:
            self.__text_action("I'm sorry, I couldn't understand what video you wanted.")  

    def __zomato_action(self, nlu_entities=None):
        if nlu_entities is not None:
            if 'location' in nlu_entities:
                entities=nlu_entities['location'][0]["value"]
                print entities
                response= requests.get('https://maps.googleapis.com/maps/api/geocode/json?address=%s&key=' %entities) #inset google maps key here
                resp_json_payload = response.json()
                lat=(resp_json_payload['results'][0]['geometry']['location']['lat'])
                lng=(resp_json_payload['results'][0]['geometry']['location']['lng'])

                print lat
                print lng
                locationUrlFromLatLong = "https://developers.zomato.com/api/v2.1/geocode?lat=%s&lon=%s" %(lat,lng)
                header = {"Accept": "application/json", "user_key": ""}  #add user key

                response = requests.get(locationUrlFromLatLong, headers=header)

                restaurants=(response.json().get("nearby_restaurants"))
                name = []
                rating = []
                avgcost = []
                for restaurant in restaurants:
                    name.append(restaurant['restaurant']['name'])
                    avgcost.append(restaurant['restaurant']['average_cost_for_two'])
                    rating.append(restaurant['restaurant']['user_rating']['aggregate_rating'])
                    
                    

                    #print name    

                

                zomato_data = {"cabtype": name, 'maxfare': avgcost, "minfare": rating}
                uber_action = "Sure. Here are some results"
                
                

                requests.post("http://localhost:8080/zomato", data=json.dumps(zomato_data))
                #self.speech.synthesize_text(uber_action)


               

                self.speech.synthesize_text(uber_action)
            
           
           
        else:
            self.__text_action("I'm sorry, I couldn't understand what restaurant you wanted.")  

    
    def __uber_action(self, nlu_entities=None):
        uber = None
        
                
        if nlu_entities is not None:
            if 'location' in nlu_entities:
                 entities3=nlu_entities['search_query'][0]["value"]
                 entities1=nlu_entities['location'][0]["value"]
                 entities2=nlu_entities['location'][1]["value"]
                 print entities3
                 print entities1
                 print entities2

        if entities1 and entities2  is not None:
            response= requests.get('https://maps.googleapis.com/maps/api/geocode/json?address=%s&key=' %entities1) #add key
            resp_json_payload = response.json()

            lat1=(resp_json_payload['results'][0]['geometry']['location']['lat'])
            lng1=(resp_json_payload['results'][0]['geometry']['location']['lng'])

            response = requests.get('https://maps.googleapis.com/maps/api/geocode/json?address=%s&key=' %entities2)  #add key

            resp_json_payload = response.json()
            
            lat2=(resp_json_payload['results'][0]['geometry']['location']['lat'])
            lng2=(resp_json_payload['results'][0]['geometry']['location']['lng'])

            oauth2credential = OAuth2Credential(
            client_id='', #add client id
            access_token='', #get access token
            expires_in_seconds= '2592000',
            scopes='all_trips delivery history history_lite places profile request request_receipt ride_widgets',
            grant_type='authorization_code',
            redirect_url='', #add redirect_url
            client_secret='', #add client secret
            refresh_token='', # add refresh token
        )

            session = Session(oauth2credential=oauth2credential)
            client = UberRidesClient(session, sandbox_mode=True)

            print (client)

            response = client.get_products(lat1, lng1)
            credentials = session.oauth2credential
            #print (response)
            response = client.get_user_profile()
            profile = response.json
            
            # response_uber = client.get_price_estimates(
            #     start_latitude=lat1,
            #     start_longitude=lng1,
            #     end_latitude=lat2,
            #     end_longitude=lng2,
            #     seat_count=1
            # )

            # estimate = response_uber.json.get('prices')

            # print estimate[0]['high_estimate']
            # print estimate[0]['low_estimate']
            # print estimate[0]['localized_display_name']
            # print estimate[0]['currency_code']
            # currency = estimate[0]['currency_code']
            # hi_est =  str(estimate[0]['high_estimate']) + str(estimate[0]['currency_code'])
            # low_est =  str(estimate[0]['low_estimate']) + str(estimate[0]['currency_code'])
            # type_cab =  estimate[0]['localized_display_name']
             

            # print estimate[0]

            response = client.get_products(lat1, lng1)
            products = response.json.get('products')
            #print(products)
            if entities3 == 'Uber go':
                for i in range(1,5):
                    if products[i]['display_name']=='uberGO':
                        product_id = products[i].get('product_id')
                        type_cab = products[i].get('display_name')
            elif entities3 == 'Uber pool':
                for i in range(1,5):
                    if products[i]['display_name']=='POOL':
                        product_id = products[i].get('product_id')
                        type_cab = products[i].get('display_name')
            else:
                product_id = products[0].get('product_id')
                type_cab = products[0].get('display_name')

            

            estimate = client.estimate_ride(
                product_id=product_id,
                start_latitude=lat1,
                start_longitude=lng1,
                end_latitude=lat2,
                end_longitude=lng2,
                seat_count=1
            )
            fare = estimate.json.get('fare') 
            bas = fare['display'] 
            client.cancel_current_ride()
            response = client.request_ride(
             product_id=product_id,
             start_latitude=lat1,
             start_longitude=lng1,
             end_latitude=lat2,
             end_longitude=lng2,
             seat_count=1,
             fare_id=fare['fare_id']
            )  

            request = response.json
            print request
            request_id = request.get('request_id')
            url = 'https://sandbox-api.uber.com/v1.2/sandbox/requests/' + request_id
            ur = 'https://sandbox-api.uber.com/v1.2/requests/' + request_id + '/map'

            token = "" #insert token

            data = {
                "status": "accepted"

                }

            headers = {'Authorization': 'Bearer ' + token, "Content-Type": "application/json"}

#Call REST API
            respons = requests.put(url, data=json.dumps(data), headers=headers)
            respon = requests.get(ur, headers=headers)
            response = client.get_ride_details(request_id)
            ride = response.json
            print ride

            status = ride.get('status')
            dri_name = ride.get('driver').get('name')
            dri_pic = ride.get('driver').get('picture_url')

            eta = ride.get('destination').get('eta')   
            car_pix = ride.get('vehicle').get('picture_url')

            
            # product_name1 = products[3]['display_name'] #GO
            # product_nam2 = products[2]['display_name'] #POOL

            uber_action = "Sure. Booking your uber from %s to %s. Your cab type is %s and estimated time of arrival is %s and fare will be approx %s" % (entities1, entities2, type_cab, eta, bas)
            cab_data = {"cabtype": type_cab, 'maxfare': bas, "minfare": eta, 'to': entities2, 'from': entities1, 'status':status, 'driver': dri_name, 'pic': dri_pic, 'car': car_pix, 'map':ur}
            #print cab_data

            requests.post("http://localhost:8080/cab", data=json.dumps(cab_data))
            self.speech.synthesize_text(uber_action)
            
           
        else:
            self.__text_action("I'm sorry, I don't think that their is any cab available between these two locations.")                

    def __holidays_action(self):
        holidays = self.knowledge.get_holidays()
        next_holiday = self.__find_next_holiday(holidays)
        requests.post("http://localhost:8080/holidays", json.dumps({"holiday": next_holiday}))
        self.speech.synthesize_text(self.nlg.holiday(next_holiday['localName']))

    def __find_next_holiday(self, holidays):
        today = datetime.datetime.now()
        for holiday in holidays:
            date = holiday['date']
            if (date['day'] > today.day) and (date['month'] > today.month):
                return holiday

        # next year
        return holidays[0]


    

    def __module_action(self, nlu_entities=None):
        
        if nlu_entities is not None:
 
            Status_Type = nlu_entities['Status_Type'][0]["value"]
            if 'search_query' in nlu_entities:
                
                video = nlu_entities['search_query'][0]["value"]
                print video
                body = {'url': video, 'sta': Status_Type}
                print body

                requests.post("http://localhost:8080/module", data=json.dumps(body)) 
                print 'Raghav'
                self.speech.synthesize_text("sure")


        
  
    def __hound_action(self, speech=None):
         if speech is not None:
            clientId = "" #get client id from houndify
            clientKey = "" #insert client key
            userId = "test_user"
            requestInfo = {
              "Latitude": 18.5679, 
              "Longitude": 73.9143
            }

            client = houndify.TextHoundClient(clientId, clientKey, userId, requestInfo)
            response = client.query(speech)
            #conversationState = response["AllResults"][0]["ConversationState"]
            #client.setConversationState(conversationState)
            command = response["AllResults"][0]["WrittenResponseLong"]
            
           
            spoken = response["AllResults"][0]["SpokenResponseLong"]
             
            name = []
            rating = []
            avgcost = []    
            url = []  
            print 
            if "Template" in response["AllResults"][0]["ViewType"]:
                if len(response["AllResults"][0]["TemplateData"]["Items"]) > 8:
                    for item in range(0,10):
                        if 'Title' in response["AllResults"][0]["TemplateData"]["Items"][item]["TemplateData"]:
                            name.append(response["AllResults"][0]["TemplateData"]["Items"][item]["TemplateData"]["Title"])
                        if 'Subtitle' in response["AllResults"][0]["TemplateData"]["Items"][item]["TemplateData"]:
                            rating.append(response["AllResults"][0]["TemplateData"]["Items"][item]["TemplateData"]["Subtitle"])
                        if 'BodyText' in response["AllResults"][0]["TemplateData"]["Items"][item]["TemplateData"]:    
                            avgcost.append(response["AllResults"][0]["TemplateData"]["Items"][item]["TemplateData"]["BodyText"])
                        if 'URL' in response["AllResults"][0]["TemplateData"]["Items"][item]["TemplateData"]["Image"]:    
                            url.append(response["AllResults"][0]["TemplateData"]["Items"][item]["TemplateData"]["Image"][ "URL"])


                    hound_data = {"title": name, 'subtitle': rating, "details": avgcost, "url": url, "command": command}
                    requests.post("http://localhost:8080/other", data=json.dumps(hound_data))
                else:   
                    requests.post("http://localhost:8080/other", data=json.dumps(command))
                    

            #requests.get("http://localhost:8080/statement?text=%s" % text)
            #self.speech.synthesize_text(text)
            
            else:
                requests.post("http://localhost:8080/other", data=json.dumps(command))

            self.speech.synthesize_text(spoken)
            self.decide_action()
Example #2
0
 def decide_action():
     recognizer, audio = Speech.listen_for_audio()
     speech = Speech.google_speech_recognition(recognizer, audio)
     if speech is not None:
         main.action(str)
Example #3
0
class Bot(object):
    def __init__(self):
        self.nlg = NLG(user_name=my_name)
        self.speech = Speech(launch_phrase=launch_phrase,
                             debugger_enabled=debugger_enabled)
        self.knowledge = Knowledge(weather_api_token)
        self.vision = Vision(camera=camera)

    def start(self):
        """
        Main loop. Waits for the launch phrase, then decides an action.
        :return:
        """
        while True:
            requests.get("http://localhost:8080/clear")
            if self.vision.recognize_face():
                print "Found face"
                if use_launch_phrase:
                    recognizer, audio = self.speech.listen_for_audio()
                    if self.speech.is_call_to_action(recognizer, audio):
                        self.__acknowledge_action()
                        self.decide_action()
                else:
                    self.decide_action()

    def decide_action(self):
        """
        Recursively decides an action based on the intent.
        :return:
        """
        recognizer, audio = self.speech.listen_for_audio()

        # received audio data, now we'll recognize it using Google Speech Recognition
        speech = self.speech.google_speech_recognition(recognizer, audio)

        if speech is not None:
            try:
                r = requests.get('https://api.wit.ai/message?v=20160918&q=%s' %
                                 speech,
                                 headers={"Authorization": wit_ai_token})
                print r.text
                json_resp = json.loads(r.text)
                entities = None
                intent = None
                if 'entities' in json_resp and 'Intent' in json_resp[
                        'entities']:
                    entities = json_resp['entities']
                    intent = json_resp['entities']['Intent'][0]["value"]

                print intent
                if intent == 'greeting':
                    self.__text_action(self.nlg.greet())
                elif intent == 'snow white':
                    self.__text_action(self.nlg.snow_white())
                elif intent == 'weather':
                    self.__weather_action(entities)
                elif intent == 'news':
                    self.__news_action()
                elif intent == 'maps':
                    self.__maps_action(entities)
                elif intent == 'holidays':
                    self.__holidays_action()
                elif intent == 'appearance':
                    self.__appearance_action()
                elif intent == 'user status':
                    self.__user_status_action(entities)
                elif intent == 'user name':
                    self.__user_name_action()
                elif intent == 'personal status':
                    self.__personal_status_action()
                elif intent == 'joke':
                    self.__joke_action()
                elif intent == 'insult':
                    self.__insult_action()
                    return
                elif intent == 'appreciation':
                    self.__appreciation_action()
                    return
                else:  # No recognized intent
                    self.__text_action(
                        "I'm sorry, I don't know about that yet.")
                    return

            except Exception as e:
                print "Failed wit!"
                print(e)
                traceback.print_exc()
                self.__text_action(
                    "I'm sorry, I couldn't understand what you meant by that")
                return

            self.decide_action()

    def __joke_action(self):
        joke = self.nlg.joke()

        if joke is not None:
            self.__text_action(joke)
        else:
            self.__text_action("I couldn't find any jokes")

    def __user_status_action(self, nlu_entities=None):
        attribute = None

        if (nlu_entities is not None) and ("Status_Type" in nlu_entities):
            attribute = nlu_entities['Status_Type'][0]['value']

        self.__text_action(self.nlg.user_status(attribute=attribute))

    def __user_name_action(self):
        if self.nlg.user_name is None:
            self.__text_action(
                "I don't know your name. You can configure it in bot.py")

        self.__text_action(self.nlg.user_name)

    def __appearance_action(self):
        requests.get("http://localhost:8080/face")

    def __appreciation_action(self):
        self.__text_action(self.nlg.appreciation())

    def __acknowledge_action(self):
        self.__text_action(self.nlg.acknowledge())

    def __insult_action(self):
        self.__text_action(self.nlg.insult())

    def __personal_status_action(self):
        self.__text_action(self.nlg.personal_status())

    def __text_action(self, text=None):
        if text is not None:
            requests.get("http://localhost:8080/statement?text=%s" % text)
            self.speech.synthesize_text(text)

    def __news_action(self):
        headlines = self.knowledge.get_news()

        if headlines:
            requests.post("http://localhost:8080/news",
                          data=json.dumps({"articles": headlines}))
            self.speech.synthesize_text(self.nlg.news("past"))
            interest = self.nlg.article_interest(headlines)
            if interest is not None:
                self.speech.synthesize_text(interest)
        else:
            self.__text_action("I had some trouble finding news for you")

    def __weather_action(self, nlu_entities=None):

        current_dtime = datetime.datetime.now()
        skip_weather = False  # used if we decide that current weather is not important

        weather_obj = self.knowledge.find_weather()
        temperature = weather_obj['temperature']
        icon = weather_obj['icon']
        wind_speed = weather_obj['windSpeed']

        weather_speech = self.nlg.weather(temperature, current_dtime,
                                          "present")
        forecast_speech = None

        if nlu_entities is not None:
            if 'datetime' in nlu_entities:
                if 'grain' in nlu_entities['datetime'][0] and nlu_entities[
                        'datetime'][0]['grain'] == 'day':
                    dtime_str = nlu_entities['datetime'][0][
                        'value']  # 2016-09-26T00:00:00.000-07:00
                    dtime = dateutil.parser.parse(dtime_str)
                    if current_dtime.date() == dtime.date():  # hourly weather
                        forecast_obj = {
                            'forecast_type': 'hourly',
                            'forecast': weather_obj['daily_forecast']
                        }
                        forecast_speech = self.nlg.forecast(forecast_obj)
                    elif current_dtime.date() < dtime.date(
                    ):  # sometime in the future ... get the weekly forecast/ handle specific days
                        forecast_obj = {
                            'forecast_type': 'daily',
                            'forecast': weather_obj['weekly_forecast']
                        }
                        forecast_speech = self.nlg.forecast(forecast_obj)
                        skip_weather = True
            if 'Weather_Type' in nlu_entities:
                weather_type = nlu_entities['Weather_Type'][0]['value']
                print weather_type
                if weather_type == "current":
                    forecast_obj = {
                        'forecast_type': 'current',
                        'forecast': weather_obj['current_forecast']
                    }
                    forecast_speech = self.nlg.forecast(forecast_obj)
                elif weather_type == 'today':
                    forecast_obj = {
                        'forecast_type': 'hourly',
                        'forecast': weather_obj['daily_forecast']
                    }
                    forecast_speech = self.nlg.forecast(forecast_obj)
                elif weather_type == 'tomorrow' or weather_type == '3 day' or weather_type == '7 day':
                    forecast_obj = {
                        'forecast_type': 'daily',
                        'forecast': weather_obj['weekly_forecast']
                    }
                    forecast_speech = self.nlg.forecast(forecast_obj)
                    skip_weather = True

        weather_data = {
            "temperature": temperature,
            "icon": icon,
            'windSpeed': wind_speed,
            "hour": datetime.datetime.now().hour
        }
        requests.post("http://localhost:8080/weather",
                      data=json.dumps(weather_data))

        if not skip_weather:
            self.speech.synthesize_text(weather_speech)

        if forecast_speech is not None:
            self.speech.synthesize_text(forecast_speech)

    def __maps_action(self, nlu_entities=None):

        location = None
        map_type = None
        if nlu_entities is not None:
            if 'location' in nlu_entities:
                location = nlu_entities['location'][0]["value"]
            if "Map_Type" in nlu_entities:
                map_type = nlu_entities['Map_Type'][0]["value"]

        if location is not None:
            maps_url = self.knowledge.get_map_url(location, map_type)
            maps_action = "Sure. Here's a map of %s." % location
            body = {'url': maps_url}
            requests.post("http://localhost:8080/image", data=json.dumps(body))
            self.speech.synthesize_text(maps_action)
        else:
            self.__text_action(
                "I'm sorry, I couldn't understand what location you wanted.")

    def __holidays_action(self):
        holidays = self.knowledge.get_holidays()
        next_holiday = self.__find_next_holiday(holidays)
        requests.post("http://localhost:8080/holidays",
                      json.dumps({"holiday": next_holiday}))
        self.speech.synthesize_text(self.nlg.holiday(
            next_holiday['localName']))

    def __find_next_holiday(self, holidays):
        today = datetime.datetime.now()
        for holiday in holidays:
            date = holiday['date']
            if (date['day'] > today.day) and (date['month'] > today.month):
                return holiday

        # next year
        return holidays[0]
Example #4
0
class Bot(object):
    def __init__(self, name=None, speech_input=False, facebook_input=False):
        self.phrases = Phrases()
        self.speech = Speech()
        self.knowledge = Knowledge(weather_api_token=weather_api_token)
        self.name = name
        self.facebook_input = facebook_input
        if self.facebook_input:
            self.facebook_response = list()
        self.speech_input = speech_input
        self.witai = Wit("S73IKQDWJ22OJMOSD6AOT4CSJOWXIPX6")
        self.fs = Fatsecret("90fe184a283449ed8a83e35790c04d65", "054e80b2be154337af191be2c9e11c28")
        self.translator = Translator()

    def gr_to_en(self, text):
        return self.translator.translate(text, 'en', 'el').text

    def en_to_gr(self, text):
        return self.translator.translate(text, 'el', 'en').text

    def start(self):
        if self.speech_input or self.facebook_input:
            self.decide_action()
        else:
            print("Γεία σου! Πως θα μπορούσα να σε βοηθήσω;")
            while 1:
                self.decide_action()

    def learn_action(self, filename, phraseslist):
        Knowledge.learn_default_responses(file=filename,
                                          phrases=phraseslist)

    def decide_action(self, facebook_input=None):

        if self.speech_input or self.facebook_input:
            if self.speech_input:
                recognizer, audio = self.speech.listen_for_audio()
                # received audio data, now we'll recognize it using Google Speech Recognition
                bot_input = self.speech.google_speech_recognition(recognizer, audio)
            if self.facebook_input:
                self.facebook_response[:] = []
                bot_input = facebook_input
        else:
            bot_input = input()

        if bot_input is not None:
            try:
                resp = self.witai.message(bot_input)
                entities = None
                intent = None
                if 'entities' in resp and 'intent' in resp['entities']:
                    entities = resp['entities']
                    intent = resp['entities']['intent'][0]["value"]
                    # print('Intent: {intent}'.format(intent=intent))
                if intent == 'greeting':
                    self.__text_action(self.phrases.get_phrases('greetings_phrases'))
                elif intent == 'tutorial':
                    self.__tutorial_action()
                elif intent == 'name':
                    if self.name is not None:
                        self.__text_action(self.phrases.get_phrases('name_phrases').replace('<name>', self.name))
                    else:
                        self.__text_action('Οι δημιουργοί μου δεν μου έδωσαν κάποιο όνομα')
                elif intent == 'swear':
                    self.__text_action(self.phrases.get_phrases('swear_phrases'))
                elif intent == 'funny':
                    self.__text_action(self.phrases.get_phrases('funny_phrases'))
                elif intent == 'sex_type':
                    self.__text_action('Λίγο απ\'όλα')
                elif intent == 'user_joke':
                    self.__text_action('χαχαχα')
                elif intent == 'personal_status':
                    self.__personal_status()
                elif intent == 'joke':
                    self.__joke_action()
                elif intent == 'datetime':
                    # print(resp)
                    self.__datetime_action(entities)
                elif intent == 'weather':
                    self.__weather_action()
                elif intent == 'search':
                    self.__search_action(entities)
                elif intent == 'food_det':
                    self.__food_action(entities)
                elif intent == 'recipe':
                    self.__recipe_action(entities)
                elif intent == 'thanksgiving':
                    self.__text_action(self.phrases.get_phrases('thanks_phrases'))
                elif intent == 'sticker':
                    self.__text_action('Επίσης')
                else:  # No recognized intent
                    # print('Intent not recognized')
                    self.__text_action(self.phrases.get_phrases('unrecognized_intent_phrases'))
                    return

            except Exception as e:
                print("Exception occured")
                print(e)
                traceback.print_exc()
                self.__text_action("Έγινε κάποιο λάθος")
                return

    def __text_action(self, text=None):
        if text is not None:
            if self.speech_input:
                self.speech.synthesize_text(text)
            if self.facebook_input:
                self.facebook_response.append(text)
            if not (self.facebook_input or self.speech_input):
                print(text)

    def __tutorial_action(self):
        self.__text_action(self.phrases.get_phrases('tutorial_phrases'))

    def __personal_status(self):
        self.__text_action(self.phrases.get_phrases('personal_status_phrases'))

    def __joke_action(self):
        joke = self.phrases.get_phrases('joke_phrases')
        self.__text_action(joke)

    def __datetime_action(self, entities):
        dt = None
        if 'date' in entities:
            dt = entities['date'][0]['value']
            print('Datetime: {dt}'.format(dt=dt))
        if str(dt) == 'hour':
            self.__text_action('Η ώρα είναι {time}'.format(time=self.knowledge.get_time()))
        elif str(dt) == 'day':
            self.__text_action('Σήμερα είναι {weekday}'.format(weekday=self.knowledge.get_weekday()))
        elif str(dt) == 'date':
            self.__text_action('Σήμερα είναι {date}'.format(date=self.knowledge.get_date()))

    def __weather_action(self):
        weather_obj = self.knowledge.find_weather()
        self.__text_action('Η θερμοκρασία είναι ' + str(weather_obj['temperature']) + '° Κελσίου.')

    def __search_action(self, entities=None):
        self.__text_action(self.phrases.get_phrases('search_phrases'))
        if 'wikipedia_search_query' in entities:
            query = entities['wikipedia_search_query'][0]['value']
            # print('wikipedia query: {query}'.format(query=query))
            wikipedia.set_lang("el")
            try:
                self.__text_action(re.sub(r'\([^)]*\)', '', wikipedia.summary(query, sentences=1)))
            except wikipedia.PageError as e:
                print(e)
                self.__text_action('Δεν βρήκα κάποιο αποτέλεσμα')
        else:
            self.__text_action('Δεν μου είπες τί να ψάξω')

    def __food_action(self, entities):
        self.__text_action(self.phrases.get_phrases('search_phrases'))
        inp = self.gr_to_en(entities['wikipedia_search_query'][0]['value'])
        try:
            resp = self.fs.foods_search(inp)
            food = self.fs.food_get(resp[0]['food_id'])
            if 'nutrient_type' in entities.keys():
                self.__text_action(
                    self.en_to_gr(
                        '{type} - 1 {serving}'.format(serving=food['servings']['serving'][0]['measurement_description'],
                                                      type=resp[0]["food_name"])))
                for nutrient in entities['nutrient_type']:
                    self.__text_action(self.en_to_gr('{nutrient}: {value}'.format(nutrient=nutrient['value'],
                                                                                  value=
                                                                                  food['servings']['serving'][0][
                                                                                      nutrient['value']])))
            else:
                self.__text_action(self.en_to_gr(resp[0]["food_name"] + "\n" + resp[0]["food_description"]))
        except Exception as e:
            self.__text_action(
                "Δεν υπάρχουν διαθέσιμες διατροφικές πληροφορίες για " + entities['wikipedia_search_query'][0]['value'])
            self.__search_action(entities)

    def __recipe_action(self, entities):
        self.__text_action(self.phrases.get_phrases('search_phrases'))
        inp = self.gr_to_en(entities['wikipedia_search_query'][0]['value'])
        try:
            resp = self.fs.recipes_search(inp)
            recipe = self.fs.recipe_get(resp[0]['recipe_id'])
            if self.facebook_input:
                self.__text_action("Μπορείς να δεις την συνταγή στο παρακάτω link:")
                self.__text_action(recipe['recipe_url'])
            else:
                self.__text_action(self.en_to_gr(recipe['recipe_name'] + "\n"))
                self.__text_action("Οδηγίες")
                for dir in recipe['directions']['direction']:
                    self.__text_action(self.en_to_gr(dir['direction_description']))
                self.__text_action("Συστατικά")
                for ing in recipe['ingredients']['ingredient']:
                    self.__text_action(self.en_to_gr(ing['ingredient_description']))
        except Exception as e:
            self.__text_action(
                "Δεν υπάρχει διαθέσιμη συνταγή για " + entities['wikipedia_search_query'][0]['value'])
            self.__search_action(entities)
Example #5
0
class Bot(object):
    def __init__(self):
        self.nlg = NLG(user_name=my_name)
        self.speech = Speech(launch_phrase=launch_phrase,
                             debugger_enabled=debugger_enabled)
        self.knowledge = Knowledge(weather_api_token)
        self.vision = Vision(camera=camera)

    def start(self):
        """
        Main loop. Waits for the launch phrase, then decides an action.
        :return:
        """
        # subprocess.Popen(["aplay", "/home/pi/AI-Smart-Mirror/sample-audio-files/Startup.wav"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        # time.sleep(1)
        self.__setup()
        while True:
            requests.get("http://localhost:8080/clear")
            if self.vision.recognize_face():
                # if True:
                print('Found face')
                if use_launch_phrase:
                    recognizer, audio = self.speech.listen_for_audio()
                    if self.speech.is_call_to_action(recognizer, audio):
                        GPIO.output(LEDPIN, GPIO.HIGH)

                        # set volumn_down 10
                        if self.__ismpvplaying():  #check mpv have play or not
                            if os.path.isfile("/home/pi/.mediavolume.json"):
                                mpvsetvol = os.system("echo '" + json.dumps({
                                    "command":
                                    ["set_property", "volume", "10"]
                                }) + "' | socat - /tmp/mpvsocket")
                            else:
                                mpvgetvol = subprocess.Popen(
                                    [("echo '" + json.dumps({
                                        "command": ["get_property", "volume"]
                                    }) + "' | socat - /tmp/mpvsocket")],
                                    shell=True,
                                    stdout=subprocess.PIPE)
                                output = mpvgetvol.communicate()[0]
                                for currntvol in re.findall(
                                        r"[-+]?\d*\.\d+|\d+", str(output)):
                                    with open('/home/pi/.mediavolume.json',
                                              'w') as vol:
                                        json.dump(currntvol, vol)
                                mpvsetvol = os.system("echo '" + json.dumps({
                                    "command":
                                    ["set_property", "volume", "10"]
                                }) + "' | socat - /tmp/mpvsocket")

                        self.__acknowledge_action()
                        self.decide_action()
                        GPIO.output(LEDPIN, GPIO.LOW)

                        #set back volume
                        if self.__ismpvplaying():  #check mpv have play or not
                            if os.path.isfile("/home/pi/.mediavolume.json"):
                                with open('/home/pi/.mediavolume.json',
                                          'r') as vol:
                                    oldvollevel = json.load(vol)
                                print(oldvollevel)
                                mpvsetvol = os.system("echo '" + json.dumps({
                                    "command": [
                                        "set_property", "volume",
                                        str(oldvollevel)
                                    ]
                                }) + "' | socat - /tmp/mpvsocket")

                else:
                    self.decide_action()

    def __setup(self):
        GPIO.setwarnings(False)
        #set the gpio modes to BCM numbering
        GPIO.setmode(GPIO.BCM)
        #set LEDPIN's mode to output,and initial level to LOW(0V)
        GPIO.setup(LEDPIN, GPIO.OUT, initial=GPIO.LOW)

    def decide_action(self):
        """
        Recursively decides an action based on the intent.
        :return:
        """
        recognizer, audio = self.speech.listen_for_audio()

        # received audio data, now we'll recognize it using Google Speech Recognition
        speech = self.speech.google_speech_recognition(recognizer, audio)

        if speech is not None:
            try:
                r = requests.get('https://api.wit.ai/message?v=20180428&q=%s' %
                                 speech,
                                 headers={"Authorization": wit_ai_token})
                print(r.text)
                json_resp = json.loads(r.text)
                entities = None
                intent = None
                if 'entities' in json_resp and 'Intent' in json_resp[
                        'entities']:
                    entities = json_resp['entities']
                    intent = json_resp['entities']['Intent'][0]["value"]
                if intent == 'greeting':
                    self.__text_action(self.nlg.greet())
                elif intent == 'snow white':
                    self.__text_action(self.nlg.snow_white())
                elif intent == 'weather':
                    self.__weather_action(entities)
                elif intent == 'news':
                    self.__news_action()
                elif intent == 'maps':
                    self.__maps_action(entities)
                elif intent == 'holidays':
                    self.__holidays_action()
                elif intent == 'appearance':
                    self.__appearance_action()
                elif intent == 'user status':
                    self.__user_status_action(entities)
                elif intent == 'user name':
                    self.__user_name_action()
                elif intent == 'personal status':
                    self.__personal_status_action()
                elif intent == 'joke':
                    self.__joke_action()
                elif intent == 'insult':
                    self.__insult_action()
                    return
                elif intent == 'appreciation':
                    self.__appreciation_action()
                    return
                elif intent == 'music':
                    self.__playmusic(entities)
                    return
                elif intent == 'light':
                    self.__light_action(entities)
                    return
                else:  # No recognized intent
                    self.__text_action(
                        "I'm sorry, I don't know about that yet.")
                    return

            except Exception as e:
                print("Failed wit!")
                print(e)
                traceback.print_exc()
                self.__text_action(
                    "I'm sorry, I couldn't understand what you meant by that")
                return

            self.decide_action()

    def __light_action(self, nlu_entities=None):
        action = None
        position = None
        light = Light(23)
        if nlu_entities is not None:
            if 'action' in nlu_entities:
                action = nlu_entities['action'][0]['value']
            if 'position' in nlu_entities:
                position = nlu_entities['position'][0]['value']
            if action == 'on':
                light.turn_on()
            elif action == 'off':
                light.turn_off()
                self.__text_action("Ok")
            else:
                self.__text_action(
                    "I'm sorry, I couldn't understand what you meant by that")

    def __joke_action(self):
        joke = self.nlg.joke()

        if joke is not None:
            self.__text_action(joke)
        else:
            self.__text_action("I couldn't find any jokes")

    def __user_status_action(self, nlu_entities=None):
        attribute = None

        if (nlu_entities is not None) and ("Status_Type" in nlu_entities):
            attribute = nlu_entities['Status_Type'][0]['value']

        self.__text_action(self.nlg.user_status(attribute=attribute))

    def __user_name_action(self):
        if self.nlg.user_name is None:
            self.__text_action(
                "I don't know your name. You can configure it in bot.py")

        self.__text_action(self.nlg.user_name)

    def __appearance_action(self):
        requests.get("http://localhost:8080/face")

    def __appreciation_action(self):
        self.__text_action(self.nlg.appreciation())

    def __acknowledge_action(self):
        self.__text_action(self.nlg.acknowledge())

    def __insult_action(self):
        self.__text_action(self.nlg.insult())

    def __personal_status_action(self):
        self.__text_action(self.nlg.personal_status())

    def __text_action(self, text=None):
        if text is not None:
            requests.get("http://localhost:8080/statement?text=%s" % text)
            # self.speech.synthesize_text(text)
            say(text, language)

    def __news_action(self):
        headlines = self.knowledge.get_news()

        if headlines:
            requests.post("http://localhost:8080/news",
                          data=json.dumps({"articles": headlines}))
            self.speech.synthesize_text(self.nlg.news("past"))
            interest = self.nlg.article_interest(headlines)
            if interest is not None:
                self.speech.synthesize_text(interest)
        else:
            self.__text_action("I had some trouble finding news for you")

    def __weather_action(self, nlu_entities=None):

        current_dtime = datetime.datetime.now()
        skip_weather = False  # used if we decide that current weather is not important

        weather_obj = self.knowledge.find_weather()
        temperature = weather_obj['temperature']
        icon = weather_obj['icon']
        wind_speed = weather_obj['windSpeed']

        weather_speech = self.nlg.weather(temperature, current_dtime,
                                          "present")
        forecast_speech = None

        if nlu_entities is not None:
            if 'datetime' in nlu_entities:
                if 'grain' in nlu_entities['datetime'][0] and nlu_entities[
                        'datetime'][0]['grain'] == 'day':
                    dtime_str = nlu_entities['datetime'][0][
                        'value']  # 2016-09-26T00:00:00.000-07:00
                    dtime = dateutil.parser.parse(dtime_str)
                    if current_dtime.date() == dtime.date():  # hourly weather
                        forecast_obj = {
                            'forecast_type': 'hourly',
                            'forecast': weather_obj['daily_forecast']
                        }
                        forecast_speech = self.nlg.forecast(forecast_obj)
                    elif current_dtime.date() < dtime.date(
                    ):  # sometime in the future ... get the weekly forecast/ handle specific days
                        forecast_obj = {
                            'forecast_type': 'daily',
                            'forecast': weather_obj['weekly_forecast']
                        }
                        forecast_speech = self.nlg.forecast(forecast_obj)
                        skip_weather = True
            if 'Weather_Type' in nlu_entities:
                weather_type = nlu_entities['Weather_Type'][0]['value']
                print(weather_type)
                if weather_type == "current":
                    forecast_obj = {
                        'forecast_type': 'current',
                        'forecast': weather_obj['current_forecast']
                    }
                    forecast_speech = self.nlg.forecast(forecast_obj)
                elif weather_type == 'today':
                    forecast_obj = {
                        'forecast_type': 'hourly',
                        'forecast': weather_obj['daily_forecast']
                    }
                    forecast_speech = self.nlg.forecast(forecast_obj)
                elif weather_type == 'tomorrow' or weather_type == '3 day' or weather_type == '7 day':
                    forecast_obj = {
                        'forecast_type': 'daily',
                        'forecast': weather_obj['weekly_forecast']
                    }
                    forecast_speech = self.nlg.forecast(forecast_obj)
                    skip_weather = True

        weather_data = {
            "temperature": temperature,
            "icon": icon,
            'windSpeed': wind_speed,
            "hour": datetime.datetime.now().hour
        }
        requests.post("http://localhost:8080/weather",
                      data=json.dumps(weather_data))

        if not skip_weather:
            # self.speech.synthesize_text(weather_speech)
            say(weather_speech)

        if forecast_speech is not None:
            # self.speech.synthesize_text(forecast_speech)
            say(forecast_speech)

    def __maps_action(self, nlu_entities=None):

        location = None
        map_type = None
        origin = None
        destination = None
        if nlu_entities is not None:
            if 'location' in nlu_entities:
                location = nlu_entities['location'][0]["value"]
            if "Map_Type" in nlu_entities:
                map_type = nlu_entities['Map_Type'][0]["value"]
            if 'origin' in nlu_entities:
                origin = nlu_entities['origin'][0]["value"]
            if 'destination' in nlu_entities:
                destination = nlu_entities['destination'][0]["value"]

        if origin is not None:
            if destination is not None:
                print(origin, destination)

        if location is not None:
            maps_url = self.knowledge.get_map_url(location, map_type)
            maps_action = "Sure. Here's a map of %s." % location
            body = {'url': maps_url}
            requests.post("http://localhost:8080/image", data=json.dumps(body))
            self.speech.synthesize_text(maps_action)
        else:
            self.__text_action(
                "I'm sorry, I couldn't understand what location you wanted.")

    def __playmusic(self, nlu_entities=None):
        chanel = None
        action = None
        region_code = 'VN'
        location = None
        local_search_query = None

        if nlu_entities is not None:
            if 'chanel' in nlu_entities:
                chanel = nlu_entities['chanel'][0]['value']
            if 'action' in nlu_entities:
                action = nlu_entities['action'][0]['value']
            if 'local_search_query' in nlu_entities:
                local_search_query = nlu_entities['local_search_query'][0][
                    'value']
            if 'location' in nlu_entities:
                location = nlu_entities['location'][0]['value']
                region_code = self.knowledge.get_country_code(location)
            if chanel is not None:
                if 'youtube' == chanel:
                    if 'play' == action:
                        stop()
                        if local_search_query is not None:
                            YouTube_Autoplay(local_search_query, region_code)
                        else:
                            YouTube_Autoplay('Le quyen', region_code)
                    elif 'stop' == action:
                        stop()
                        self.__text_action("OK, stoped it")
                    else:
                        self.__text_action("what are you want to do %s" %
                                           my_name)

    def __holidays_action(self):
        holidays = self.knowledge.get_holidays()
        next_holiday = self.__find_next_holiday(holidays)
        requests.post("http://localhost:8080/holidays",
                      json.dumps({"holiday": next_holiday}))
        self.speech.synthesize_text(self.nlg.holiday(
            next_holiday['localName']))

    def __find_next_holiday(self, holidays):
        today = datetime.datetime.now()
        for holiday in holidays:
            date = holiday['date']
            if (date['day'] > today.day) and (date['month'] > today.month):
                return holiday

        # next year
        return holidays[0]

    #Function to check if mpv is playing
    def __ismpvplaying(self):
        for pid in psutil.pids():
            p = psutil.Process(pid)
            if 'mpv' in p.name():
                mpvactive = True
                break
            else:
                mpvactive = False
        return mpvactive
Example #6
0
class Jarvis(object):
    my_name = "Scott"
    launch_phrase = "jarvis"
    use_launch_phrase = True
    debugger_enabled = True
    location = "hoboken"
    unknown_fieldnames = ['Command', 'Action']
    awake = False

    def __init__(self):
        self.nlg = NLG(user_name=self.my_name)
        self.speech = Speech(launch_phrase=self.launch_phrase,
                             debugger_enabled=self.debugger_enabled)
        self.actions = Actions(self.location)
        if os.path.isfile('unknown_commands.csv') == False:
            with open('unknown_commands.csv', 'w') as csvfile:
                writer = csv.DictWriter(csvfile,
                                        fieldnames=self.unknown_fieldnames)
                writer.writeheader()

    def start(self):
        """
        Main loop. Waits for the launch phrase, then decides an action.
        """
        while True:
            requests.get('http://localhost:8080/clear')
            if self.use_launch_phrase:
                recognizer, audio = self.speech.listen_for_audio(self.awake)
                text = self.speech.google_speech_recognition(recognizer, audio)
                if text is not None and self.launch_phrase in text.lower():
                    self.awake = True
                    #self.__acknowledge_action()
                    self.decide_action(text)
                else:
                    if self.awake == True:
                        self.decide_action(text)
                    else:
                        self.speech.debugger_microphone(enable=False)

    def decide_action(self, text):
        """
        Reursively decides an action based on the intent.
        """
        acknowledgement = False
        if text is not None and self.awake == True:
            text = text.lower()
            if "hide" in text:
                if "time" in text:
                    self.__hide_action("time")
                if "weather" in text:
                    self.__hide_action("weather")
                if "calendar" in text:
                    self.__hide_action("calendar")
                if "commute" in text:
                    self.__hide_action("commute")
                if "all" in text:
                    self.__hide_action("all")
                return
            if "show" in text:
                if "time" in text:
                    self.__show_action("time")
                if "weather" in text:
                    self.__show_action("weather")
                if "calendar" in text:
                    self.__show_action("calendar")
                if "commute" in text:
                    self.__show_action("commute")
                if "all" in text:
                    self.__show_action("all")
                return
            if "hello" in text or "good morning" in text or "good afternoon" in text or "good evening" in text or "hey" in text or "hi" in text:
                if "jarvis" in text:
                    self.__acknowledge_action()
                    acknowledgement = True
                else:
                    self.__greet_action()
                    return
            if "how are you" in text or "how's it going" in text or "what's going on" in text:
                self.__personal_status()
                return
            if "weather" in text:
                if "today" in text:
                    self.__weather_action("today")
                elif "tomorrow" in text:
                    self.__weather_action("tomorrow")
                else:
                    self.__weather_action("today")
                return
            if "time" in text:
                if "date" in text:
                    self.__time_action(withDate=True)
                    return
                else:
                    self.__time_action(withDate=False)
                    return
            if "date" in text and "time" not in text:
                self.__date_action()
                return
            if "play" in text and "music" in text:
                if "some" in text:
                    self.__play_spotify_action()
                return
            if "goodbye" in text or "thank you" in text or "that's all" in text or "that is all" in text or "that's it" in text or "thanks" in text:
                self.__done_action()
                return
            if text == "":
                return
            if acknowledgement == True:
                return
            self.__unknown_command_action(text)

    def __text_action(self, text=None):
        if text is not None:
            requests.get("http://localhost:8080/statement?text=%s" % text)
            self.speech.synthesize_text(text)

    def __acknowledge_action(self):
        self.__text_action(self.nlg.acknowledge())

    def __greet_action(self):
        self.__text_action(self.nlg.greet())

    def __personal_status(self):
        self.__text_action(self.nlg.personal_status())

    def __weather_action(self, tod):
        if tod is not None:
            weathertext = self.actions.getWeather(tod)
            if weathertext is not None:
                city = weathertext['city'].encode('ascii', 'ignore')
                date = weathertext['date']
                condition = weathertext['condition'].encode('ascii', 'ignore')
                low = weathertext['low'].encode('ascii', 'ignore')
                high = weathertext['high'].encode('ascii', 'ignore')
                response = "The weather in " + city + " " + date + " is going to be " + condition + " with temperatures ranging from " + str(
                    low) + " to " + str(high) + " degrees"
                self.__text_action(response)
            else:
                response = "Sorry, I couldn't gather weather text for some reason"
                self.__text_action(response)

    def __time_action(self, withDate=False):
        if withDate:
            time = self.actions.getTime()
            date = self.actions.getDate()
            response = "It is " + str(time) + " on " + str(date)
            self.__text_action(response)
        else:
            time = self.actions.getTime()
            response = "It is " + str(time)
            self.__text_action(response)

    def __date_action(self):
        date = self.actions.getDate()
        response = "It is " + str(date)
        self.__text_action(response)

    def __done_action(self):
        self.speech.debugger_microphone(enable=False)
        self.__text_action("Have a great day")
        self.awake = False

    def __unknown_command_action(self, text):
        self.__text_action("Command unknown. Save command?")
        commandToSave = text
        recognizer, audio = self.speech.listen_for_audio(self.awake)
        text = self.speech.google_speech_recognition(recognizer, audio)
        if text is not None:
            if "yes" in text:
                self.__text_action("Ok, what is its action?")
                recognizer, audio = self.speech.listen_for_audio(self.awake)
                actionToSave = self.speech.google_speech_recognition(
                    recognizer, audio)
                if actionToSave is not None:
                    with open('unknown_commands.csv', 'a') as csvfile:
                        writer = csv.DictWriter(
                            csvfile, fieldnames=self.unknown_fieldnames)
                        writer.writerow({
                            'Command': commandToSave,
                            'Action': actionToSave
                        })
                    self.__text_action("Command recorded.")

    def __hide_action(self, widget):
        if (widget == "all"):
            requests.get("http://localhost:8080/hide?widget=%s" % "time")
            requests.get("http://localhost:8080/hide?widget=%s" % "weather")
            requests.get("http://localhost:8080/hide?widget=%s" % "calendar")
            requests.get("http://localhost:8080/hide?widget=%s" % "commute")
        else:
            requests.get("http://localhost:8080/hide?widget=%s" % widget)
        self.__text_action(self.nlg.confirmation())

    def __show_action(self, widget):
        if (widget == "all"):
            requests.get("http://localhost:8080/show?widget=%s" % "time")
            requests.get("http://localhost:8080/show?widget=%s" % "weather")
            requests.get("http://localhost:8080/show?widget=%s" % "calendar")
            requests.get("http://localhost:8080/show?widget=%s" % "commute")
        else:
            requests.get("http://localhost:8080/show?widget=%s" % widget)
        self.__text_action(self.nlg.confirmation())

    def __play_spotify_action(self):
        self.__text_action("Here you go")
        self.actions.playRandomSpotify()
        self.__done_action()
Example #7
0
class Bot(object):
    def __init__(self):
        self.nlg = NLG(user_name=my_name)
        self.speech = Speech(
            debugger_enabled=debugger_enabled
        )  #(launch_phrase=launch_phrase, debugger_enabled=debugger_enabled)
        #self.knowledge = Knowledge(weather_api_token)
        #self.vision = Vision(camera=camera)

    def start(self):
        """
        Main loop. Waits for the launch phrase, then decides an action.
        :return:
        """
        while True:
            #requests.get("http://localhost:8080/clear")
            #if self.vision.recognize_face():
            #print ("Found face")
            if use_launch_phrase:
                recognizer, audio = self.speech.listen_for_audio()
                if self.speech.is_call_to_action(recognizer, audio):
                    self.__acknowledge_action()
                    self.decide_action()
            else:
                self.decide_action()

    def decide_action(self):
        """
        Recursively decides an action based on the intent.
        :return:
        """
        recognizer, audio = self.speech.listen_for_audio()

        # received audio data, now we'll recognize it using Google Speech Recognition
        speech = self.speech.google_speech_recognition(recognizer, audio)

        if speech is not None:
            try:
                r = requests.get('https://api.wit.ai/message?v=20160918&q=%s' %
                                 speech,
                                 headers={"Authorization": wit_ai_token})
                print(r.text)
                json_resp = json.loads(r.text)
                entities = None
                intent = None
                if 'entities' in json_resp and 'Intent' in json_resp[
                        'entities']:
                    entities = json_resp['entities']
                    intent = json_resp['entities']['Intent'][0]["value"]

                print(intent)
                if intent == 'greeting':
                    self.__text_action(self.nlg.greet())
                elif intent == 'joke':
                    self.__joke_action()
                elif intent == 'insult':
                    self.__insult_action()
                    return
                elif intent == 'appreciation':
                    self.__appreciation_action()
                    return

                elif intent == 'hello':  #hello to AI
                    self.__hello_action()

                elif intent == 'shut down':  #hello to AI
                    self.__shutdown_action()

                elif intent == 'music':  #Playing Music
                    self.__music_action()

                elif intent == 'stop playing':  #Stop playing music
                    self.__stop_playing_action()

                elif intent == 'fan':  #Start fan
                    self.__fan_on_action()
                elif intent == 'fan off':  #Stop fan
                    self.__fan_off_action()

                elif intent == 'dim off':  #Stop dimmer
                    self.__dim_off_action()

                elif intent == 'dim low':  #dimmer 25
                    self.__dim_low_action()

                elif intent == 'dim high':  #dimmer 75
                    self.__dim_high_action()

                elif intent == 'dim full':  #dimmer 100
                    self.__dim_full_action()

                elif intent == 'lights':  #Switch on lights
                    self.__lights_on_action()

                elif intent == 'lights off':  #Switch off Lights
                    self.__lights_off_action()

                elif intent == 'good morning':  #Good morning routine
                    self.__good_morning_action()

                elif intent == 'good night':  #Good night routine
                    self.__good_night_action()

                elif intent == 'goodbye':  #Goodbye routine
                    self.__goodbye_action()

                elif intent == 'I am home':  #i am home to AI
                    self.__iamhome_action()

                elif intent == 'study time':  #study time to AI
                    self.__study_action()

                elif intent == 'charge my phone':  #charge my phone to AI
                    self.__phonecharge_action()

                elif intent == 'charge my laptop':  #charge my laptop to AI
                    self.__laptopcharge_action()

                else:  # No recognized intent
                    #self.__text_action("I'm sorry, I don't know about that yet.")
                    return

            except Exception as e:
                print("Failed wit!")
                print(e)
                traceback.print_exc()
                self.__text_action(
                    "I'm sorry, I couldn't understand what you meant by that")
                return

            self.decide_action()

    def __joke_action(self):
        joke = self.nlg.joke()

        if joke is not None:
            self.__text_action(joke)
        else:
            self.__text_action("I couldn't find any jokes")

    def __appreciation_action(self):
        self.__text_action(self.nlg.appreciation())

    def __insult_action(self):
        self.__text_action(self.nlg.insult())

    def __text_action(self, text=None):
        if text is not None:
            requests.get("http://localhost:8080/statement?text=%s" % text)
            self.speech.synthesize_text(text)

    def __hello_action(self):
        print("Hello! I am kore!!!!!")
        GPIO.output(fan_gpio, GPIO.LOW)
        GPIO.output(light_gpio, GPIO.LOW)
        GPIO.output(lamp_gpio, GPIO.LOW)
        GPIO.output(charger_gpio, GPIO.LOW)
        GPIO.output(toaster_gpio, GPIO.LOW)
        GPIO.output(f, GPIO.LOW)
        GPIO.output(g, GPIO.LOW)
        GPIO.output(laptop_charger_gpio, GPIO.LOW)

    def __shutdown_action(self):
        print("everything down!")
        GPIO.output(fan_gpio, GPIO.HIGH)
        GPIO.output(light_gpio, GPIO.HIGH)
        GPIO.output(lamp_gpio, GPIO.HIGH)
        GPIO.output(charger_gpio, GPIO.HIGH)
        GPIO.output(toaster_gpio, GPIO.HIGH)
        GPIO.output(f, GPIO.HIGH)
        GPIO.output(g, GPIO.HIGH)
        GPIO.output(laptop_charger_gpio, GPIO.HIGH)

    #FAN
    def __fan_on_action(self):
        print("Fan is on!")
        GPIO.output(fan_gpio, GPIO.LOW)

    def __fan_off_action(self):
        print("Fan is off!")
        GPIO.output(fan_gpio, GPIO.HIGH)

    #Lights
    def __lights_on_action(self):
        print("Lights on!")
        GPIO.output(light_gpio, GPIO.LOW)

    def __lights_off_action(self):
        print("Lights off!")
        GPIO.output(light_gpio, GPIO.HIGH)

    #Dimmer
    def __dim_off_action(self):
        print("Dimmer off!")

    def __dim_low_action(self):
        print("Dimmer at 25!")

    def __dim_high_action(self):
        print("Dimmer at 75!")

    def __dim_full_action(self):
        print("Dimmer full!")

    #Good morning
    def __good_morning_action(self):
        print("Good morning!")
        GPIO.output(fan_gpio, GPIO.LOW)  #Fan On
        GPIO.output(toaster_gpio, GPIO.LOW)  #Toaster On
        GPIO.output(light_gpio, GPIO.HIGH)  #lights off
        #dimmer to zero

    #Good night
    def __good_night_action(self):
        print("Good night!")
        GPIO.output(fan_gpio, GPIO.LOW)  #Fan On
        GPIO.output(light_gpio, GPIO.HIGH)  #everything off
        GPIO.output(lamp_gpio, GPIO.HIGH)
        GPIO.output(charger_gpio, GPIO.HIGH)
        GPIO.output(toaster_gpio, GPIO.HIGH)
        GPIO.output(f, GPIO.LOW)  #dimmer on to 5%
        GPIO.output(g, GPIO.HIGH)
        GPIO.output(laptop_charger_gpio, GPIO.HIGH)

    #Goodbye
    def __goodbye_action(self):
        print("Good bye!")
        GPIO.output(fan_gpio, GPIO.HIGH)  #everything off
        GPIO.output(light_gpio, GPIO.HIGH)
        GPIO.output(lamp_gpio, GPIO.HIGH)
        GPIO.output(charger_gpio, GPIO.HIGH)
        GPIO.output(toaster_gpio, GPIO.HIGH)
        GPIO.output(f, GPIO.HIGH)
        GPIO.output(g, GPIO.HIGH)
        GPIO.output(laptop_charger_gpio, GPIO.HIGH)

    #Studytime
    def __study_action(self):
        print("Good morning!")
        GPIO.output(lamp_gpio, GPIO.LOW)  #lamp on
        GPIO.output(fan_gpio, GPIO.LOW)  #Fan on
        #Dimmer Low
        GPIO.output(laptop_charger_gpio, GPIO.LOW)  #laptop charger on
        pygame.mixer.init()
        pygame.mixer.music.load(
            "thunder.mp3")  #change file to some other good mp3
        pygame.mixer.music.play()  #play soothing music to help concentration

    #I'm home
    def __iamhome_action(self):
        print("Welcome home!")
        GPIO.output(fan_gpio, GPIO.LOW)  #fan on
        GPIO.output(light_gpio, GPIO.LOW)  #lights on
        GPIO.output(f, GPIO.LOW)  #Turn Dimmer on
        GPIO.output(g, GPIO.LOW)
        pygame.mixer.init()
        pygame.mixer.music.load(
            "thunder.mp3")  #change file to some highway to hell  mp3
        pygame.mixer.music.play()  #play welcome music

    #Charge my phone
    def __phonecharge_action(self):
        print("Charging your Phone!")
        GPIO.output(charger_gpio, GPIO.LOW)

    #Charge my laptop
    def __laptopcharge_action(self):
        print("Charging your Phone!")
        GPIO.output(laptop_charger_gpio, GPIO.LOW)

    def __music_action(self):
        text = "playing your morning playlist"
        musicicon = "fa fa-play"
        name = "Thunder, by Imagine Dragons"
        text_obj = {"text_content": text, "musicicon": musicicon, "name": name}

        #self.speech.synthesize_text(text)
        #music
        pygame.mixer.init()
        pygame.mixer.music.load("thunder.mp3")
        pygame.mixer.music.play()

    def __stop_playing_action(self):
        pygame.mixer.music.stop()