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())
