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()
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]
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
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)
class Bot(object):
def __init__(self):
self.nlg = NLG(user_name=my_name)
self.nlg_vn = NLG(user_name=my_name_vn, language='vi')
self.speech = Speech(launch_phrase=launch_phrase,
debugger_enabled=debugger_enabled)
self.wit_client_vn = Wit(wit_ai_token_vn)
self.wit_client_en = Wit(wit_ai_token)
self.knowledge = Knowledge(weather_api_token,
google_cloud_api_key=google_cloud_api_key)
#self.vision = Vision(camera=camera)
self.bot_vn = 'ty'
subprocess.Popen([
"aplay", "/home/pi/AI-Smart-Mirror/sample-audio-files/Startup.wav"
],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
time.sleep(4)
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 start(self):
"""
Main loop. Waits for the launch phrase, then decides an action.
:return:
"""
self.__setup()
while True:
# requests.get("http://localhost:8080/clear")
if True:
# if True:
print('Found face')
if use_launch_phrase:
recognizer, audio = self.speech.listen_for_audio(
) # save file audio
vn_bot = self.speech.is_call_to_action(recognizer,
audio,
language='vi')
self.bot_vn = vn_bot
en_bot = None
if not (vn_bot in ['ty', 'be', 'xuka']):
# vn_bot = self.speech_vn.is_call_to_action(recognizer, audio, language='vi')
en_bot = self.speech.is_call_to_action(
recognizer, audio) # check vn or en bot
if en_bot is not None or vn_bot is not None:
GPIO.output(LEDPIN, GPIO.HIGH) # light on
# 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")
if vn_bot in ['ty', 'be', 'xuka']:
self.__acknowledge_action(langague='vi') #
self.decide_action(langague='vi')
else:
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(langague='vi')
# Wait for all threads to complete
def decide_action(self, langague=None, oldintent=None, pre_message=None):
"""
Recursively decides an action based on the intent.
:return:
"""
speech_en = None
speech_vn = None
# received audio data, now we'll recognize it using Google Speech Recognition
if langague is not None:
while speech_vn is None:
recognizer, audio = self.speech.listen_for_audio()
speech_vn = self.speech.google_speech_recognition(
recognizer, audio, langague)
if oldintent is not None:
speech_vn = '%s %s' % (oldintent, speech_vn)
else:
while speech_en is None:
recognizer, audio = self.speech.listen_for_audio()
speech_en = self.speech.google_speech_recognition(
recognizer, audio)
# Run EN Bot
if speech_en is not None:
try:
# r = requests.get('https://api.wit.ai/message?v=20180428&q=%s' % speech_en,
# headers={"Authorization": wit_ai_token})
response = self.wit_client_en.message(speech_en)
entities = None
intent = None
if response is not None:
entities = response['entities']
intent = 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.__text_action('News function is not yet implemted')
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 == '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()
else:
# Run VN Bot
if speech_vn is not None:
try:
# r = requests.get('https://api.wit.ai/message?v=20180428&q=%s' % speech_vn,
# headers={"Authorization": wit_ai_token_vn})
# resp = json.loads(r.text)
response = self.wit_client_vn.message(speech_vn)
entities = None
intent = None
print(response)
if response is not None:
entities = response['entities']
if 'intent' in entities:
intent = entities['intent'][0]["value"]
print(intent)
if intent == 'lời chào':
self.__text_action(self.nlg_vn.greet())
elif intent == 'thời tiết':
self.__weather_action_vn(entities)
elif intent == 'tin tức':
self.__news_action(entities, langague, oldintent)
if pre_message is not None:
if speech_vn is not None and 'dịch' in speech_vn:
self.__text_action(pre_message)
return
if oldintent is not None:
self.__text_action('Kết thúc đọc tin tức')
return
elif intent == 'bản đồ':
self.__maps_action(entities)
elif intent == 'ngày nghỉ':
self.__holidays_action(entities)
elif intent == 'điều khiển':
self.__device_action(entities)
# elif intent == 'self':
# self.__appearance_action()
elif intent == 'alarm':
self.__alarm(entities)
return
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 == 'đánh giá':
self.__appreciation_action()
return
elif intent == 'nhạc':
self.__playmusic(entities)
return
elif intent == 'light':
self.__light_action(entities)
return
elif intent == 'current time':
ti = datetime.datetime.now().time()
self.__text_action(ti)
else: # No recognized intent
self.__text_action(self.nlg_vn.unknown())
# return
except Exception as e:
print("Failed wit!")
print(e)
traceback.print_exc()
self.__text_action(
"Code thối lỗi banh xác rồi, fix đêêêêê")
return
self.decide_action(langague='vi')
def __device_action(self, nlu_entities=None):
action = None
position = None
device = None
mode = None
if nlu_entities is not None:
if 'action' in nlu_entities:
action = nlu_entities['action'][0]['value'].lower().encode()
if 'position' in nlu_entities:
position = nlu_entities['position'][0]['value'].lower().encode(
)
if 'device' in nlu_entities:
device = nlu_entities['device'][0]['value'].lower().encode()
if 'mode' in nlu_entities:
mode = nlu_entities['mode'][0]['value'].lower().encode()
if device is not None and action is not None:
if device == 'loa'.encode():
if action == 'bật'.encode() or action == 'tắt'.encode():
os.system('irsend SEND_ONCE speaker KEY_POWER')
elif action == 'tăng'.encode() or action == 'lớn'.encode():
os.system('irsend SEND_ONCE speaker KEY_VOLUMEUP')
elif action == 'giảm'.encode() or action == 'nhỏ'.encode():
os.system('irsend SEND_ONCE speaker KEY_VOLUMEDOWN')
elif action == 'ánh sáng'.encode():
os.system('irsend SEND_ONCE speaker KEY_LIGHTS_TOGGLE')
elif device == 'điều hòa'.encode():
print('%s, %s, %s' % (device, mode, action))
if action == 'bật'.encode() or action == 'chuyển'.encode():
if mode is not None and mode == 'lạnh'.encode():
os.system('irsend SEND_ONCE air COLD') # lanh
self.__text_action('đã bật điều hoà, chế độ lạnh')
elif mode is not None and mode == 'nóng'.encode():
os.system('irsend SEND_ONCE air HOT') # nong
self.__text_action('đã bật điều hoà, chế độ nóng')
elif action == 'tắt'.encode():
os.system('irsend SEND_ONCE air OFF') # tắt
self.__text_action('đã tắt điều hoà')
elif action == 'giảm'.encode():
os.system('irsend SEND_ONCE air DOWN') # DOWN
self.__text_action('đã giảm điều hoà')
elif action == 'tăng'.encode():
os.system('irsend SEND_ONCE air UP') # UP
self.__text_action('đã tăng điều hoà')
elif device == 'quạt'.encode():
if action == 'bật'.encode() or action == 'chuyển'.encode():
if mode is not None and mode == 'lạnh'.encode():
os.system(
'irsend SEND_ONCE fan KEY_POWER KEY_BLUE KEY_BLUE'
) # lanh
self.__text_action('đã bật quạt chế độ lạnh')
elif mode is not None and mode == 'nóng':
os.system(
'irsend SEND_ONCE fan KEY_POWER KEY_0 KEY_0'
) # nong
self.__text_action('đã bật quạt chế độ nóng')
else:
os.system(
'irsend SEND_ONCE fan KEY_POWER KEY_BLUE KEY_BLUE'
) # lanh
self.__text_action('đã bật quạt chế độ nóng')
elif action == 'tắt'.encode():
os.system(
'irsend SEND_ONCE fan KEY_POWER KEY_POWER') # tắt
self.__text_action('đã tắt quạt')
elif action == 'giảm'.encode():
if mode is not None and mode == 'lạnh'.encode():
os.system('irsend SEND_ONCE fan KEY_DOWN KEY_DOWN'
) # giam
self.__text_action('đã giảm quạt chế độ lạnh')
elif mode is not None and mode == 'nóng'.encode():
os.system(
'irsend SEND_ONCE fan KEY_1 KEY_1') # giam
self.__text_action('đã giảm quạt chế độ nóng')
elif action == 'tăng'.encode():
if mode is not None and mode == 'lạnh'.encode():
os.system(
'irsend SEND_ONCE fan KEY_UP KEY_UP') # tăng
self.__text_action('đã tăng quạt chế độ lạnh')
elif mode is not None and mode == 'nóng'.encode():
os.system(
'irsend SEND_ONCE fan KEY_0 KEY_0') # giam
self.__text_action('đã tăng quạt chế độ nóng')
elif action == 'xoay'.encode():
os.system('irsend SEND_ONCE fan KEY_RO KEY_RO') # xoay
self.__text_action('đã xoay quạt')
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):
if self.bot_vn in ['ty', 'be', 'xuka']:
self.__text_action(self.nlg_vn.appreciation())
else:
self.__text_action(self.nlg.appreciation())
def __acknowledge_action(self, langague=None):
if self.bot_vn in ['ty', 'be', 'xuka']:
self.__text_action(self.nlg_vn.acknowledge())
else:
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)
if self.bot_vn in ['ty', 'be', 'xuka']:
say(text, 'vi', self.bot_vn)
else:
say(text)
# Voi viet nam thoi
def __news_action(self, nlu_entities=None, language='vi', oldintent=None):
country = None
intent = None
action = None
if nlu_entities is not None:
# get entites from API
if 'country' in nlu_entities:
country = nlu_entities['country'][0]['value']
if 'intent' in nlu_entities:
intent = nlu_entities['intent'][0]['value']
# doc tin tuc cua nc nao
if country is not None and 'việt' in country.lower():
self.__text_action('tin việt nam ạ, chờ em tý!')
# todo:get_vnex_news
news_vn = self.knowledge.get_news('vi')
if news_vn:
# requests.post("http://localhost:8080/news", data=json.dumps({"articles":headlines}))
interest = self.nlg.article_interest(news_vn)
if interest is not None:
self.__text_action(interest)
elif country is not None and 'nhật bản' in country.lower():
self.__text_action(
'tin nhật bản ạ, chờ tý em bảo chị gu gồ đọc cho %s nghe' %
my_name_vn)
news_jp = self.knowledge.get_news('jp')
if news_jp:
# requests.post("http://localhost:8080/news", data=json.dumps({"articles":headlines}))
interest = self.nlg.article_interest(news_jp)
if interest is not None:
say(interest, 'ja')
self.decide_action(langague=language,
oldintent=intent,
pre_message=interest)
else:
self.__text_action('không tìm thấy tin nào hết, %s ạ' %
my_name_vn)
elif oldintent is None:
self.__text_action(
'Anh muốn nghe tin gì, nước nào nhật bản hay việt nam hả %s ?'
% my_name_vn)
self.decide_action(langague=language, oldintent=intent)
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(my_address)
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['hourly_forecast'],
'location': my_address
}
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'],
'location': my_address
}
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'],
'location': my_address
}
forecast_speech = self.nlg.forecast(forecast_obj)
elif weather_type == 'today':
forecast_obj = {
'forecast_type': 'hourly',
'forecast': weather_obj['hourly_forecast'],
'location': my_address
}
forecast_speech = self.nlg.forecast(forecast_obj)
elif weather_type == 'tomorrow':
forecast_obj = {
'forecast_type': 'daily',
'forecast': weather_obj['tomorrow_forecast'],
'location': my_address
}
forecast_speech = self.nlg.forecast(forecast_obj)
skip_weather = True
elif weather_type == '3 day' or weather_type == '7 day':
forecast_obj = {
'forecast_type': 'daily',
'forecast': weather_obj['weekly_forecast'],
'location': my_address
}
forecast_speech = self.nlg.forecast(forecast_obj)
skip_weather = True
else:
forecast_obj = {
'forecast_type': 'hourly',
'forecast': weather_obj['hourly_forecast'],
'location': my_address
}
forecast_speech = self.nlg.forecast(forecast_obj)
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 __weather_action_vn(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(my_address)
temperature = weather_obj['temperature']
icon = weather_obj['icon']
wind_speed = weather_obj['windSpeed']
weather_speech = self.nlg_vn.weather(temperature, current_dtime,
"present")
forecast_speech = None
if nlu_entities is not None:
if 'timely' in nlu_entities:
timely = nlu_entities['timely'][0]['value']
print(timely)
if timely == 'hôm nay':
forecast_obj = {
'forecast_type': 'hourly',
'forecast': weather_obj['hourly_forecast'],
'location': my_address
}
forecast_speech = self.nlg_vn.forecast(forecast_obj)
elif timely == 'bây giờ':
forecast_obj = {
'forecast_type': 'current',
'forecast': weather_obj['current_forecast'],
'location': my_address
}
forecast_speech = self.nlg_vn.forecast(forecast_obj)
elif timely == 'ngày mai':
forecast_obj = {
'forecast_type': 'daily',
'forecast': weather_obj['tomorrow_forecast'],
'location': my_address
}
forecast_speech = self.nlg_vn.forecast(forecast_obj)
skip_weather = True
elif 'tuần' in timely or timely == 'cuối tuần':
forecast_obj = {
'forecast_type': 'daily',
'forecast': weather_obj['weekly_forecast'],
'location': my_address
}
forecast_speech = self.nlg_vn.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, 'vi', self.bot_vn)
if forecast_speech is not None:
# self.speech.synthesize_text(forecast_speech)
say(forecast_speech, 'vi', self.bot_vn)
def __maps_action(self, nlu_entities=None):
location = None
map_type = None
origin = None
destination = None
maps_url = None
if self.bot_vn in ['ty', 'be', 'xuka']:
if nlu_entities is not None:
if 'city' in nlu_entities:
location = nlu_entities['city'][0]["value"]
if 'country' in nlu_entities:
country = nlu_entities['country'][0]["value"]
if 'from' in nlu_entities:
origin = nlu_entities['from'][0]["value"]
if 'to' in nlu_entities:
destination = nlu_entities['to'][0]["value"]
if origin is not None and destination is not None:
maps_url = self.knowledge.get_direction_map(
origin, destination)
location = 'đường đi'
else:
if location is not None:
maps_url = self.knowledge.get_map_url(location, map_type)
else:
self.__text_action(
"Em xin lỗi, em không biết nơi anh muốn tìm")
if maps_url is not None:
maps_action = "chắc chắn rồi, đây là bản đồ %s." % location
body = {'url': maps_url}
# requests.post("http://localhost:8080/image", data=json.dumps(body))
say(maps_action, 'vi', self.bot_vn)
else:
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 __playmusic(self, nlu_entities=None):
chanel = 'youtube'
action = None
region_code = 'VN'
location = None
search_query = None
if self.bot_vn in ['ty', 'be', 'xuka']: # vn bot
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 'search_query' in nlu_entities:
search_query = nlu_entities['search_query'][0]['value']
# Play music
if chanel is not None:
if 'youtube' == chanel:
if 'mở' == action:
stop()
if search_query is not None and search_query != 'nghe':
YouTube_Autoplay(search_query, region_code)
else:
YouTube_Autoplay('Le quyen', region_code)
elif 'tắt' == action:
stop()
self.__text_action("ok, em tắt rồi")
else:
self.__text_action("em chưa hiểu, thưa %s" %
my_name)
else: # en bot
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, nlu_entities=None):
country = None
if nlu_entities is not None:
if 'country' in nlu_entities:
country = nlu_entities['country'][0]["value"]
print(nlu_entities['country'][0]["value"])
if country is not None:
holidays = self.knowledge.get_holidays(country)
else:
holidays = self.knowledge.get_holidays(country='vi')
if not holidays:
self.__text_action("No upcoming events found.")
else:
i = 0
words = ''
while i < 3:
dayho = dateutil.parser.parse(holidays[i]['start'])
print(dayho.weekday())
dayofweek = self.__dayofweek(dayho.weekday())
words = "%s . %s Ngày %s, tháng %s, năm %s, %s" % (
words, dayofweek, dayho.day, dayho.month, dayho.year,
holidays[i]['summary'])
i = i + 1
self.__text_action(words)
def __dayofweek(self, i):
days = [
'Thứ hai', 'Thứ ba', 'Thứ tư', 'Thứ năm', 'Thứ sáu', 'Thứ bảy',
'Chủ nhật'
]
return days[i]
def __alarm(self, nlu_entities=None):
__datetime = None
__action = None
current_ts = time.time()
if nlu_entities is not None:
if 'datetime' in nlu_entities:
__datetime = nlu_entities['datetime'][0]['value']
if __datetime is not None:
dtime = dateutil.parser.parse(__datetime)
str = '%s giờ, %s, Ngày %s, Tháng %s' % (dtime.hour, dtime.minute,
dtime.day, dtime.month)
timestamp2 = time.mktime(dtime.timetuple())
delay = timestamp2 - current_ts
if delay > 0:
_thread.start_new_thread(self.__start_alarm, (
"alarm",
delay,
))
say('đã cài báo thức %s', str)
# 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
# registe alarm
def __start_alarm(self, threadName, delay):
time.sleep(delay)
alarm_file = "/home/pi/AI-Smart-Mirror/sample-audio-files/martian-gun.mp3"
song = AudioSegment.from_mp3(alarm_file)
i = 0
while i <= 30:
play(song)
time.sleep(2)
i += 1