def get_handler():
sb = StandardSkillBuilder(table_name="GoogleClassroomStates",\
auto_create_table=True)
sb.add_request_handler(PermissionChangedEventHandler())
sb.add_request_handler(ProactiveSubscriptionChanged())
sb.add_request_handler(AccountLinkedEventHandler())
return sb.lambda_handler()
def test_persistence_adapter_set(self):
test_table_name = "TestTable"
test_dynamodb_resource = mock.Mock()
test_partition_keygen = mock.Mock()
test_auto_create_table = False
test_skill_builder = StandardSkillBuilder(
table_name=test_table_name,
auto_create_table=test_auto_create_table,
partition_keygen=test_partition_keygen,
dynamodb_client=test_dynamodb_resource)
actual_skill_config = test_skill_builder.skill_configuration
actual_adapter = actual_skill_config.persistence_adapter
assert isinstance(actual_adapter, DynamoDbAdapter), (
"Standard Skill Builder set incorrect persistence adapter in "
"skill configuration")
assert actual_adapter.table_name == test_table_name, (
"Standard Skill Builder set persistence adapter with incorrect "
"table name in skill configuration")
assert actual_adapter.partition_keygen == test_partition_keygen, (
"Standard Skill Builder set persistence adapter with incorrect "
"partition key generator function in skill configuration")
assert actual_adapter.create_table == test_auto_create_table, (
"Standard Skill Builder set persistence adapter with incorrect "
"auto create table flag in skill configuration")
assert actual_adapter.dynamodb == test_dynamodb_resource, (
"Standard Skill Builder set persistence adapter with incorrect "
"dynamo db resource in skill configuration")
def test_persistence_adapter_default_null(self):
test_skill_builder = StandardSkillBuilder()
actual_skill_config = test_skill_builder.skill_configuration
assert actual_skill_config.persistence_adapter is None, (
"Standard Skill Builder didn't set Persistence Adapter to None "
"when no table_name is provided")
def test_default_api_client_set(self):
test_skill_builder = StandardSkillBuilder()
actual_skill_config = test_skill_builder.skill_configuration
assert isinstance(actual_skill_config.api_client, DefaultApiClient), (
"Standard Skill Builder didn't set the api client to the default"
"implementation")
#point at local dynamodb
#skill_persistence_table = os.environ["skill_persistence_table"]
skill_persistence_table = 'recipedb'
dynamodb = boto3.resource(
'dynamodb',
region_name='us-east-1') #, endpoint_url="http://localhost:8000")
RECIPE_SLOT = 'recipe'
INGREDIENT_SLOT = 'ingredient'
SESSION_KEY = 'current_recipe'
PERSISTENCE_KEY = 'recipe_list'
sb = StandardSkillBuilder(table_name=skill_persistence_table,
auto_create_table=False,
partition_keygen=ask_sdk_dynamodb.partition_keygen.
user_id_partition_keygen,
dynamodb_client=dynamodb)
class LaunchRequestHandler(AbstractRequestHandler):
def can_handle(self, handler_input):
return is_request_type("LaunchRequest")(handler_input)
def handle(self, handler_input):
speech_text = "Welcome to the Recipe Tracker Skill. Say 'start a recipe' or 'create a recipe' to start tracking!"
handler_input.response_builder.speak(speech_text).set_card(
SimpleCard("Launch Recipe Tracker",
speech_text)).set_should_end_session(False)
return handler_input.response_builder.response
# coding: UTF-8
from ask_sdk_core.skill_builder import SkillBuilder
from ask_sdk_core.dispatch_components import AbstractRequestHandler
from ask_sdk_core.dispatch_components import AbstractExceptionHandler
from ask_sdk_core.utils import is_request_type, is_intent_name
from ask_sdk_model.ui import SimpleCard
from ask_sdk_core.response_helper import ResponseFactory
from ask_sdk.standard import StandardSkillBuilder
import datetime
import boto3
from boto3.dynamodb.conditions import Key, Attr
dynamodb = boto3.resource('dynamodb', region_name='ap-northeast-1')
table = dynamodb.Table('SapporoTrashCalendar')
sb = StandardSkillBuilder(table_name="SapporoTrash", auto_create_table=True)
class LaunchRequestHandler(AbstractRequestHandler):
def can_handle(self, handler_input):
return handler_input.request_envelope.request.object_type == "LaunchRequest"
def handle(self, handler_input):
attr = handler_input.attributes_manager.persistent_attributes
if not attr:
speech_text = "札幌市のゴミ収集情報をお知らせします。はじめに、収集エリアの設定を行います。おすまいの区を教えてください"
card_title = "初期設定"
card_body = "お住いの区を教えてください"
reprompt = "おすまいの区を教えてください"
else:
speech_text = "今日以降で何のゴミか知りたい日、または、出したいゴミの種類、どちらかを教えてください"
reprompt = "今日以降で何のゴミか知りたい日、または、出したいゴミの種類、どちらかを教えてください"
"""lambda_function.py: example phone Alexa skill."""
import logging
from ask_sdk.standard import StandardSkillBuilder
from ask_sdk_core.dispatch_components import (
AbstractRequestHandler, AbstractExceptionHandler)
from ask_sdk_core.utils import is_intent_name, is_request_type
sb = StandardSkillBuilder(table_name="PhoneTable", auto_create_table=True)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
class LaunchRequestHandler(AbstractRequestHandler):
"""Handler for skill launch."""
def can_handle(self, handler_input):
"""Can handle or not."""
return is_request_type("LaunchRequest")(handler_input)
def handle(self, handler_input):
"""Handle response."""
logger.info("In LaunchRequestHandler")
# get attributes from DynamoDB table
session_attr = handler_input.attributes_manager.persistent_attributes
if not session_attr:
# first time
speech = "Hi. What is your phone number?"
reprompt = "What is your phone number?"
else:
class RequestLogger(AbstractRequestInterceptor):
"""Log the request envelope."""
def process(self, handler_input):
# type: (HandlerInput) -> None
logger.info("Request Envelope: {}".format(
handler_input.request_envelope))
class ResponseLogger(AbstractResponseInterceptor):
"""Log the response envelope."""
def process(self, handler_input, response):
# type: (HandlerInput, Response) -> None
logger.info("Response: {}".format(response))
sb = StandardSkillBuilder()
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(InProgressHowMuchIntent())
sb.add_request_handler(InProgressHowManyIntent())
sb.add_request_handler(HowMuchIsCryptoInFiat())
sb.add_request_handler(HowManyCryptoCanIBuy())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(FallbackIntentHandler())
sb.add_request_handler(SessionEndedHandler())
sb.add_request_handler(RepeatHandler())
sb.add_exception_handler(CatchAllExceptionHandler())
sb.add_global_request_interceptor(RequestLogger())
sb.add_global_response_interceptor(ResponseLogger())
lambda_handler = sb.lambda_handler()
from ask_sdk.standard import StandardSkillBuilder
from ask_sdk_core.utils import is_request_type, is_intent_name
import ask_sdk_dynamodb
from ask_sdk_model.dialog import (ElicitSlotDirective, DelegateDirective)
from ask_sdk_model import (Response, IntentRequest, DialogState,
SlotConfirmationStatus, Slot)
from ask_sdk_model.ui import SimpleCard
import config
dbTable = os.environ["skill_persistence_table"]
skillId = os.environ["skill_id"]
skillName = config.config['skill_name']
sb = StandardSkillBuilder(table_name=dbTable,
auto_create_table=False,
partition_keygen=ask_sdk_dynamodb.partition_keygen.
user_id_partition_keygen)
###########################
# Launcher Request
###########################
@sb.request_handler(can_handle_func=is_request_type("LaunchRequest"))
def launch_request_handler(handler_input):
attr = handler_input.attributes_manager.persistent_attributes
session_attr = {
'state': 'launch',
'prev_state': '',
}
class SessionEndedRequestHandler(AbstractRequestHandler):
def can_handle(self, handler_input):
return is_request_type("SessionEndedRequest")(handler_input)
def handle(self, handler_input):
logger.debug(
f"Reason for ending session: {handler_input.request_envelope.request.reason}"
)
# persist_user_attributes(handler_input)
return handler_input.response_builder.response
sb = StandardSkillBuilder(
# table_name='whoami_user', auto_create_table=False,
# partition_keygen=ask_sdk_dynamodb.partition_keygen.user_id_partition_keygen
)
# Add all request handlers to the skill.
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(SessionEndedRequestHandler())
sb.add_request_handler(StopIntent())
sb.add_request_handler(CancelIntent())
sb.add_request_handler(HelpIntent())
sb.add_request_handler(PreviousIntent())
sb.add_request_handler(YesIntentHandler())
sb.add_request_handler(NoIntentHandler())
# sb.add_request_handler(StartOverIntent())
# sb.add_request_handler(PauseIntent())
sb.add_request_handler(DownloadIntentHandler())
sb.add_request_handler(MovieTitleHandler())
import os
import time
import math
from ask_sdk.standard import StandardSkillBuilder
from ask_sdk_core.utils import is_request_type, is_intent_name
import ask_sdk_dynamodb
from ask_sdk_core.dispatch_components import AbstractRequestHandler, AbstractExceptionHandler, \
AbstractRequestInterceptor, AbstractResponseInterceptor
skill_persistence_table = os.environ["skill_persistence_table"]
SKILL_NAME = 'code counter'
sb = StandardSkillBuilder(table_name=skill_persistence_table,
auto_create_table=False,
partition_keygen=ask_sdk_dynamodb.partition_keygen.
user_id_partition_keygen)
'''
cat_facts = [
"A cat usually has about 12 whiskers on each side of its face.",
"On average, cats spend 2/3 of every day sleeping. That means a nine-year-old cat has been awake for only three years of its life.",
"In the original Italian version of Cinderella, the benevolent fairy godmother figure was a cat.",
"In the 1750s, Europeans introduced cats into the Americas to control pests.",
"Cats spend nearly 1/3 of their waking hours cleaning themselves.",
"A female cat is called a queen or a molly.",
"Rome has more homeless cats per square mile than any other city in the world.",
"Cats can drink seawater.",
"Cats are extremely sensitive to vibrations. Cats are said to detect earthquake tremors 10 or 15 minutes before humans can.",
"A cat's heart beats nearly twice as fast as a human heart, at 110 to 140 beats a minute."
]
'''
def process(self, handler_input, response):
# type: (HandlerInput, Response) -> None
logger.debug("Alexa Response: {}".format(response))
class SavePersistenceAttributesResponseInterceptor(AbstractResponseInterceptor
):
"""Save persistence attributes before sending response to user."""
def process(self, handler_input, response):
# type: (HandlerInput, Response) -> None
handler_input.attributes_manager.save_persistent_attributes()
# ###################################################################
sb = StandardSkillBuilder(table_name=data.DYNAMODB_TABLE_NAME,
auto_create_table=True)
# ############# REGISTER HANDLERS #####################
# Request Handlers
sb.add_request_handler(CheckAudioInterfaceHandler())
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(ExceptionEncounteredHandler())
sb.add_request_handler(SessionEndedRequestHandler())
sb.add_request_handler(YesHandler())
sb.add_request_handler(NoHandler())
sb.add_request_handler(StartPlaybackHandler())
sb.add_request_handler(PlayCommandHandler())
sb.add_request_handler(NextPlaybackHandler())
sb.add_request_handler(NextCommandHandler())
sb.add_request_handler(PreviousPlaybackHandler())
class RequestLogger(AbstractRequestInterceptor):
"""Log the request envelope."""
def process(self, handler_input):
# type: (HandlerInput) -> None
logger.info("Request Envelope: {}".format(
handler_input.request_envelope))
class ResponseLogger(AbstractResponseInterceptor):
"""Log the response envelope."""
def process(self, handler_input, response):
# type: (HandlerInput, Response) -> None
logger.info("Response: {}".format(response))
sb = StandardSkillBuilder()
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(GetFactHandler())
sb.add_request_handler(YesHandler())
sb.add_request_handler(NoHandler())
sb.add_request_handler(GetCategoryFactHandler())
sb.add_request_handler(BuyResponseHandler())
sb.add_request_handler(CancelResponseHandler())
sb.add_request_handler(UpsellResponseHandler())
sb.add_request_handler(ShoppingHandler())
sb.add_request_handler(ProductDetailHandler())
sb.add_request_handler(BuyHandler())
sb.add_request_handler(CancelSubscriptionHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(FallbackIntentHandler())
import time
from ask_sdk.standard import StandardSkillBuilder
from ask_sdk_core.utils import is_request_type, is_intent_name
import jmespath
from core import logger, log_invocation # pylint: disable=no-name-in-module
import content
import models
import utils
# TODO: navigate home intent?
# TODO: support "make it harder/easier" and "change operation" intents
# TODO: prompt for a 5-star review
sb = StandardSkillBuilder(table_name=os.environ['SKILL_TABLE_NAME'])
sb.skill_id = 'amzn1.ask.skill.d455ad8c-dde9-4ee8-a492-4e3985b5ff79'
sb.custom_user_agent = 'alexa-math-practice-skill/1.0.0'
#
# helpers
#
def request_handler(request_type):
def wrapper(fn):
return sb.request_handler(is_request_type(request_type))(fn)
return wrapper
skill_name = "Baby Data"
help_text = ("You can say baby slept at 2pm or "
"had a diaper change at 2:30pm "
"or that the last feed was at 11am")
sleep_slot_key = "SLEEP"
diaper_slot_key = "DIAPER"
feed_slot_key = "FEED"
baby_name_slot_key = "BABY"
sleep_slot = "Sleep"
diaper_slot = "Diaper"
feed_slot = "Feed"
baby_name_slot = "Baby"
# sb = SkillBuilder()
sb = StandardSkillBuilder(table_name="alexa-baby-data", auto_create_table=True)
@sb.request_handler(can_handle_func=is_request_type("LaunchRequest"))
def launch_request_handler(handler_input):
# Handler for Skill Launch
attr = handler_input.attributes_manager.persistent_attributes
handler_input.attributes_manager.session_attributes = attr
if not attr:
missing_name_text = "What is the name of your baby? Say my baby's name is Jane"
handler_input.response_builder.speak(missing_name_text).ask(
missing_name_text)
return handler_input.response_builder.response
from ask_sdk.standard import StandardSkillBuilder
from ask_sdk_core.dispatch_components import AbstractRequestHandler
from ask_sdk_core.dispatch_components import AbstractExceptionHandler
from ask_sdk_core.utils import is_request_type, is_intent_name
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_model import Response
from ask_sdk_model.ui import AskForPermissionsConsentCard
from ask_sdk_model.services import ServiceException
from auxilary import get_a_question, send_email
import requests
sb = StandardSkillBuilder(
table_name='interview_me_users',
auto_create_table=True,
)
skill_name = "Interview Me"
NOTIFY_MISSING_PERMISSIONS = """
Please enable email permissions in the Amazon Alexa app.
"""
ERROR = """
Something wen't bad. Please try again in a while.
"""
permissions = ["alexa::profile:email:read"]
CONTINUE_QUESTION = "What would you like to do next ? I can email this question to you, or you can tell me another topic to ask question from ?"
class LaunchRequestHandler(AbstractRequestHandler):
def can_handle(self, handler_input):
return handler_input.response_builder.response
class RequestLogger(AbstractRequestInterceptor):
"""Log the request envelope."""
def process(self, handler_input):
# type: (HandlerInput) -> None
logger.info("Request Envelope: {}".format(
handler_input.request_envelope))
class ResponseLogger(AbstractResponseInterceptor):
"""Log the response envelope."""
def process(self, handler_input, response):
# type: (HandlerInput, Response) -> None
logger.info("Response: {}".format(response))
sb = StandardSkillBuilder()
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(FallbackIntentHandler())
sb.add_request_handler(SessionEndedHandler())
sb.add_exception_handler(CatchAllExceptionHandler())
sb.add_global_request_interceptor(RequestLogger())
sb.add_global_response_interceptor(ResponseLogger())
lambda_handler = sb.lambda_handler()
#End of program
# Request and Response Loggers
class RequestLogger(AbstractRequestInterceptor):
"""Log the request envelope."""
def process(self, handler_input):
logger.info("Request Envelope: {}".format(
handler_input.request_envelope))
class ResponseLogger(AbstractResponseInterceptor):
"""Log the response envelope."""
def process(self, handler_input, response):
logger.info("Response: {}".format(response))
# build a skill
sb = StandardSkillBuilder(table_name="Pomodoro", auto_create_table=True)
# add request handlers
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(PomodoroSessionHandler())
sb.add_request_handler(StartBreakHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(CancelAndStopIntentHandler())
sb.add_request_handler(SessionEndedRequestHandler())
# add exception handler
sb.add_exception_handler(AllExceptionHandler())
# add response interceptor
sb.add_global_request_interceptor(RequestLogger())
sb.add_global_response_interceptor(ResponseLogger())
# type: (HandlerInput, Exception) -> bool
return True
def handle(self, handler_input, exception):
# type: (HandlerInput, Exception) -> Response
logger.error(exception, exc_info=True)
speech_text = "Sorry, I couldn't understand what you said. Please try again."
handler_input.response_builder.speak(speech_text).ask(
speech_text).set_should_end_session(True)
return handler_input.response_builder.response
# This handler acts as the entry point for your skill, routing all request and response
# payloads to the handlers above. Make sure any new handlers or interceptors you've
# defined are included below. The order matters - they're processed top to bottom.
sb = StandardSkillBuilder()
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(WithContextIntentHandler())
sb.add_request_handler(GaneshaShopIntentHandler())
sb.add_request_handler(UseIntentHandler())
sb.add_request_handler(YesIntentHandler())
sb.add_request_handler(WhatHaveIGotIntentHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(CancelOrStopIntentHandler())
sb.add_request_handler(SessionEndedRequestHandler())
sb.add_request_handler(BuyHandler())
sb.add_request_handler(BuyResponseHandler())
sb.add_request_handler(WhatCanIBuyHandler())
sb.add_request_handler(ProductDetailHandler())
sb.add_request_handler(RefundProductHandler())
import os
from ask_sdk.standard import StandardSkillBuilder
from command_handlers import (LaunchRequestHandler, StartLatestEpisodeHandler, StopEpisodeHandler, SearchEpisodeHandler,
ShuffleOnEpisodeHandler, ShuffleOffEpisodeHandler, StartOverEpisodeHandler,
RepeatEpisodeHandler,ResumeEpisodeHandler, HelpHandler, FallbackHandler, SessionEndedRequestHandler,
PreviousEpisodeHandler, NextEpisodeHandler, LoopOnEpisodeHandler, LoopOffEpisodeHandler)
from event_handlers import (PlaybackStoppedHandler, PlaybackFinishedHandler, PlaybackStartedHandler,
PlaybackFailedHandler, PlaybackNearlyFinishedHandler)
from interceptors import (SaveStateResponseInterceptor, LoadStateRequestInterceptor, RequestLogger, ResponseLogger,
CatchAllExceptionHandler)
streaming_table_name = os.getenv("STREAMING_TABLE_NAME")
skill_builder = StandardSkillBuilder(
table_name=streaming_table_name,
auto_create_table=False)
# Launch Request
skill_builder.add_request_handler(LaunchRequestHandler())
# Command Handlers
skill_builder.add_request_handler(StartLatestEpisodeHandler())
skill_builder.add_request_handler(SessionEndedRequestHandler())
skill_builder.add_request_handler(StopEpisodeHandler())
skill_builder.add_request_handler(ResumeEpisodeHandler())
skill_builder.add_request_handler(SearchEpisodeHandler())
skill_builder.add_request_handler(ShuffleOnEpisodeHandler())
skill_builder.add_request_handler(ShuffleOffEpisodeHandler())
skill_builder.add_request_handler(StartOverEpisodeHandler())
skill_builder.add_request_handler(RepeatEpisodeHandler())
from ask_sdk.standard import StandardSkillBuilder
from ask_sdk_core.utils import is_request_type, is_intent_name
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_core.dispatch_components import AbstractRequestHandler
from ask_sdk_model.ui import SimpleCard
from ask_sdk_model import Response
from the_whisperer_in_darkness import TheWhispererInDarkness
from the_whisperer_in_darkness import OctopusRoom
from slot_types import Room
from alexa_helper import StateHelper
from alexa_helper import AlexaHelper
from audio import Audio
SKILL_NAME = 'The Whisperer in Darkness'
sb = StandardSkillBuilder(table_name="The-Whisperer-In-Darkness",
auto_create_table=True)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
@sb.request_handler(can_handle_func=is_request_type("LaunchRequest"))
def launch_request_handler(handler_input):
"""
Handler for Skill Launch.
"""
# type: (HandlerInput) -> Response
state_variables = handler_input.attributes_manager.persistent_attributes
if state_variables is None:
state_variables = {}
if not state_variables:
import logging
import gettext
from ask_sdk.standard import StandardSkillBuilder
from ask_sdk_core.dispatch_components import (AbstractRequestHandler,
AbstractExceptionHandler,
AbstractRequestInterceptor,
AbstractResponseInterceptor)
from ask_sdk_core.utils import is_request_type, is_intent_name
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_model import Response
import data
import util
sb = StandardSkillBuilder(table_name=data.jingle["db_table"],
auto_create_table=True)
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
# ######################### INTENT HANDLERS #########################
# This section contains handlers for the built-in intents and generic
# request handlers like launch, session end, skill events etc.
class CheckAudioInterfaceHandler(AbstractRequestHandler):
"""Check if device supports audio play.
This can be used as the first handler to be checked, before invoking
other handlers, thus making the skill respond to unsupported devices
without doing much processing.
"""
from ask_sdk.standard import StandardSkillBuilder from fallzahlen.handlers.today_handler import TodayIntentHandler from fallzahlen.handlers.close_handler import CloseRequestHandler from fallzahlen.handlers.help_handler import HelpHandler from fallzahlen.handlers.fallback_handler import FallbackHandler from fallzahlen.handlers.exception_handler import ExceptionHandler builder = StandardSkillBuilder() builder.add_request_handler(TodayIntentHandler()) builder.add_request_handler(CloseRequestHandler()) builder.add_request_handler(HelpHandler()) builder.add_request_handler(FallbackHandler()) builder.add_exception_handler(ExceptionHandler()) handler = builder.lambda_handler()
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk.standard import StandardSkillBuilder
from ask_sdk_core.utils import is_intent_name, is_request_type
from ask_sdk_model import Response
import assistant
import skill_helpers
import data
from device_helpers import register_device, RegistrationError
_logger = logging.getLogger(__name__)
_logger.setLevel(logging.DEBUG)
_sb = StandardSkillBuilder(table_name=data.DYNAMODB_TABLE, auto_create_table=True)
def preflight_check(f: Callable) -> Callable:
@wraps(f)
def decorated_function(handler_input: HandlerInput) -> Response:
_logger.info('Pre-flight check')
# Obtain credentials
credentials = skill_helpers.get_credentials(handler_input)
# Obtain the deviceId
device_id = skill_helpers.get_device_id(handler_input)
last_device_id = skill_helpers.get_persistent_attribute(handler_input, 'device_id')
project_id = data.GOOGLE_ASSISTANT_API['project_id']
from ask_sdk_model.ui import (AskForPermissionsConsentCard, SimpleCard,
StandardCard)
## Not sure why this import is different from line 34;
## commenting to see what happens:
#from ask_sdk_core.dispatch_components.exception_components import(
# AbstractExceptionHandler
#)
# Local imports
import audio
import display
import events
import kilian_data
import session
sb = StandardSkillBuilder()
LOGGER = logging.getLogger()
LOGGER.setLevel(logging.INFO)
# =============================================================================
# Main Handler
# =============================================================================
class LaunchRequestHandler(AbstractRequestHandler):
"""Object handling all initial requests. Launches the skill."""
def can_handle(self, handler_input):
"""Inform the request handler of what intents can be handled."""
return is_request_type("LaunchRequest")(handler_input)
def handle(self, handler_input):
"""Handle the launch request; fetch and serve appropriate response.
)
sample_saved_attributes = {
'3': {
'object': 'latte',
'expiration': '2019-08-17',
'token': 'bcccd595-58ca-4041-85c7-990ac9248c93'
}
}
import boto3
dynamodb = boto3.resource('dynamodb', region_name='eu-west-1')
sb = StandardSkillBuilder(table_name="Scadenze",
auto_create_table=True,
partition_keygen=user_id_partition_keygen,
dynamodb_client=dynamodb)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
welcome_speech = {
"en-US": "Welcome. You can say: Add milk with expiration August 5th",
"it-IT": "Ciao. Puoi dire: aggiungi latte con scadenza 5 Agosto."
}
FOOD_SLOT = "food"
DATE_SLOT = "date"
NOTIFY_MISSING_PERMISSIONS = (
"Per favore, autorizza i Promemoria nella app Amazon Alexa.")
from planet_story.solar_questions import Question
# Const strings
STAR = 'star'
PLANET = 'planet'
BRIGHTNESS = 'brightness'
SIZE = 'size'
DISTANCE = 'distance'
SKILL_TITLE = 'Build A Planet'
# sb = SkillBuilder()
sb = StandardSkillBuilder()
planet_story: PlanetStory
device: Device
def get_slot_value_from_handler(handler_input, slot_name):
return str(
handler_input.request_envelope.request.intent.slots[slot_name].
resolutions.resolutions_per_authority[0].values[0].value.name).lower()
def _load_apl_document(file_path):
# type: (str) -> Dict[str, Any]
"""Load the apl json document at the path into a dict object."""
with open(file_path) as f:
return json.load(f)
# -*- coding: utf-8 -*-
# This is a High Low Guess game Alexa Skill.
# The skill serves as a simple sample on how to use the
# persistence attributes and persistence adapter features in the SDK.
import random
import logging
from ask_sdk.standard import StandardSkillBuilder
from ask_sdk_core.utils import is_request_type, is_intent_name
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_model import Response
SKILL_NAME = 'High Low Game'
sb = StandardSkillBuilder(table_name="High-Low-Game", auto_create_table=True)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
@sb.request_handler(can_handle_func=is_request_type("LaunchRequest"))
def launch_request_handler(handler_input):
"""Handler for Skill Launch.
Get the persistence attributes, to figure out the game state.
"""
# type: (HandlerInput) -> Response
attr = handler_input.attributes_manager.persistent_attributes
if not attr:
attr['ended_session_count'] = 0
import json
import six
from ask_sdk.standard import StandardSkillBuilder
from ask_sdk_core.utils import is_request_type, is_intent_name
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_model import Response, ui
from ask_sdk_model.slu.entityresolution import StatusCode
from lessons import LESSONS
SKILL_NAME = 'Auralias'
CARD_FOLDER = 'https://s3.amazonaws.com/auralias-alexa-skill/cards/'
MP3_FOLDER = 'https://s3.amazonaws.com/auralias-alexa-skill/mp3s/'
sb = StandardSkillBuilder(table_name="Auralias", auto_create_table=True)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
def calculate_assessment_questions(subject, level):
major_scale_formula = [0, 2, 2, 1, 2, 2, 2, 1]
major_interval_names = ['unison', 'major 2nd', 'major 3rd', 'perfect 4th', 'perfect 5th', 'major 6th',
'major 7th', 'octave']
major_interval_cards = [1, 2, 3, 4, 5, 6, 7, 8]
start_note_midi_key_map = {
'c_major_asc': 60,
'd_major_asc': 62,
'd_major_desc': 74
}
return None
def get_count_person(persistence_attr):
personClass = [0, 0]
for person_id in persistence_attr:
if 'personClass' not in persistence_attr[person_id]:
pass
elif 'parent' not in persistence_attr[person_id]['personClass']:
personClass[0] += 1
elif 'parent' not in persistence_attr[person_id]['personClass']:
personClass[1] += 1
return personClass
sb = StandardSkillBuilder()
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(WishAddInIntentHandler())
sb.add_request_handler(WishListIntentHandler())
sb.add_request_handler(WishDeleteIntentHandler())
sb.add_request_handler(AnswerClassIntentHandler())
sb.add_request_handler(PremiumInfoIntentHandler())
sb.add_request_handler(ShoppingIntentHandler())
sb.add_request_handler(BuyIntentHandler())
sb.add_request_handler(CancelSubscriptionIntentHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(CancelIntentHandler())
sb.add_request_handler(StopIntentHandler())
sb.add_request_handler(YesIntentHandler())
sb.add_request_handler(NoIntentHandler())