def test_get_attributes_from_existing_bucket_get_object_fails(self):
self.object_keygen.return_value = "test_object_key"
self.s3_client.get_object.read.side_effect = Exception("test exception")
test_s3_adapter = S3Adapter(bucket_name=self.bucket_name, path_prefix=self.bucket_key,
s3_client=self.s3_client, object_keygen=self.object_keygen)
with self.assertRaises(PersistenceException) as exc:
test_s3_adapter.get_attributes(request_envelope=self.request_envelope)
def test_get_attributes_from_existing_bucket_get_object_null_returns_no_item(self):
self.object_keygen.return_value = "test_object_key"
mock_object = {"Body": None}
self.s3_client.get_object = mock.MagicMock(return_value=mock_object)
test_s3_adapter = S3Adapter(bucket_name=self.bucket_name, path_prefix=self.bucket_key,
s3_client=self.s3_client, object_keygen=self.object_keygen)
result = test_s3_adapter.get_attributes(request_envelope=self.request_envelope)
self.assertEquals({}, result)
def test_save_attributes_to_existing_bucket_put_item_fails(self):
self.object_keygen.return_value = "test_object_key"
self.s3_client.put_object.side_effect = Exception("test exception")
test_s3_adapter = S3Adapter(bucket_name=self.bucket_name, path_prefix=self.bucket_key,
s3_client=self.s3_client, object_keygen=self.object_keygen)
with self.assertRaises(PersistenceException) as exc:
test_s3_adapter.save_attributes(request_envelope=self.request_envelope, attributes=_MOCK_DATA)
def test_get_attributes_resource_not_exist_fails(self):
self.object_keygen.return_value = "test_object_key"
self.s3_client.get_object.side_effect = ResourceNotExistsError("resource does not exist",
self.bucket_key, self.bucket_name)
test_s3_adapter = S3Adapter(bucket_name=self.bucket_name, path_prefix=self.bucket_key,
s3_client=self.s3_client, object_keygen=self.object_keygen)
with self.assertRaises(PersistenceException) as exc:
test_s3_adapter.get_attributes(request_envelope=self.request_envelope)
def test_get_attributes_from_existing_bucket_get_object_invalid_json_fails(self):
self.object_keygen.return_value = "test_object_key"
mock_object = {"Body": MockMalformedData()}
self.s3_client.get_object = mock.MagicMock(return_value=mock_object)
test_s3_adapter = S3Adapter(bucket_name=self.bucket_name, path_prefix=self.bucket_key,
s3_client=self.s3_client, object_keygen=self.object_keygen)
with self.assertRaises(PersistenceException) as exc:
test_s3_adapter.get_attributes(request_envelope=self.request_envelope)
def test_save_attributes_fails_with_no_existing_bucket(self):
self.object_keygen.return_value = "test_object_key"
test_s3_adapter = S3Adapter(bucket_name=self.bucket_name, path_prefix=self.bucket_key,
s3_client=self.s3_client, object_keygen=self.object_keygen)
self.s3_client.put_object.side_effect = ResourceNotExistsError("resource does not exist",
self.bucket_key, self.bucket_name)
with self.assertRaises(PersistenceException) as exc:
test_s3_adapter.save_attributes(request_envelope=self.request_envelope, attributes=_MOCK_DATA)
def test_delete_attributes_to_existing_bucket(self):
self.object_keygen.return_value = "test_object_key"
test_s3_adapter = S3Adapter(bucket_name=self.bucket_name, path_prefix=self.bucket_key,
s3_client=self.s3_client, object_keygen=self.object_keygen)
test_s3_adapter.delete_attributes(request_envelope=self.request_envelope)
self.object_keygen.assert_called_once_with(self.request_envelope)
self.s3_client.delete_object.assert_called_once_with(
Bucket=self.bucket_name,
Key=os.path.join("test_key", "test_object_key"))
def test_get_attributes_from_existing_bucket_no_prefix(self):
self.object_keygen.return_value = "test_object_key"
mock_object = {"Body": MockData()}
self.s3_client.get_object = mock.MagicMock(return_value=mock_object)
test_s3_adapter = S3Adapter(bucket_name=self.bucket_name, path_prefix=None,
s3_client=self.s3_client, object_keygen=self.object_keygen)
result = test_s3_adapter.get_attributes(request_envelope=self.request_envelope)
self.assertEquals(_MOCK_DATA, result)
self.s3_client.get_object.assert_called()
def test_save_attributes_to_existing_bucket(self):
self.object_keygen.return_value = "test_object_key"
json_data = json.dumps(_MOCK_DATA)
generated_key = os.path.join("test_key", "test_object_key")
test_s3_adapter = S3Adapter(bucket_name=self.bucket_name, path_prefix=self.bucket_key,
s3_client=self.s3_client, object_keygen=self.object_keygen)
test_s3_adapter.save_attributes(request_envelope=self.request_envelope, attributes=_MOCK_DATA)
self.object_keygen.assert_called_once_with(self.request_envelope)
self.s3_client.put_object.assert_called_once_with(Body=json_data,
Bucket=self.bucket_name,
Key=generated_key)
# -*- coding: utf-8 -*-
# This sample demonstrates handling intents from an Alexa skill using the Alexa Skills Kit SDK for Python.
# Please visit https://alexa.design/cookbook for additional examples on implementing slots, dialog management,
# session persistence, api calls, and more.
# This sample is built using the handler classes approach in skill builder.
import logging
import ask_sdk_core.utils as ask_utils
import os
from ask_sdk_s3.adapter import S3Adapter
s3_adapter = S3Adapter(bucket_name="NAME_OF_YOUR_BUCKET_HERE")
from ask_sdk_core.skill_builder import CustomSkillBuilder
from ask_sdk_core.dispatch_components import AbstractRequestHandler
from ask_sdk_core.dispatch_components import AbstractExceptionHandler
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_model import Response
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 ask_utils.is_request_type("LaunchRequest")(handler_input)
def handle(self, handler_input):
# implementing slots, dialog management,
# 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?"
import json
import logging
import os
import boto3
# Use an S3 repository bucket to save slot values
from ask_sdk_s3.adapter import S3Adapter
# Set up the bucket adapter so that we can interact with the repository
bucket_name = "gravresponse"
s3_client = boto3.client('s3',
config=boto3.session.Config(
signature_version='s3v4',
s3={'addressing_style': 'path'}))
s3_adapter = S3Adapter(bucket_name=bucket_name,
path_prefix=None,
s3_client=s3_client)
# We need the CustomSkillBuilder in order to access the S3 repository
from ask_sdk_core.skill_builder import CustomSkillBuilder
from ask_sdk_core.handler_input import HandlerInput
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_intent_name, is_request_type
from ask_sdk_core.response_helper import (get_plain_text_content,
get_rich_text_content)
from ask_sdk_model.interfaces.display import (ImageInstance, Image,
BuyIntent,
DonIntent,
DoffIntent,
AttackIntent,
GoInCharacterIntent,
)
from core.interceptors import LoggingRequestInterceptor
from ask_sdk_core.view_resolvers import FileSystemTemplateLoader
from ask_sdk_jinja_renderer import JinjaTemplateRenderer
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
logger.debug("Initializing")
storage = S3Adapter(
bucket_name=
"amzn1-ask-skill-59314ad7-6f29-buildsnapshotbucket-1m7jwign3zu2z")
sb = CustomSkillBuilder(persistence_adapter=storage)
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(MoveIntentHandler())
sb.add_request_handler(LookIntentHandler())
sb.add_request_handler(CharUpdateIntent())
sb.add_request_handler(CheckInventoryIntent())
sb.add_request_handler(GetIntent())
sb.add_request_handler(DropIntent())
sb.add_request_handler(ListIntent())
sb.add_request_handler(SellIntent())
sb.add_request_handler(BuyIntent())
sb.add_request_handler(DonIntent())
sb.add_request_handler(DoffIntent())
import boto3
from ask_sdk_core.skill_builder import CustomSkillBuilder, SkillBuilder
from ask_sdk_s3.adapter import S3Adapter
##########
# S3 adapter setup
##########
skill_s3_client = boto3.client('s3')
skill_bucket_name = os.environ['bucket_name']
skill_prefix = "users/"
skill_s3_adapter = S3Adapter(
bucket_name=skill_bucket_name,
path_prefix=skill_prefix,
s3_client=skill_s3_client,
)
##########
# Imports
##########
from interceptors.cache_prompt import CacheRepromptInterceptor
from interceptors.cache_response_int import CacheResponseForRepeatInterceptor
from interceptors.launch_intercept import LaunchRequestInterceptor
from exit_skill.handler import ExitHandler, SessionEndedRequestHandler, StopActivity
from fallback.handler import FallbackHandler
from helper.handler import HelpHandler
from launch.handlers import LaunchRequestHandler
import os
import boto3
from ask_sdk_s3.adapter import S3Adapter
from ask_sdk_core.skill_builder import CustomSkillBuilder
bucket_region = os.environ.get('BUCKET_REGION')
bucket_name = os.environ.get('BUCKET_NAME')
s3_client = boto3.client('s3', region_name=bucket_region)
s3_adapter = S3Adapter(bucket_name,
path_prefix='gods_oracle/persistent_attributes',
s3_client=s3_client)
sb = CustomSkillBuilder(persistence_adapter=s3_adapter)
# -*- coding: utf-8 -*-
# This sample demonstrates handling intents from an Alexa skill using the Alexa Skills Kit SDK for Python.
# Please visit https://alexa.design/cookbook for additional examples on implementing slots, dialog management,
# session persistence, api calls, and more.
# This sample is built using the handler classes approach in skill builder.
import logging
import ask_sdk_core.utils as ask_utils
import os
import requests
import calendar
from datetime import datetime
from pytz import timezone
from ask_sdk_s3.adapter import S3Adapter
s3_adapter = S3Adapter(bucket_name=os.environ["INSERT_YOUR_BUCKET_NAME_HERE"])
from ask_sdk_core.skill_builder import CustomSkillBuilder
from ask_sdk_core.dispatch_components import AbstractRequestHandler
from ask_sdk_core.dispatch_components import AbstractExceptionHandler
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_model import Response
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
class LaunchRequestHandler(AbstractRequestHandler):
"""Handler for Skill Launch."""
def can_handle(self, handler_input):
# type: (HandlerInput) -> bool
def s3_adapter():
return S3Adapter(s3_bucket_name(), s3_client=s3_client())
import os
import boto3
from ask_sdk_s3.adapter import S3Adapter
from ask_sdk_core.skill_builder import CustomSkillBuilder
# ask persistence adapterの読み込み
from ask_sdk_core.skill_builder import CustomSkillBuilder
from ask_sdk_dynamodb.adapter import DynamoDbAdapter
# 永続性アダプターを初期化
## S3
bucket_region = os.environ.get('S3_PERSISTENCE_REGION')
bucket_name = os.environ.get('S3_PERSISTENCE_BUCKET')
s3_client = boto3.client('s3', region_name=bucket_region)
s3_adapter = S3Adapter(bucket_name, s3_client=s3_client)
## DynamoDB
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)
import line_function
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
import os
import json
import prompts
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,
AbstractRequestInterceptor,
AbstractResponseInterceptor)
from ask_sdk_core.utils import is_request_type, is_intent_name
s3_adapter = S3Adapter(bucket_name=os.environ.get('S3_PERSISTENCE_BUCKET'))
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):
data = handler_input.attributes_manager.request_attributes["_"]
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_s3.adapter import S3Adapter
SKILL_NAME = 'Cookie'
USER_NAME = 'user'
bucket_name = os.environ.get('S3_PERSISTENCE_BUCKET')
s3_client = boto3.client('s3',
region_name=os.environ.get('S3_PERSISTENCE_REGION'),
config=boto3.session.Config(
signature_version='s3v4',
s3={'addressing_style': 'path'}))
s3_adapter = S3Adapter(bucket_name=bucket_name,
path_prefix="Media",
s3_client=s3_client)
sb = CustomSkillBuilder(persistence_adapter=s3_adapter)
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
# -*- coding: utf-8 -*-
#IMPORTS =================================================================================================================
import logging
import json
import ask_sdk_core.utils as ask_utils
import os
import random #for random questioning - Dalton
from ask_sdk_s3.adapter import S3Adapter
s3_adapter = S3Adapter(bucket_name=os.environ["S3_PERSISTENCE_BUCKET"]) #For storing information between intents - Dalton
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, viewport
from ask_sdk_core.response_helper import get_plain_text_content #new
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_model.ui import SimpleCard
from ask_sdk_model.ui import StandardCard
from ask_sdk_model import Response
from ask_sdk_model.interfaces.display import (ImageInstance, Image, RenderTemplateDirective, BackButtonBehavior, BodyTemplate1, BodyTemplate2) #new
from ask_sdk_model import ui # new
from ask_sdk_core.utils import get_supported_interfaces #new
from ask_sdk_model.interfaces.alexa.presentation.apl import (
RenderDocumentDirective, ExecuteCommandsDirective, SpeakItemCommand,
AutoPageCommand, HighlightMode)
from typing import Dict, Any
# This sample demonstrates handling intents from an Alexa skill and using the
# Alexa Skills Kid SDK (v2)
# Please visit https://alexa.design/cookbook for additional examples on
# implementing slots, dialog management,
# session persistence, api calls, and more.
import logging
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="S3-BUCKET-NAME")
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):
speak_output = "Hello! This is Cake walk. What is your birthday?"
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.
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())
import boto3
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.handler_input import HandlerInput
from ask_sdk.standard import StandardSkillBuilder
from ask_sdk_model import Response
from ask_sdk_s3.adapter import S3Adapter
from ask_sdk_core.skill_builder import CustomSkillBuilder
s3_client = boto3.client('s3')
s3_adapter = S3Adapter(
bucket_name=
"amzn1-ask-skill-442eae5e-f577-buildsnapshotbucket-16fh383r9srj1",
s3_client=s3_client)
sb = CustomSkillBuilder(persistence_adapter=s3_adapter)
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 ask_utils.is_request_type("LaunchRequest")(handler_input)
def handle(self, handler_input):
import os
import logging
import ask_sdk_core.utils as ask_utils
import random
from ask_sdk_core.skill_builder import CustomSkillBuilder
from ask_sdk_core.dispatch_components import AbstractRequestHandler
from ask_sdk_core.dispatch_components import AbstractExceptionHandler
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_model import Response
from ask_sdk_s3.adapter import S3Adapter
from RouleteHandler import RouleteHandler
s3_adapter = S3Adapter(bucket_name=os.environ["S3_PERSISTENCE_BUCKET"])
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 ask_utils.is_request_type("LaunchRequest")(handler_input)
def handle(self, handler_input):
# type: (HandlerInput) -> Response
speak_output = "Welcome, you can say Hello or Help. Which would you like to try?"
return (handler_input.response_builder.speak(speak_output).ask(
# -*- coding: utf-8 -*-
import logging
import ask_sdk_core.utils as ask_utils
from ask_sdk_core.skill_builder import SkillBuilder
from ask_sdk_core.skill_builder import CustomSkillBuilder
from ask_sdk_core.dispatch_components import AbstractRequestHandler
from ask_sdk_core.dispatch_components import AbstractExceptionHandler
from ask_sdk_core.handler_input import HandlerInput
from ask_sdk_model import Response
from ask_sdk_s3.adapter import S3Adapter
s3_adapter = S3Adapter(bucket_name="martinig-alexathon")
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
class HasBirthdayLaunchRequestHandler(AbstractRequestHandler):
"""Handler for launch after they have set their birthday"""
def can_handle(self, handler_input):
# extract persistent attributes and check if they are all present
attr = handler_input.attributes_manager.persistent_attributes
attributes_are_present = ("ano" in attr and "mes" in attr
and "dia" in attr)
return attributes_are_present and ask_utils.is_request_type(
"LaunchRequest")(handler_input)
def handle(self, handler_input):
