def test_custom_persistence_adapter_default_null(self): test_custom_skill_builder = CustomSkillBuilder() actual_skill_config = test_custom_skill_builder.skill_configuration assert actual_skill_config.persistence_adapter is None, ( "Custom Skill Builder didn't set the default persistence adapter " "as None")
def test_custom_api_client_default_null(self): test_custom_skill_builder = CustomSkillBuilder() actual_skill_config = test_custom_skill_builder.skill_configuration assert actual_skill_config.api_client is None, ( "Custom Skill Builder didn't set the default api client " "as None")
def test_custom_api_client_used(self): mock_api_client = mock.Mock() test_custom_skill_builder = CustomSkillBuilder( api_client=mock_api_client) actual_skill_config = test_custom_skill_builder.skill_configuration assert actual_skill_config.api_client == mock_api_client, ( "Custom Skill Builder didn't set the api client provided")
def test_custom_persistence_adapter_used(self): mock_adapter = mock.Mock() test_custom_skill_builder = CustomSkillBuilder( persistence_adapter=mock_adapter) actual_skill_config = test_custom_skill_builder.skill_configuration assert actual_skill_config.persistence_adapter == mock_adapter, ( "Custom Skill Builder didn't set the persistence adapter provided")
import json import prompts import recipe_utils import apl_utils from ask_sdk_core.skill_builder import CustomSkillBuilder from ask_sdk_core.serialize import DefaultSerializer from ask_sdk_core.dispatch_components import (AbstractRequestHandler, AbstractExceptionHandler, AbstractResponseInterceptor, AbstractRequestInterceptor) from ask_sdk_core.utils import is_request_type, is_intent_name from ask_sdk_model.ui import StandardCard, Image from ask_sdk_model import Response sb = CustomSkillBuilder() logger = logging.getLogger("main") logger.setLevel(logging.INFO) class LaunchRequestIntentHandler(AbstractRequestHandler): """ Handles LaunchRequest requests sent by Alexa Note: this type of request is sent when hte user invokes your skill without providing a specific intent """ def can_handle(self, handler_input): return is_request_type("LaunchRequest")(handler_input) def handle(self, handler_input): data = handler_input.attributes_manager.request_attributes["_"]
import logging from ask_sdk_core.skill_builder import CustomSkillBuilder from ask_sdk_core.api_client import DefaultApiClient 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 SimpleCard, AskForPermissionsConsentCard from ask_sdk_model.services import ServiceException # python standard library import json # third party import requests import xmltodict sb = CustomSkillBuilder(api_client=DefaultApiClient()) # remove api client #logger = logging.getLogger(__name__) #logger.setLevel(logging.INFO) permissions = ["read::alexa:device:all:address"] Subway_LIST = ["1", "2", "3", "4", "5", "6", "7", "a", "c", "e", "f", "b", "n", "r", "q", "m", "s", "j", "z", "d", "g","l"] Subway_Status = {"1":"", "2":"", "3":"", "4":"", "5":"", "6":"", "7":"", "a":"", "c":"", "e":"", "f":"", "b":"", "n":"", "r":"", "q":"", "w":"", "m":"", "s":"", "j":"", "z":"", "d":"", "g":"","l":"", "si":""} WELCOME = ("Welcome to the Sample Device Address API Skill! " "You can ask for the device address by saying what is my " "address. What do you want to ask?") WHAT_DO_YOU_WANT = "What do you want to ask?" NOTIFY_MISSING_PERMISSIONS = ("Please enable Location permissions in "
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_core.handler_input import HandlerInput from ask_sdk_model.services.directive import ( SendDirectiveRequest, Header, SpeakDirective) from ask_sdk_model.ui import SimpleCard from ask_sdk_model import Response from ask_sdk_core.api_client import DefaultApiClient from ask_sdk_core.skill_builder import CustomSkillBuilder sb = CustomSkillBuilder(api_client=DefaultApiClient()) logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) URL = 'http://35.197.194.231:5000/authenticate/' headers = "Content-Type: application/json" #globals for flow control fact_number = None fact_name = None transaction_completed = False def check_auth(json):
return True def handle(self, handler_input, exception): # type: (HandlerInput, Exception) -> Response logger.error(exception, exc_info=True) speak_output = "Sorry, I had trouble doing what you asked. Please try again." return (handler_input.response_builder.speak(speak_output).ask( speak_output).response) # The SkillBuilder object 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 = CustomSkillBuilder(persistence_adapter=s3_adapter) sb.add_request_handler(LaunchRequestHandler()) sb.add_request_handler(RodarRoletaIntentHandler()) sb.add_request_handler(CriarRoletaIntentHandler()) sb.add_request_handler(HelpIntentHandler()) sb.add_request_handler(CancelOrStopIntentHandler()) sb.add_request_handler(SessionEndedRequestHandler()) sb.add_request_handler( IntentReflectorHandler() ) # make sure IntentReflectorHandler is last so it doesn't override your custom intent handlers sb.add_exception_handler(CatchAllExceptionHandler()) lambda_handler = sb.lambda_handler()
return False def is_warning_needed(current_wealth, current_energy): if current_wealth <= 10 or current_energy <= 10: return True else: return False # The SkillBuilder object 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. # Skill Builder object sb = CustomSkillBuilder(api_client=DefaultApiClient()) # Add all request handlers to the skill. sb.add_request_handler(LaunchRequestHandler()) sb.add_request_handler(StartAdventureIntentHandler()) sb.add_request_handler(HelpIntentHandler()) sb.add_request_handler(CancelOrStopIntentHandler()) sb.add_request_handler(SessionEndedRequestHandler()) sb.add_request_handler(FallbackIntentHandler()) sb.add_request_handler(YesIntentHandler()) sb.add_request_handler(NoIntentHandler()) # Add exception handler to the skill. sb.add_exception_handler(CatchAllExceptionHandler()) # Add request and response interceptors
speak_output = "Sorry, I had trouble doing what you asked. Please try again." return ( handler_input.response_builder .speak(speak_output) .ask(speak_output) .response ) # The SkillBuilder object 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. try: s3_adapter = S3Adapter(bucket_name=AWS_S3_BUCKET) sb = CustomSkillBuilder(persistence_adapter=s3_adapter) sb.add_request_handler(LaunchRequestHandler()) sb.add_request_handler(SetRoomIntentHandler()) sb.add_request_handler(PauseIntentHandler()) sb.add_request_handler(PlayIntentHandler()) sb.add_request_handler(StopIntentHandler()) sb.add_request_handler(SetVolumeIntentHandler()) sb.add_request_handler(PreviousIntentHandler()) sb.add_request_handler(NextIntentHandler()) sb.add_request_handler(RestartIntentHandler()) sb.add_request_handler(PlayTrailerIntentHandler()) sb.add_request_handler(PlayOnAppIntentHandler())
# -*- coding: utf-8 -*- from ask_sdk_core.skill_builder import CustomSkillBuilder from handlers import * import utils # The SkillBuilder object 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 = CustomSkillBuilder(persistence_adapter=utils.s3_adapter()) sb.add_request_handler(LaunchRequestHandler()) sb.add_request_handler(RegisterPressureIntentHandler()) sb.add_request_handler(ReadLastPressureIntentHandler()) sb.add_request_handler(RemoveLastPressureIntentHandler()) sb.add_request_handler(EditLastPressureIntentHandler()) sb.add_request_handler(ReportLatestPressuresIntentHandler()) sb.add_request_handler(AddReminderIntentHandler()) # sb.add_request_handler(RemoveReminderIntentHandler()) sb.add_request_handler(HelpIntentHandler()) sb.add_request_handler(CancelOrStopIntentHandler()) sb.add_request_handler(SessionEndedRequestHandler()) # make sure IntentReflectorHandler is last so it doesn't override your custom intent handlers sb.add_request_handler(IntentReflectorHandler()) sb.add_exception_handler(CatchAllExceptionHandler()) lambda_handler = sb.lambda_handler()
from datetime import datetime from pytz import timezone import gettext from alexa import data from ask_sdk_s3.adapter import S3Adapter from ask_sdk_core.skill_builder import CustomSkillBuilder from ask_sdk_core.dispatch_components import (AbstractRequestHandler, AbstractExceptionHandler, AbstractRequestInterceptor, AbstractResponseInterceptor) from ask_sdk_core.utils import is_request_type, is_intent_name s3_adapter = S3Adapter(bucket_name="custom-walk-testing") sb = CustomSkillBuilder(persistence_adapter=s3_adapter) logger = logging.getLogger("main") logger.setLevel(logging.INFO) class LaunchRequestIntentHandler(AbstractRequestHandler): """ Handler for Skill Launch """ def can_handle(self, handler_input): return is_request_type("LaunchRequest")(handler_input) def handle(self, handler_input): _ = handler_input.attributes_manager.request_attributes["_"]
from ask_sdk_core.skill_builder import CustomSkillBuilder from ask_sdk_core.api_client import DefaultApiClient 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_model.services.directive import (SendDirectiveRequest, Header, SpeakDirective) from ask_sdk_core.handler_input import HandlerInput from ask_sdk_model.response import Response import time import logging sb = CustomSkillBuilder(api_client=DefaultApiClient()) logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) class LaunchRequestHandler(AbstractRequestHandler): # Handler for Skill Launch def can_handle(self, handler_input): # type: (HandlerInput) -> bool return is_request_type("LaunchRequest")(handler_input) def handle(self, handler_input): # type: (HandlerInput) -> Response speech_text = "Welcome to the Alexa Skills Kit, you can say hello!" handler_input.response_builder.speak(speech_text).set_card( SimpleCard("Hello World", speech_text)).set_should_end_session(False)
import requests import json import config import utils import language import trakt_api from ask_sdk_core.skill_builder import CustomSkillBuilder from ask_sdk_core.utils import is_request_type, is_intent_name, get_slot_value from ask_sdk_core.handler_input import HandlerInput # noqa: F401 from ask_sdk_model import Response # noqa: F401 from ask_sdk_s3.adapter import S3Adapter from datetime import datetime s3_adapter = S3Adapter(bucket_name=os.environ["S3_PERSISTENCE_BUCKET"]) sb = CustomSkillBuilder(persistence_adapter=s3_adapter) logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) watch_lists = ('watchlist', 'watch list') DATE_FORMAT = '%Y-%m-%d' clientid = config.client_id user = '******' is_auth = False @sb.request_handler(can_handle_func=lambda input: is_request_type("LaunchRequest")(input) or is_intent_name("AddMovie")(input)) def add_movie_intent_handler(handler_input): """Handler for Add Movie Intent."""
class RepeatInterceptor(AbstractResponseInterceptor): def process(self, handler_input, response): session_attributes = handler_input.attributes_manager.session_attributes session_attributes["repeat_speech_output"] = response.output_speech.ssml.replace("<speak>","").replace("</speak>","") try: session_attributes["repeat_reprompt"] = response.reprompt.output_speech.ssml.replace("<speak>","").replace("</speak>","") except: session_attributes["repeat_reprompt"] = response.output_speech.ssml.replace("<speak>","").replace("</speak>","") # Skill Builder # Define a skill builder instance and add all the request handlers, # exception handlers and interceptors to it. sb = CustomSkillBuilder (persistence_adapter = s3_adapter) sb.add_request_handler(InvalidConfigHandler()) sb.add_request_handler(LaunchRequestHandler()) sb.add_request_handler(MyNameIsIntentHandler()) sb.add_request_handler(LearnMoreIntentHandler()) sb.add_request_handler(YesNoIntentHandler()) sb.add_request_handler(RepeatIntentHandler()) sb.add_request_handler(CancelOrStopIntentHandler()) sb.add_request_handler(HelpIntentHandler()) sb.add_request_handler(FallbackIntentHandler()) sb.add_request_handler(SessionEndedRequesthandler()) sb.add_exception_handler(CatchAllExceptionHandler()) sb.add_global_request_interceptor(LocalizationInterceptor()) sb.add_global_request_interceptor(InvalidConfigInterceptor())
"""Log the request envelope.""" def process(self, handler_input): # type: (HandlerInput) -> None logger.info('Request recieved: {}'.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 generated: {}'.format(response)) # Skillbuilder sb = CustomSkillBuilder(api_client=DefaultApiClient()) # Custom sb.add_request_handler(createWorkoutAPIHandler()) sb.add_request_handler(GetRecommendationAPIHandler()) sb.add_request_handler(GetDescriptionAPIHandler()) # Standard sb.add_request_handler(SessionEndedRequestHandler()) # Exceptions sb.add_exception_handler(CatchAllExceptionHandler()) # Loggers sb.add_global_request_interceptor(RequestLogger()) sb.add_global_response_interceptor(ResponseLogger())
from flask import Flask from flask_ask_sdk.skill_adapter import SkillAdapter import Utils import data logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) user_slot = "userName" medicine_slot = "medicine" REQUIRED_PERMISSIONS = ["alexa::alerts:reminders:skill:readwrite"] TIME_ZONE_ID = "Asia/Kolkata" app = Flask(__name__) sb = CustomSkillBuilder(api_client=DefaultApiClient()) class LaunchRequestHandler(AbstractRequestHandler): """Launch Request Handler""" def can_handle(self, handler_input): # type: (HandlerInput) -> bool return ask_utils.is_request_type("LaunchRequest")(handler_input) def handle(self, handler_input): # type: (HandlerInput) -> Response _ = handler_input.attributes_manager.request_attributes["_"] speak_output = data.launch_welcome_message return (handler_input.response_builder.speak(speak_output).response)
"""Generic error handling to capture any syntax or routing errors. If you receive an error stating the request handler chain is not found, you have not implemented a handler for the intent being invoked or included it in the skill builder below.""" class CatchAllExceptionHandler(AbstractExceptionHandler): def can_handle(self, handler_input, exception): # type: (HandlerInput, Exception) -> bool return True def handle(self, handler_input, exception): # type: (HandlerInput, Exception) -> Response logger.error(exception, exc_info=True) return handler_input.response_builder.speak(data.ISSUE_MESSAGE).ask(data.ISSUE_MESSAGE).response #Processed top to bottom sb = CustomSkillBuilder(persistence_adapter=s3_adapter)#SkillBuilder() sb.add_request_handler(LaunchRequestHandler()) sb.add_request_handler(CaptureQuestionTypeIntentHandler()) sb.add_request_handler(RepeatQIntentHandler()) sb.add_request_handler(GetAnswerIntentHandler()) sb.add_request_handler(CaptureUserAnswerIntent()) #sb.add_request_handler(CaptureGradeLevelIntentHandler()) sb.add_request_handler(HelpIntentHandler()) sb.add_request_handler(CancelOrStopIntentHandler()) sb.add_request_handler(SessionEndedRequestHandler()) sb.add_request_handler(IntentReflectorHandler()) # make sure IntentReflectorHandler is last so it doesn't override your custom intent handlers sb.add_exception_handler(CatchAllExceptionHandler()) lambda_handler = sb.lambda_handler()
language_data = json.load(language_prompts) # set default translation data to broader translation data = language_data[skill_locale[:2]] # if a more specialized translation exists, then select it instead # example: "fr-CA" will pick "fr" translations first, but if "fr-CA" translation exists, # then pick that instead if skill_locale in language_data: data.update(language_data[skill_locale]) handler_input.attributes_manager.request_attributes["_"] = data # configure the runtime to treat time according to the skill locale skill_locale = skill_locale.replace('-', '_') locale.setlocale(locale.LC_TIME, skill_locale) sb = CustomSkillBuilder(persistence_adapter=s3_adapter) sb.add_request_handler(LaunchRequestHandler()) sb.add_request_handler(MeditationIntentHandler()) sb.add_request_handler(MedicationIntentHandler()) sb.add_request_handler(CheckMedicationIntentHandler()) sb.add_request_handler(HelpIntentHandler()) sb.add_request_handler(PanicAttackIntentHandler()) sb.add_request_handler(YesIntentHandler()) sb.add_request_handler(NoIntentHandler()) sb.add_request_handler(ResourcesIntentHandler()) sb.add_request_handler(CancelOrStopIntentHandler()) sb.add_request_handler(SessionEndedRequestHandler()) sb.add_request_handler( IntentReflectorHandler() ) # make sure IntentReflectorHandler is last so it doesn’t override your custom intent handlers
def handle(self, handler_input, exception): # type: (HandlerInput, Exception) -> Response logger.error(exception, exc_info=True) return ( handler_input.response_builder .speak("Uh Oh. Looks like something went wrong.") .ask("Uh Oh. Looks like something went wrong.") .response ) # The SkillBuilder object 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 = CustomSkillBuilder(api_client=DefaultApiClient()) sb.add_request_handler(LaunchRequestHandler()) sb.add_request_handler(TimerIntentHandler()) sb.add_request_handler(AcceptGrantResponseHandler()) sb.add_request_handler(ConnectionsResponsehandler()) sb.add_request_handler(SessionResumedHandlerRequest()) sb.add_request_handler(CancelOrStopIntentHandler()) sb.add_request_handler(SessionEndedRequestHandler()) # Adding Request and Response interceptor sb.add_global_request_interceptor(LoggingRequestInterceptor()) sb.add_global_response_interceptor(LoggingResponseInterceptor()) handler = sb.lambda_handler()
from ask_sdk_model.interfaces.display import (ImageInstance, Image, RenderTemplateDirective, ListTemplate1, BackButtonBehavior, ListItem, BodyTemplate2, BodyTemplate1) from ask_sdk_model import ui, Response, DialogState from ask_sdk_model.ui import SimpleCard from ask_sdk_model.dialog import ElicitSlotDirective, DelegateDirective from ask_sdk_model import (Intent, IntentConfirmationStatus, Slot, SlotConfirmationStatus) from ask_sdk_model.slu.entityresolution.resolution import Resolution from ask_sdk_model.slu.entityresolution import StatusCode from alexa import data, util sb = CustomSkillBuilder(persistence_adapter=s3_adapter) # Set the skill id so not just anyone can invoke this function sb.skill_id = "amzn1.ask.skill.92878a4c-6715-4eed-9b71-7805480315a0" gravIntent = Intent() calIntent = Intent(name="CalibrateIntent") logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) class LaunchRequestHandler(AbstractRequestHandler): """Determine if this is a Launch Request.""" def can_handle(self, handler_input): # type: (HandlerInput) -> bool
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() # ################################################################### # The SkillBuilder object 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. s3_adapter = S3Adapter(bucket_name=os.environ["S3_PERSISTENCE_BUCKET"]) sb = CustomSkillBuilder(persistence_adapter=s3_adapter,api_client=DefaultApiClient()) # ############# 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(TodayIntentHandler()) sb.add_request_handler(playAudioIntentHandler()) sb.add_request_handler(qayaamIntentHandler()) sb.add_request_handler(rozaNiyatIntentHandler()) sb.add_request_handler(moharramIntentHandler()) sb.add_request_handler(NamaazTimesIntentHandler())
import logging from ask_sdk_core.skill_builder import CustomSkillBuilder from ask_sdk_core.api_client import DefaultApiClient from ask_sdk_core.dispatch_components import AbstractRequestHandler from ask_sdk_core.dispatch_components import AbstractExceptionHandler from ask_sdk_core.dispatch_components import AbstractResponseInterceptor from ask_sdk_core.dispatch_components import AbstractRequestInterceptor from ask_sdk_core.handler_input import HandlerInput from ask_sdk_model import Response from ask_sdk_core.exceptions import AskSdkException import ask_sdk_core.utils as ask_utils from handlers.exports import request_handlers from interceptors import LoggingRequestInterceptor, LoggingResponseInterceptor from handlers.core.errorhandlers import CatchAllExceptionHandler sb = CustomSkillBuilder(api_client=DefaultApiClient()) for h in request_handlers: sb.add_request_handler(h) sb.add_exception_handler(CatchAllExceptionHandler()) sb.add_global_response_interceptor(LoggingResponseInterceptor()) sb.add_global_request_interceptor(LoggingRequestInterceptor()) # This is the exported entry point. lambda_handler = sb.lambda_handler()
from ask_sdk_dynamodb.adapter import DynamoDbAdapter from ask_sdk_dynamodb.adapter import DynamoDbAdapter from ask_sdk_model import Response logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) ddb_region = os.environ.get('DYNAMODB_PERSISTENCE_REGION') ddb_table_name = os.environ.get('DYNAMODB_PERSISTENCE_TABLE_NAME') ddb_resource = boto3.resource('dynamodb', region_name=ddb_region) dynamodb_adapter = DynamoDbAdapter(table_name=ddb_table_name, create_table=False, dynamodb_resource=ddb_resource) sb = CustomSkillBuilder(persistence_adapter=dynamodb_adapter) TOKEN = "Removed Upon Request" USER = "******" class PromptQuestionHandler(AbstractRequestHandler): """Handler for Skill Launch and PromptQuestion Intent.""" def can_handle(self, handler_input): # type: (HandlerInput) -> bool return (is_request_type("LaunchRequest")(handler_input) or is_intent_name("PromptQuestion")(handler_input)) def handle(self, handler_input): # type: (HandlerInput) -> Response logger.info("In PromptQuestionHandler")
# type: (HandlerInput, Exception) -> bool return True def handle(self, handler_input, exception): # type: (HandlerInput, Exception) -> Response logger.error(exception, exc_info=True) speak_output = "すみません、何か上手くいかないみたいです。もう一度試してください。" return (handler_input.response_builder.speak(speak_output).ask( speak_output).response) sb = SkillBuilder() #sb = CustomSkillBuilder(persistence_adapter = s3_adapter) sb = CustomSkillBuilder(persistence_adapter=dynamodb_adapter) sb.add_request_handler(LaunchRequestHandler()) sb.add_request_handler(DiapersNoteIntentHandler()) sb.add_request_handler(InitialDiaperIntentHandler()) sb.add_request_handler(HelpIntentHandler()) sb.add_request_handler(CancelOrStopIntentHandler()) sb.add_request_handler(SessionEndedRequestHandler()) sb.add_request_handler( IntentReflectorHandler() ) # make sure IntentReflectorHandler is last so it doesn't override your custom intent handlers sb.add_exception_handler(CatchAllExceptionHandler()) lambda_handler = sb.lambda_handler()
# session persistence, api calls, and more. import requests import logging import calendar from datetime import datetime from pytz import timezone from ask_sdk_s3.adapter import S3Adapter from ask_sdk_core.skill_builder import CustomSkillBuilder from ask_sdk_core.dispatch_components import (AbstractRequestHandler, AbstractExceptionHandler) from ask_sdk_core.utils import is_request_type, is_intent_name s3_adapter = S3Adapter(bucket_name="custom-walk-testing") sb = CustomSkillBuilder(persistence_adapter=s3_adapter) logger = logging.getLogger("main") logger.setLevel(logging.INFO) class LaunchRequestIntentHandler(AbstractRequestHandler): """ Handler for Skill Launch """ def can_handle(self, handler_input): return is_request_type("LaunchRequest")(handler_input) def handle(self, handler_input): speech = "Hello! Welcome to Cake Time. What is your birthday?" reprompt = "I was born Nov. 6th, 2015. When were you born?"
from ask_sdk_core.utils import is_request_type, is_intent_name from ask_sdk_core.skill_builder import CustomSkillBuilder from ask_sdk_core.api_client import DefaultApiClient from ask_sdk_model.ui import SimpleCard from ask_sdk_model.ui import AskForPermissionsConsentCard from ask_sdk_model import Response from ask_sdk_model.permission_status import PermissionStatus from ask_sdk_model.services.service_exception import ServiceException from ask_sdk_model.canfulfill import CanFulfillIntent, CanFulfillIntentValues if getenv("ENVIRONMENT") in (None, "PROD"): aws_lambda_logging.setup(level="INFO") else: logging.basicConfig(level=logging.INFO) sb = CustomSkillBuilder(api_client=DefaultApiClient()) ERROR_TITLE = "Uh oh" ERROR = "Looks like something went wrong." NOTIFY_TITLE = "Permissions needed" NOTIFY_MISSING_ADDRESS_PERMISSIONS = ("Please enable Address permissions in " "the Amazon Alexa app.") NOTIFY_MISSING_LOCATION_PERMISSIONS = ("Please enable Location permissions in " "the Amazon Alexa app.") SWEET_TITLE = "Your Air Report" SWEET_CARD = ("I found an {}air sensor that's {} away. " "The air quality is {}. " "Your AQI is {}.") SWEET_SPEECH = (
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 metro_api.directions_api import get_train from metro_api import commands from ask_sdk_model import Response from ask_sdk_model.slu.entityresolution import StatusCode from ask_sdk_model.ui import SimpleCard, AskForPermissionsConsentCard from ask_sdk_model.services.reminder_management import Trigger, TriggerType, AlertInfo, SpokenInfo, SpokenText, \ PushNotification, PushNotificationStatus, ReminderRequest from ask_sdk_model.services import ServiceException import pytz from datetime import datetime sb = CustomSkillBuilder( api_client=DefaultApiClient()) # required to use remiders logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) REQUIRED_PERMISSIONS = [ "alexa::alerts:reminders:skill:readwrite", "read::alexa:device:all:address" ] # Request Handler classes class LaunchRequestHandler(AbstractRequestHandler): """Handler for skill launch.""" def can_handle(self, handler_input): # type: (HandlerInput) -> bool return is_request_type("LaunchRequest")(handler_input)
with open("languages/" + str(locale) + ".json") as language_data: language_prompts = json.load(language_data) except: with open("languages/" + str(locale[:2]) + ".json") as language_data: language_prompts = json.load(language_data) handler_input.attributes_manager.request_attributes[ "_"] = language_prompts # Skill Builder # Define a skill builder instance and add all the request handlers, # exception handlers and interceptors to it. sb = CustomSkillBuilder(persistence_adapter=dynamodb_adapter) sb.add_request_handler(CheckAudioInterfaceHandler()) sb.add_request_handler(LaunchRequestHandler()) sb.add_request_handler(PlayNewestEpisodeIntentHandler()) sb.add_request_handler(PlayOldestEpisodeIntentHandler()) sb.add_request_handler(ChooseEpisodeIntentHandler()) sb.add_request_handler(PauseIntentHandler()) sb.add_request_handler(ResumeIntentHandler()) sb.add_request_handler(NoIntentHandler()) sb.add_request_handler(NextIntentHandler()) sb.add_request_handler(PreviousIntentHandler()) sb.add_request_handler(RepeatIntentHandler()) sb.add_request_handler(ShuffleOnIntentHandler()) sb.add_request_handler(ShuffleOffIntentHandler()) sb.add_request_handler(LoopOnIntentHandler()) sb.add_request_handler(LoopOffIntentHandler())
from config import settings from handlers import game_play_handlers, global_handlers, start_handlers, roll_call_handlers ENV = os.environ.get('ENV') adapter_config = { "table_name": settings.STORAGE['session_table'], "create_table": ENV == 'DEV', } if ENV == 'DEV': localhost = 'http://localhost:8000' adapter_config["dynamodb_resource"] = boto3.resource("dynamodb", endpoint_url=localhost) else: adapter_config["dynamodb_resource"] = boto3.resource("dynamodb") sb = CustomSkillBuilder(persistence_adapter=DynamoDbAdapter(**adapter_config)) sb.skill_id = settings.APP_ID sb.add_request_handler(game_play_handlers.AnswerHandler()) sb.add_request_handler(game_play_handlers.DontKnowNextHandler()) sb.add_request_handler(game_play_handlers.GameEventHandler()) sb.add_request_handler(game_play_handlers.PlayGameHandler()) sb.add_request_handler(game_play_handlers.EndGameHandler()) sb.add_request_handler(game_play_handlers.YesHandler()) sb.add_request_handler(roll_call_handlers.YesHandler()) sb.add_request_handler(roll_call_handlers.NoHandler()) sb.add_request_handler(roll_call_handlers.GameEventHandler()) sb.add_request_handler(start_handlers.PlayerCountHandler()) sb.add_request_handler(start_handlers.YesHandler()) sb.add_request_handler(start_handlers.NoHandler()) sb.add_request_handler(start_handlers.LaunchPlayGameHandler())