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