def get_time_slept_intent(request):
cur_date = get_cur_date() - timedelta(days=1)
bedtime = get_value_on_date(cur_date, ATTR_MAP["bedtime"])
waketime = get_value_on_date(cur_date, ATTR_MAP["waketime"])
latency = get_value_on_date(cur_date, ATTR_MAP["latency"])
if not bedtime:
return alexa.create_response("Sorry, looks like you didn't set a bedtime yesterday.")
if not waketime:
return alexa.create_response("Sorry, looks like you didn't wake up yesterday.")
if not latency:
latency = timedelta() # In case we didn't record latency
else:
h, m, s = map(int, latency.split(":"))
latency = timedelta(hours=h, minutes=m)
#If bedtime is before midnight, subtract an extra day
if bedtime[-2:] == "PM":
bedtime = create_datetime_from_time(bedtime, cur_date - timedelta(days=1))
else:
bedtime = create_datetime_from_time(bedtime, cur_date)
bedtime += latency
waketime = create_datetime_from_time(waketime, cur_date)
duration = waketime - bedtime
hours = int(duration.total_seconds() / 3600)
minutes = int((duration.total_seconds() % 3600)/60)
response_str = "You slept {} hours and {} minutes last night, Michael.".format(hours, minutes)
return alexa.create_response(response_str, end_session=True)
def launch_ReOrder_handler(request):
oid = int(request.slots["orderid"])
global ORDER
name = ORDER['name']
orderHandler = OrderHandler()
orders = orderHandler.getPersonOrder(name)
if oid in orders:
temp = oid + 1
sheet = '!C' + str(temp) + ':Z'
get_order = orderHandler.getOrderNumbers(sheet)[0]
# ORDER = OrderedDict()
ORDER['name'] = name
ORDER['type'] = get_order[1]
ORDER['size'] = get_order[3]
ORDER['crust'] = get_order[5]
ORDER['sauce'] = get_order[7]
ORDER['bake'] = get_order[9]
ORDER['cut'] = get_order[11]
ORDER['seasoning'] = get_order[13]
ORDER['toppings'] = [
get_order[15], get_order[17], get_order[19], get_order[21],
get_order[23]
]
ORDER['no_of_pizza'] = get_order[0]
reply, card = checkIsReady()
return alexa.create_response(message=reply,
end_session=False,
card_obj=card)
else:
return alexa.create_response(
message=
'I am sorry i dont find that order in your name. Please try again.'
)
def set_bill_reminder_intent_handler(request):
payee = request.get_slot_value("payee")
payee_str = str(payee)
payment_amount = request.get_slot_value("payment_amount")
payment_str = str(payment_amount)
payment_double = (int(payment_str) / 1.0)
headers = {'Content-Type': 'application/json'}
url = 'http://api.reimaginebanking.com/accounts/5925e4eca73e4942cdafd61d/bills?key=61892e8b6b69dca102737332a828661c'
req = urllib2.Request(
url,
data=
'{"status": "recurring", "payee": "%s", "payment_date": "2017-05-25", "payment_amount": %d, "recurring_date": 1}'
% (payee_str, payment_double),
headers=headers)
resp = urllib2.urlopen(req)
code = json.load(resp)['code']
if code == 201:
success_str = "A bill has been created for " + payee_str + " in the amount of " + payment_str + " dollars."
return alexa.create_response(message=success_str, end_session=True)
return alexa.create_response(
message="An Error Occurred. The Bill was not created. Try again.",
end_session=True)
def get_temp_response(temperature_type,
success_response,
fail_response,
min_date=None,
max_date=None,
aggregate_type=None):
params = {}
if min_date:
params['min_date'] = min_date
if max_date:
params['max_date'] = max_date
if aggregate_type:
params['aggregate_type'] = aggregate_type
try:
endpoint = '/temperature/%s' % temperature_type
response = poolmon.request(endpoint, params=params)
temp = int(
round(response['measurements'][0]['temperature']
[preferred_temp_type]))
message = success_response % {'temp': temp}
return alexa.create_response(message=message, end_session=True)
except IndexError:
return alexa.create_response(message=fail_response, end_session=True)
def get_recipe_intent_handler(request):
"""
You can insert arbitrary business logic code here
"""
# Get variables like userId, slots, intent name etc from the 'Request' object
ingredient = request.slots["Ingredient"] # Gets an Ingredient Slot from the Request object.
if ingredient == None:
return alexa.create_response("Could not find an ingredient!")
# All manipulations to the request's session object are automatically reflected in the request returned to Amazon.
# For e.g. This statement adds a new session attribute (automatically returned with the response) storing the
# Last seen ingredient value in the 'last_ingredient' key.
request.session['last_ingredient'] = ingredient # Automatically returned as a sessionAttribute
# Modifying state like this saves us from explicitly having to return Session objects after every response
# alexa can also build cards which can be sent as part of the response
card = alexa.create_card(title="GetRecipeIntent activated", subtitle=None,
content="asked alexa to find a recipe using {}".format(ingredient))
return alexa.create_response("Finding a recipe with the ingredient {}".format(ingredient),
end_session=False, card_obj=card)
def get_time_intent_handler(request):
request_text = request.request['request']['intent']['slots']['value'][
'value']
phrases_array = [
"what time is it", "what time it is", "what time it is in binary",
"what time is it in binary"
]
if request_text in phrases_array:
binary_arrays = get_binary_arrays(str(datetime.utcnow().time()))
binary_time_array = []
for array in binary_arrays:
binary_time_array.append(binary_to_words(array))
return alexa.create_response(
message="The current time in binary is " + binary_time_array[0] +
" hours, and " + binary_time_array[1] + " minutes, and " +
binary_time_array[2] + " seconds, Coordinated Universal Time",
end_session=True)
else:
return alexa.create_response(
message="I didn't understand that. Ask me what time it is ",
end_session=False,
reprompt_message="Ask me what time it is")
def get_recipe_intent_handler(request):
"""
You can insert arbitrary business logic code here
"""
# Get variables like userId, slots, intent name etc from the 'Request' object
ingredient = request.slots[
"Ingredient"] # Gets an Ingredient Slot from the Request object.
if ingredient == None:
return alexa.create_response("Could not find an ingredient!")
# All manipulations to the request's session object are automatically reflected in the request returned to Amazon.
# For e.g. This statement adds a new session attribute (automatically returned with the response) storing the
# Last seen ingredient value in the 'last_ingredient' key.
request.session[
'last_ingredient'] = ingredient # Automatically returned as a sessionAttribute
# Modifying state like this saves us from explicitly having to return Session objects after every response
# alexa can also build cards which can be sent as part of the response
card = alexa.create_card(
title="GetRecipeIntent activated",
subtitle=None,
content="asked alexa to find a recipe using {}".format(ingredient))
return alexa.create_response(
"Finding a recipe with the ingredient {}".format(ingredient),
end_session=False,
card_obj=card)
def reply_focus_handler(request):
msg = "Sorry, I couldn't tell which tweet you wanted to reply to."
index = focused_on_tweet(request)
if index:
return alexa.create_response(
message=
"Do you want to reply to tweet {} ? If so say reply, followed by your message"
.format(index))
return alexa.create_response(message=msg, end_session=False)
def deliver_result(station,result):
if result.error:
card = alexa.create_card(title = "NextTrainIntent error", subtitle=None,
content = result.error)
return alexa.create_response("Sorry. {}".format(result.error), end_session=True, card_obj=card)
else:
card = alexa.create_card(title="NextTrainIntent activated", subtitle=None,
content="asked Alexa for trains to {}".format(station))
speak = format_trips(station, result)
return alexa.create_response(speak, end_session=True, card_obj=card)
def play_day_intent_handler(request):
day = request.get_slot_value("day")
info = oi.getPlayInfoOfDayNum(day, 0)
res, title = play_day_num(day, num)
if res == None:
if title == None:
return alexa.create_response("{0} {1}は無効な番組です".format(
day, num + 1),
end_session=False)
return alexa.create_response("{0}は再生できない番組です".format(title),
end_session=False)
return res
def launch_number_handler(request):
global ORDER
num = int(request.slots["num"])
if num >= 1:
reply = "ordering {} pizzas. ".format(num)
ORDER['no_of_pizza'] = num
r, card = checkIsReady()
reply += r
return alexa.create_response(message=reply, card_obj=card)
else:
reply = "I could not get it, please say the number of pizza you want"
return alexa.create_response(message=reply, end_session=False)
def get_pizza_size_handler(request):
size = request.slots["size"].lower()
global SIZES
if size in SIZES:
reply = "Ok, you pick " + size + " size. "
# save size into order
global ORDER
ORDER['size'] = size
reply += checkIsReady()
return alexa.create_response(message=reply, end_session=False)
else:
reply = "I could not get it. says 'show pizza sizes' to see your options"
return alexa.create_response(message=reply, end_session=False)
def get_cut_type_handler(request):
cut = request.slots["cut"].lower()
global CUTS
if cut in CUTS:
reply = 'OK, ' + cut + ' cut. '
# save type into order
global ORDER
ORDER['cut'] = cut
reply += checkIsReady()
return alexa.create_response(message=reply, end_session=False)
else:
reply = "I could not find it. says 'show pizza cuts' to see your options"
return alexa.create_response(message=reply, end_session=False)
def get_pizza_type_handler(request):
pizza = request.slots["pizza"].lower()
global PIZZAS
if pizza in PIZZAS:
reply = 'OK, order ' + pizza + '. '
# save type into order
global ORDER
ORDER['type'] = pizza
reply += checkIsReady()
return alexa.create_response(message=reply, end_session=False)
else:
reply = "I could not find it. says 'show pizza types' to see your options"
return alexa.create_response(message=reply, end_session=False)
def get_sauce_type_handler(request):
sauce = request.slots["sauce"].lower()
global SAUCES
if sauce in SAUCES:
reply = 'OK, ' + sauce + ' sauce. '
# save type into order
global ORDER
ORDER['sauce'] = sauce
reply += checkIsReady()
return alexa.create_response(message=reply, end_session=False)
else:
reply = "I could not find it. says 'show pizza sauces' to see your options"
return alexa.create_response(message=reply, end_session=False)
def get_pizza_crust_handler(request):
crust = request.slots["crust"].lower()
reply = "your crust will be " + crust + ". "
global CRUSTS
if crust in CRUSTS:
reply = "Ok, pizza crust will be " + crust + ". "
# save crust into order
global ORDER
ORDER['crust'] = crust
reply += checkIsReady()
return alexa.create_response(message=reply, end_session=False)
else:
reply = "I could not find it. says 'show pizza crusts' to see your options"
return alexa.create_response(message=reply, end_session=False)
def command(cmd, ok):
result = AVR().send(cmd)
if result == 'OK':
card = alexa.create_card(title="Marantz", subtitle=None, content=ok)
response = alexa.create_response(ok, end_session=True, card_obj=card)
else:
card = alexa.create_card(title="Marantz",
subtitle="Error",
content=result)
response = alexa.create_response(
"Sorry, the receiver doesn't seem to be cooperating.",
end_session=True,
card_obj=card)
return response
def launch_ChoosePizzaBake_handler(request):
bake = request.slots["bake"].lower()
reply = "you want your pizza to be baked in " + bake + ". "
global BAKES
if bake in BAKES:
reply = "Ok, pizza will be baked in " + bake + ". "
# save bake into order
global ORDER
ORDER['bake'] = bake
reply += checkIsReady()
return alexa.create_response(message=reply, end_session=False)
else:
reply = "I could not find it, if you want me to read menu, say 'show pizza bakes'"
return alexa.create_response(message=reply, end_session=False)
def play_intent_handler(request):
day = request.get_slot_value("day")
num = request.get_slot_value("num")
if num == None:
num = 1
num = int(num) - 1
res, title = play_day_num(day, num)
if res == None:
if title == None:
return alexa.create_response("{0} {1}は無効な番組です".format(
day, num + 1),
end_session=False)
return alexa.create_response("{0}は再生できない番組です".format(title),
end_session=False)
return res
def next_train_intent_handler(request):
# Get variables like userId, slots, intent name etc from the 'Request' object
station = request.slots["Station"]
if station == None:
return alexa.create_response("Please specify a station name.")
result = get_trips(station)
if result.error:
card = alexa.create_card(title = "NextTrainIntent error", subtitle=None,
content = result.error)
return alexa.create_response("Sorry. {}".format(result.error), end_session=True, card_obj=card)
else:
card = alexa.create_card(title="NextTrainIntent activated", subtitle=None,
content="asked Alexa for next trains to {}: {}".format(station, ", ".join(result.trips)))
speak = format_trips(station, result)
return alexa.create_response(speak, end_session=True, card_obj=card)
def launch_IsNotMember_handler(request):
orderHandler = OrderHandler()
global ORDER
ORDER['member'] = {}
reply = "it's fine! You can join later. "
reply += checkIsReady()
return alexa.create_response(message=reply, end_session=False)
def lambda_handler(request, context=None):
metadata = {}
app_id = 'amzn1.echo-sdk-ams.app.a563fd76-b63a-43bd-9d92-9af0bbe27e14'
if not request.session['application']['applicationId'] == app_id:
return alexa.create_response('yeah nice try.')
return alexa.route_request(request, metadata)
def launch_request_handler(request):
#use random module to select a random murder weapon
murder_weapon = random.choice(weapon_list)
#use random module to select a random murder location
murder_location = random.choice(place_of_murdery)
#create a suspected killers list
suspected_killers = []
#interate through the suspect dictionaries and append the 'name' values to the suspected killers list
for suspect in suspects.keys():
suspected_killers.append(suspects[suspect])
#use random module to select a random killer
killer = random.choice(suspected_killers)
killer_name = killer['name']
killer_hair = killer['facial hair']
killer_scarf = killer['scarf']
killer_hat = killer['hat']
killer_freckles = killer['freckles']
killer_pet = killer['pet']
killer_glasses = killer['glasses']
req = alexa.create_response(message="One of you killed with a {0} in the {1}. Your team is allowed two questions and one guess to figure out who the murderer is. Guess correctly and they'll be arrested and tried. Guess wrong and they go free forever. No pressure. So, what is your first question?".format(murder_weapon, murder_location))
def activity_intent_handler(request):
act = request.slots["Activity"].lower()
if act in ("tv", "t.v.", "netflix", "roku", "amazon video"):
name = 'SAT/CBL'
msg = 'OK. Turn on the TV to watch Roku, Netflix, or Amazon Video.'
elif act == 'you tube':
name = 'SAT/CBL'
msg = 'OK. Use the Roku remote to select the You Tube app.'
elif act.find('phone') > -1 or act == 'air play':
name = 'NET'
msg = 'OK. On your I phone, choose the Marantz receiver as the Air Play destination, and play a song.'
elif act.find('dvd') > -1 or act.find('movie') > -1:
name = 'BD'
msg = 'DVD player is ready. What are we watching?'
elif act == 'apple tv' or act == 'apple t.v.' or act.find(
'photos') > -1 or act.find('pictures') > -1:
name = 'MPLAY'
msg = 'OK. Use the small white remote to control Apple TV.'
elif act == 'pandora':
name = 'PANDORA'
msg = 'Pandora streaming will start in the TV room shortly.'
else:
return alexa.create_response(
"Sorry, I don't know how to set up the stereo for the " + act +
" task.",
end_session=True,
card_obj=alexa.create_card(title="Marantz Error", content=act))
response = command(['Z2OFF', 'PWON', 'ZMON', 'SI' + name], msg)
return response
def launch_request_handler(request):
return alexa.create_response(
message=
"Welcome to Code Comments! If you give me the name of a programming language, I will respond with instructions for making a comment in that language! In what language would you like to comment?",
reprompt_message=
"Learning how to comment can be fun! What language would you like to comment out?"
)
def post_tweet_intent_handler(request):
"""
Use the 'intent' field in the VoiceHandler to map to the respective intent.
"""
tweet = request.get_slot_value("Tweet")
tweet = tweet if tweet else ""
if tweet:
user_state = twitter_cache.get_user_state(request.access_token())
def action():
return post_tweet(request.access_token(), tweet)
message = "I am ready to post the tweet, {} ,\n Please say yes to confirm or stop to cancel .".format(
tweet)
user_state['pending_action'] = {
"action": action,
"description": message
}
return r.create_response(message=message, end_session=False)
else:
# No tweet could be disambiguated
message = " ".join([
"I'm sorry, I couldn't understand what you wanted to tweet .",
"Please prepend the message with either post or tweet ."
])
return alexa.create_response(message=message, end_session=False)
def previous_intent_handler(request):
user_queue = twitter_cache.user_queue(request.access_token())
if user_queue and user_queue.has_prev():
message = user_queue.read_out_prev()
else:
message = "I couldn't find anything to repeat"
return alexa.create_response(message=message)
def get_onprem_cost_efficiency_handler(request):
""" Queries the OneSphere metrics API and returns the private cloud cost efficiency.
"""
# Get KMS secured environment variables
api_base = request.metadata.get('api_base', None)
token = request.metadata.get('token', None)
# Get service status
# periodStart should default to the current month
# 'periodStart': '2018-01-01T00:00:00Z',
payload = {'category': 'providers', 'groupBy': 'providerTypeUri',
'name': 'cost.efficiency', 'period': 'month', 'periodCount': '-1', 'view': 'full'
}
r = safe_requests(requests.get, api_base + "/metrics", params=payload,
headers={'accept': 'application/json',
'Authorization': token}
)
# Parse metrics JSON output
metric_data = MetricData(r)
total_spend = metric_data.get_cost()
speech_output = "The OneSphere service private cloud efficiency for this month is ${:,.2f}".format(total_spend)
card = alexa.create_card(title="GetOnpremCostEfficiencyIntent activated", subtitle=None,
content="asked alexa to query the OneSphere metrics REST API and calculate" \
" the total private cloud monthly cost efficiency")
return alexa.create_response(speech_output,end_session=False, card_obj=card)
def get_recipe_intent_handler(request):
"""
You can insert arbitrary business logic code here
"""
# Get variables like userId, slots, intent name etc from the 'Request' object
ingredient = request.slots["Ingredient"]
if ingredient == None:
return alexa.create_response("Could not find an ingredient!")
card = alexa.create_card(title="GetRecipeIntent activated", subtitle=None,
content="asked alexa to find a recipe using {}".format(ingredient))
return alexa.create_response("Finding a recipe with the ingredient {}".format(ingredient),
end_session=False, card_obj=card)
def launch_request_handler(request):
"""
Annoatate functions with @VoiceHandler so that they can be automatically mapped
to request types.
Use the 'request_type' field to map them to non-intent requests
"""
return alexa.create_response(message="Hello Welcome to My Recipes!")
def launch_request_handler(request):
#use random module to select a random murder weapon
murder_weapon = random.choice(weapon_list)
#use random module to select a random murder location
murder_location = random.choice(place_of_murdery)
#create a suspected killers list
suspected_killers = []
#interate through the suspect dictionaries and append the 'name' values to the suspected killers list
for suspect in suspects.keys():
suspected_killers.append(suspects[suspect])
#use random module to select a random killer
killer = random.choice(suspected_killers)
killer_name = killer['name']
killer_hair = killer['facial hair']
killer_scarf = killer['scarf']
killer_hat = killer['hat']
killer_freckles = killer['freckles']
killer_pet = killer['pet']
killer_glasses = killer['glasses']
req = alexa.create_response(
message=
"One of you killed with a {0} in the {1}. Your team is allowed two questions and one guess to figure out who the murderer is. Guess correctly and they'll be arrested and tried. Guess wrong and they go free forever. No pressure. So, what is your first question?"
.format(murder_weapon, murder_location))
def arrive_intent_handler(request):
station = request.slots["Destination"]
arrive_time = request.slots["Time"]
if (station == None or arrive_time == None):
return alexa.create_response("Please try again, giving the destination station and arrival time.")
result = get_trips(station, 'arrive', arrive_time)
return deliver_result(station,result)
def tweet_list_handler(request, tweet_list_builder, msg_prefix=""):
""" This is a generic function to handle any intent that reads out a list of tweets"""
# tweet_list_builder is a function that takes a unique identifier and returns a list of things to say
tweets = tweet_list_builder(request.access_token())
print(len(tweets), 'tweets found')
if tweets:
twitter_cache.initialize_user_queue(user_id=request.access_token(),
queue=tweets)
text_to_read_out = twitter_cache.user_queue(
request.access_token()).read_out_next(MAX_RESPONSE_TWEETS)
message = msg_prefix + text_to_read_out + ", say 'next' to hear more, or reply to a tweet by number."
return alexa.create_response(message=message, end_session=False)
else:
return alexa.create_response(
message="Sorry, no tweets found, please try something else",
end_session=False)
def enqueue_next(day, num):
res = enqueue_day_num(day, num + 1)
if res == None:
if num == 0:
return alexa.create_response(end_session=True)
return enqueue_next(day, 0)
return res
def get_recipe_intent_handler(request):
"""
You can insert arbitrary business logic code here
"""
# Get variables like userId, slots, intent name etc from the 'Request' object
ingredient = request.slots["Ingredient"]
if ingredient == None:
return alexa.create_response("Could not find an ingredient!")
card = alexa.create_card(title="GetRecipeIntent activated", subtitle=None,
content="asked alexa to find a recipe using {}".format(ingredient))
return alexa.create_response("Finding a recipe with the ingredient {}".format(ingredient),
end_session=False, card_obj=card)
def play_next(day, num, endSession=True):
res, title = play_day_num(day, num + 1, endSession)
if res == None:
if title == None:
return alexa.create_response(end_session=True)
return enqueue_next(day, 0, endSession)
return res
def find_trends_handler(request):
uid = request.access_token()
user_cache = twitter_cache.get_user_state(uid)
resolved_location = False
message = ""
location = request.get_slot_value("Location")
should_end_session = True
if not location:
# Get trends for user's current location
user_details = get_user_twitter_details(uid)
location = user_details[0]['location']
if location:
message += "Finding trends near you . "
else:
message += "I could not figure out where you are, please set it up on your twitter account . "
if location:
response = geo_search(request.access_token(), location) # convert natural language text to location
top_result = response['result']['places'][0]
lon, lat = top_result['centroid']
trend_params = {"lat" : lat, "long" : lon}
trend_location = closest_trend_search(request.access_token(), trend_params) # find closest woeid which has trends
woeid = trend_location[0]['woeid']
trends = list_trends(request.access_token(), trend_location[0]['woeid']) # List top trends
trend_lst = [trend['name'] for trend in trends[0]['trends']]
message += "The top trending topics near {0} are, ".format(trend_location[0]['name'])
message += "\n".join(["{0}, {1}, ".format(index+1, trend) for index, trend in enumerate(trend_lst)])
return alexa.create_response(message=message, end_session=should_end_session)
def launch_request_handler(request):
return alexa.create_response(
message=
"Welcome to Animal Translator! If you give me the name of an animal, I will respond with the human pronounciation of the sound it makes! What animal would you like me to sound out for you?",
reprompt_message=
'Learning how to say the sounds of animals can be fun! What animal would you like me to sound out for you?'
)
def previous_intent_handler(request):
user_queue = twitter_cache.user_queue(request.access_token())
if user_queue and user_queue.has_prev():
message = user_queue.read_out_prev()
else:
message = "I couldn't find anything to repeat"
return alexa.create_response(message=message)
def reply_handler(request):
message = "Sorry, I couldn't tell which tweet you want to reply to. "
slots = request.get_slot_map()
user_state = twitter_cache.get_user_state(request.access_token())
should_end_session = True
if not slots["Tweet"]:
return reply_focus_handler(request)
else:
can_reply = False
if slots['Tweet'] and not (slots['Ordinal'] or slots['Index']):
user_state = twitter_cache.get_user_state(request.access_token())
if 'focus_tweet' in user_state: # User is focused on a tweet
can_reply = True
else:
index = focused_on_tweet(request)
if index: can_reply = True
if can_reply: # Successfully focused on a tweet
index, focus_tweet = user_state['focus_tweet']
tweet_message = "@{0} {1}".format(focus_tweet.get_screen_name(),
slots['Tweet'])
params = {"in_reply_to_status_id": focus_tweet.get_id()}
def action():
print ("Performing action! lambda functions are awesome!")
message = post_tweet(request.access_token(), tweet_message, params)
del user_state['focus_tweet']
return message
should_end_session = False
message = "I am ready to post the tweet, {}. Please say yes to confirm or stop to cancel.".format(slots['Tweet'])
user_state['pending_action'] = {"action" : action,
"description" : message }
return alexa.create_response(message=message, end_session=should_end_session)
def tweet_list_handler(request, tweet_list_builder, msg_prefix=""):
""" This is a generic function to handle any intent that reads out a list of tweets"""
# tweet_list_builder is a function that takes a unique identifier and returns a list of things to say
tweets = tweet_list_builder(request.access_token())
print (len(tweets), 'tweets found')
if tweets:
twitter_cache.initialize_user_queue(user_id=request.access_token(),
queue=tweets)
text_to_read_out = twitter_cache.user_queue(request.access_token()).read_out_next(MAX_RESPONSE_TWEETS)
message = msg_prefix + text_to_read_out + ", say 'next' to hear more, or reply to a tweet by number."
return alexa.create_response(message=message,
end_session=False)
else:
return alexa.create_response(message="Sorry, no tweets found, please try something else",
end_session=False)
def launch_request_handler(request):
card = alexa.create_card(title="最新の番組一覧",
subtitle=None,
content=oi.getStringListOfDay("最新"))
return alexa.create_response('再生したい番組を教えてください',
end_session=False,
card_obj=card)
def next_train_intent_handler(request):
# Get variables like userId, slots, intent name etc from the 'Request' object
station = request.slots["Station"]
if station == None:
return alexa.create_response("Please try again, giving the destination station name.")
result = get_trips(station, 'depart')
return deliver_result(station,result)
def get_suspect_intent_handler(request):
"""
Whodunnit??
"""
# Get variables like userId, slots, intent name etc from the 'Request' object
suspect = request.slots["Suspect"]
suspect = suspect.lower()
if suspect == None:
return alexa.create_response("Could not find a suspect!")
elif suspect == killer_name:
return alexa.create_response("You are correct! Congratulations, you have saved the day. Well, not the murder victims day. Or the killer's day. But someone's day was surely saved.", end_session=True)
else:
return alexa.create_response("You are wrong, the killer will now go free and the victim's murder will never be solved. Way to ruin everything. ", end_session=True)
def help_intent_handler(request):
cat_list = [cat for cat in useful_science.categories]
pre = cat_list[:-1]
post = cat_list[-1:]
formatted = " ".join(map(lambda x : x+",", pre) + ['and'] + post)
message = ["You can ask for posts in the following categories - ",
formatted]
return alexa.create_response(message=' '.join(message))
def get_temp_response(temperature_type, success_response, fail_response, min_date=None, max_date=None, aggregate_type=None):
params={}
if min_date:
params['min_date'] = min_date
if max_date:
params['max_date'] = max_date
if aggregate_type:
params['aggregate_type'] = aggregate_type
try:
endpoint = '/temperature/%s' % temperature_type
response = poolmon.request(endpoint, params=params)
temp = int(round(response['measurements'][0]['temperature'][preferred_temp_type]))
message = success_response % {'temp': temp}
return alexa.create_response(message=message, end_session=True)
except IndexError:
return alexa.create_response(message=fail_response, end_session=True)
def more_info_handler(request):
index = focused_on_tweet(request)
if index:
user_state = twitter_cache.get_user_state(request.access_token())
index, tweet = user_state['focus_tweet']
message = " ".join(["details about tweet number {}.".format(index+1), tweet.detailed_description(),
"To reply, say 'reply' followed by your message"])
return alexa.create_response(message=message, end_session=False)
return reply_focus_handler(request)
def past_ambient_temp(request):
min_date, max_date, date_type = poolmon.parse_date(request.slots['Date'])
if date_type == 'day':
aggregate_type = 'max'
elif date_type == 'week' or date_type == 'year':
aggregate_type = 'avg'
else:
return alexa.create_response(message=DATE_PARSE_FAIL, end_session=False)
return get_temp_response('ambient', PAST_AMBIENT_TEMP_SUCCESS, PAST_AMBIENT_TEMP_FAIL, min_date=min_date, max_date=max_date, aggregate_type=aggregate_type)
def delays_intent_handler(request):
delays = BartTrip(API_KEY)
result = "DelaysIntent activated"
if delays.error:
speak = "Sorry. {}".format(delays.error)
result = "DelaysIntent error"
elif delays.delays:
speak = delays.delays
else:
speak = "No delays reported."
card = alexa.create_card(title = result, subtitle=None, content=speak)
return alexa.create_response(speak,end_session=True,card_obj=card)
def set_waketime_intent_handler(request):
""" Tell Alexa when you woke up.
"""
cur_date = get_cur_date() - timedelta(days=1)
wake_str = cur_date.strftime(TIME_FMT)
r = set_value_for_date(cur_date, ATTR_MAP["waketime"], wake_str)
# TODO Unhappy path
response_str = "Good morning Michael! I logged your wakeup time as {}. Have a great day!".format(
cur_date.strftime("%I %M %p"))
return alexa.create_response(response_str, end_session=True)
def set_latency_intent(request):
"""Tell Alexa how long it took you to fall asleep.
Expects to be called the day after you went to bed.
"""
cur_date = get_cur_date() - timedelta(days=1)
minutes = request.slots["Minutes"]
minutes_str = "00:{}:00".format(minutes)
r = set_value_for_date(cur_date, ATTR_MAP["latency"], minutes_str)
# TODO: Unhappy path
response_str = "OK, I logged your sleep latency as {} minutes.".format(
minutes)
return alexa.create_response(response_str, end_session=True)
def update_latency_intent(request):
"""Sets the sleep latency based on the current time and the previously logged bedtime.
"""
cur_date = get_cur_date()
if cur_date.hour < 12:
cur_date = cur_date - timedelta(days=1)
prev_bedtime = get_value_on_date(cur_date, ATTR_MAP["bedtime"])
if not prev_bedtime:
response_str = "Sorry, it looks like you haven't set a bedtime yet."
return alexa.create_response(response_str, end_session=True)
prev_bedtime = create_datetime_from_time(prev_bedtime)
latency = int((cur_date - prev_bedtime).total_seconds()/60)
latency_str = "00:{}:00".format(latency)
set_value_for_date(cur_date, ATTR_MAP["latency"], latency_str)
response_str = "OK Michael, I updated your sleep latency to {} minutes".format(latency)
return alexa.create_response(response_str, end_session=True)
def results_for_afd(station_name, report_component):
report = Noaa()
station= HOME_STATION
component = report_component.upper()
report.get_afd_for(station)
if report.error:
card_title = 'error'
content = 'Sorry. {}'.format(report.error)
else:
card_title = 'activated'
content = report.sections[component]
card = alexa.create_card(title = '{}Intent {}'.format(component,card_title), subtitle='Station: {}'.format(station), content=content)
return alexa.create_response(content, end_session=True, card_obj = card)
def next_intent_handler(request):
"""
Takes care of things whenver the user says 'next'
"""
message = "Sorry, couldn't find anything in your next queue"
end_session = True
if True:
user_queue = twitter_cache.user_queue(request.access_token())
if not user_queue.is_finished():
message = user_queue.read_out_next(MAX_RESPONSE_TWEETS)
if not user_queue.is_finished():
end_session = False
message = message + ". Please, say 'next' if you want me to read out more. "
return alexa.create_response(message=message,
end_session=end_session)
def set_bedtime_intent_handler(request):
""" Tell Alexa when you went to bed.
"""
# TODO: This guy should clear out the sleep latency for the day when it's set
cur_date = get_cur_date()
# If bedtime is AM, set date to be previous day
if cur_date.hour < 12:
cur_date = cur_date - timedelta(days=1)
bedtime = cur_date.strftime(TIME_FMT)
r = set_value_for_date(cur_date, ATTR_MAP["bedtime"], bedtime)
response_str = "OK, I logged your bedtime as {}. Goodnight Michael!".format(
cur_date.strftime("%I %M %p"))
return alexa.create_response(response_str, end_session=True)
def confirm_action_handler(request):
message = "okay."
user_state = twitter_cache.get_user_state(request.access_token())
should_end_session = True
if 'pending_action' in user_state:
params = user_state['pending_action']
# Perform action
message = params['action']()
if 'message' in params:
message = params['message']
if 'callback' in params:
params['callback']()
del user_state['pending_action']
print ("successfully executed command")
message = message + " would you like me to do anything else ? "
should_end_session = False
return alexa.create_response(message, end_session=should_end_session)
def get_posts_intent_handler(request):
def resolve_slots(text):
if text in useful_science.categories:
return text
return 'new'
category_text = request.slots['Category']
category = resolve_slots(category_text)
post = useful_science.post_cache.get_post(category)
card_content = "{0} Link: {1}".format(post['summary'],
post['permalink'])
card = alexa.create_card(title=post['meta_title'],
subtitle=post['categories'],
content=card_content)
return alexa.create_response(message=post['summary'],
end_session=True,
card_obj=card)
def post_tweet_intent_handler(request):
"""
Use the 'intent' field in the VoiceHandler to map to the respective intent.
"""
tweet = request.get_slot_value("Tweet")
tweet = tweet if tweet else ""
if tweet:
user_state = twitter_cache.get_user_state(request.access_token())
def action():
return post_tweet(request.access_token(), tweet)
message = "I am ready to post the tweet, {} ,\n Please say yes to confirm or stop to cancel .".format(tweet)
user_state['pending_action'] = {"action" : action,
"description" : message}
return r.create_response(message=message, end_session=False)
else:
# No tweet could be disambiguated
message = " ".join(
[
"I'm sorry, I couldn't understand what you wanted to tweet .",
"Please prepend the message with either post or tweet ."
]
)
return alexa.create_response(message=message, end_session=False)
def next_recipe_intent_handler(request):
"""
You can insert arbitrary business logic code here
"""
return alexa.create_response(message="Getting Next Recipe ... 123")
def session_ended_request_handler(request):
return alexa.create_response(message="Goodbye!")
