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")
def setup_skill_builder(service: OpenDataService) -> CustomSkillBuilder: """Helper method to create the custom skill builder instance.""" logger.info({ "operation": "Setting up Custom Skill Builder with Dynamo DB persistence adapter", "dynamo_db_table_name": DYNAMO_DB_TABLE_NAME, }) dynamo_db_adapter = DynamoDbAdapter( table_name=DYNAMO_DB_TABLE_NAME, partition_key_name="id", attribute_name="attributes", create_table=True, dynamodb_resource=resource("dynamodb"), ) skill_builder = CustomSkillBuilder(persistence_adapter=dynamo_db_adapter) logger.info("Adding skill request handlers...") skill_builder.add_request_handler(LaunchRequestHandler()) skill_builder.add_request_handler(SaveTripPreferencesHandler()) skill_builder.add_request_handler(GetArrivalTimesNoPrefsIntentHandler()) skill_builder.add_request_handler(GetArrivalTimesIntentHandler(service)) skill_builder.add_request_handler(StartedInProgressFavoriteStopHandler()) skill_builder.add_request_handler(CompletedFavoriteStopHandler()) skill_builder.add_request_handler(StartedInProgressFavoriteLineHandler()) skill_builder.add_request_handler(CompletedFavoriteLineHandler(service)) skill_builder.add_request_handler(YesIntentHandler()) skill_builder.add_request_handler(NoIntentHandler()) skill_builder.add_request_handler(HelpIntentHandler()) skill_builder.add_request_handler(CancelOrStopIntentHandler()) skill_builder.add_request_handler(RepeatHandler()) skill_builder.add_request_handler(FallBackHandler()) skill_builder.add_request_handler(SessionEndedRequestHandler()) skill_builder.add_request_handler(IntentReflectorHandler()) logger.info("Adding skill exception handlers...") skill_builder.add_exception_handler(OpenDataAPIExceptionHandler()) skill_builder.add_exception_handler(GenericExceptionHandler()) logger.info("Adding skill request interceptors...") skill_builder.add_global_request_interceptor(LocalizationInterceptor()) skill_builder.add_global_request_interceptor(RequestLoggerInterceptor()) logger.info("Adding skill response interceptors...") skill_builder.add_global_response_interceptor(ResponseLoggerInterceptor()) tracer.put_annotation("SKILL_SETUP", "SUCCESS") tracer.put_metadata(key="environment", value=ENVIRONMENT.upper()) return skill_builder
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())
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()
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 = (
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["_"]
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)
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())
# -*- 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 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())