예제 #1
0
# defined are included below. The order matters - they're processed top to bottom.


@app.route('/ddog/webhook')
def alert(payload):
    return payload


sb = SkillBuilder()

sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(GetMetricsIntentHandler())
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_global_request_interceptor(LocalizationInterceptor())

sb.add_exception_handler(CatchAllExceptionHandler())

skill_response = SkillAdapter(
    skill=sb.create(),
    skill_id="amzn1.ask.skill.1fd6a485-84ff-406c-aba1-75007ce3df11",
    app=app)

skill_response.register(app=app, route="/")
if __name__ == '__main__':
    app.run()
예제 #2
0
class TestSkillBuilder(unittest.TestCase):
    def setUp(self):
        self.sb = SkillBuilder()

    def test_add_null_request_handler_throw_error(self):
        with self.assertRaises(SkillBuilderException) as exc:
            self.sb.add_request_handler(request_handler=None)

        assert "Valid Request Handler instance to be provided" in str(
            exc.exception
        ), ("Add Request Handler method didn't throw exception when a null "
            "request handler is added")

    def test_add_invalid_request_handler_throw_error(self):
        invalid_request_handler = mock.Mock()

        with self.assertRaises(SkillBuilderException) as exc:
            self.sb.add_request_handler(
                request_handler=invalid_request_handler)

        assert "Input should be a RequestHandler instance" in str(
            exc.exception), (
                "Add Request Handler method didn't throw exception when an "
                "invalid request handler is added")

    def test_add_valid_request_handler(self):
        mock_request_handler = mock.MagicMock(spec=AbstractRequestHandler)

        self.sb.add_request_handler(request_handler=mock_request_handler)

        assert self.sb.request_handlers[0] == mock_request_handler, (
            "Add Request Handler method didn't add valid request handler to "
            "Skill Builder Request Handlers list")

    def test_add_null_exception_handler_throw_error(self):
        with self.assertRaises(SkillBuilderException) as exc:
            self.sb.add_exception_handler(exception_handler=None)

        assert "Valid Exception Handler instance to be provided" in str(
            exc.exception
        ), ("Add Exception Handler method didn't throw exception when a null "
            "exception handler is added")

    def test_add_invalid_exception_handler_throw_error(self):
        invalid_exception_handler = mock.Mock()

        with self.assertRaises(SkillBuilderException) as exc:
            self.sb.add_exception_handler(
                exception_handler=invalid_exception_handler)

        assert "Input should be an ExceptionHandler instance" in str(
            exc.exception), (
                "Add Exception Handler method didn't throw exception when an "
                "invalid exception handler is added")

    def test_add_valid_exception_handler(self):
        mock_exception_handler = mock.MagicMock(spec=AbstractExceptionHandler)

        self.sb.add_exception_handler(exception_handler=mock_exception_handler)

        assert self.sb.exception_handlers[0] == mock_exception_handler, (
            "Add Exception Handler method didn't add valid exception handler "
            "to Skill Builder Exception Handlers list")

    def test_add_null_global_request_interceptor_throw_error(self):
        with self.assertRaises(SkillBuilderException) as exc:
            self.sb.add_global_request_interceptor(request_interceptor=None)

        assert "Valid Request Interceptor instance to be provided" in str(
            exc.exception), (
                "Add Global Request Interceptor method didn't throw exception "
                "when a null request interceptor is added")

    def test_add_invalid_global_request_interceptor_throw_error(self):
        invalid_request_interceptor = mock.Mock()

        with self.assertRaises(SkillBuilderException) as exc:
            self.sb.add_global_request_interceptor(
                request_interceptor=invalid_request_interceptor)

        assert "Input should be a RequestInterceptor instance" in str(
            exc.exception), (
                "Add Global Request Interceptor method didn't throw exception "
                "when an invalid request interceptor is added")

    def test_add_valid_global_request_interceptor(self):
        mock_request_interceptor = mock.MagicMock(
            spec=AbstractRequestInterceptor)

        self.sb.add_global_request_interceptor(
            request_interceptor=mock_request_interceptor)

        assert self.sb.global_request_interceptors[0] == \
               mock_request_interceptor, (
            "Add Global Request Interceptor method didn't add valid request "
            "interceptor to Skill Builder "
            "Request Interceptors list")

    def test_add_null_global_response_interceptor_throw_error(self):
        with self.assertRaises(SkillBuilderException) as exc:
            self.sb.add_global_response_interceptor(response_interceptor=None)

        assert "Valid Response Interceptor instance to be provided" in str(
            exc.exception
        ), ("Add Global Response Interceptor method didn't throw exception "
            "when a null response interceptor is added")

    def test_add_invalid_global_response_interceptor_throw_error(self):
        invalid_response_interceptor = mock.Mock()

        with self.assertRaises(SkillBuilderException) as exc:
            self.sb.add_global_response_interceptor(
                response_interceptor=invalid_response_interceptor)

        assert "Input should be a ResponseInterceptor instance" in str(
            exc.exception
        ), ("Add Global Response Interceptor method didn't throw exception "
            "when an invalid response interceptor "
            "is added")

    def test_add_valid_global_response_interceptor(self):
        mock_response_interceptor = mock.MagicMock(
            spec=AbstractResponseInterceptor)

        self.sb.add_global_response_interceptor(
            response_interceptor=mock_response_interceptor)

        assert self.sb.global_response_interceptors[0] == \
               mock_response_interceptor, (
            "Add Global Response Interceptor method didn't add valid response "
            "interceptor to Skill Builder "
            "Response Interceptors list")

    def test_skill_configuration_getter_no_registered_components(self):
        actual_config = self.sb.skill_configuration

        assert actual_config.request_mappers is not None, (
            "Skill Configuration getter in Skill Builder didn't set request "
            "mappers correctly")
        assert actual_config.request_mappers[
            0].request_handler_chains is not None, (
                "Skill Configuration getter in Skill Builder didn't set handler "
                "chains in request mappers correctly")
        assert len(
            actual_config.request_mappers[0].request_handler_chains) == 0, (
                "Skill Configuration getter in Skill Builder added invalid "
                "handler in handler chain, "
                "when no request handlers are registered")
        assert actual_config.handler_adapters is not None, (
            "Skill Configuration getter in Skill Builder didn't set handler "
            "adapters correctly")
        assert isinstance(actual_config.handler_adapters[0], HandlerAdapter), (
            "Skill Configuration getter in Skill Builder didn't set default "
            "handler adapter")
        assert actual_config.exception_mapper is None, (
            "Skill Configuration getter in Skill Builder created invalid "
            "exception mapper, "
            "when no exception handlers are registered")
        assert actual_config.request_interceptors == [], (
            "Skill Configuration getter in Skill Builder created invalid "
            "request interceptors, "
            "when no global request interceptors are registered")
        assert actual_config.response_interceptors == [], (
            "Skill Configuration getter in Skill Builder created invalid "
            "response interceptors, "
            "when no global response interceptors are registered")
        assert actual_config.custom_user_agent is None, (
            "Skill Configuration getter in Skill Builder set invalid custom "
            "user agent")
        assert actual_config.skill_id is None, (
            "Skill Configuration getter in Skill Builder set invalid skill id")

    def test_skill_configuration_getter_handlers_registered(self):
        mock_request_handler = mock.MagicMock(spec=AbstractRequestHandler)
        self.sb.add_request_handler(request_handler=mock_request_handler)

        mock_exception_handler = mock.MagicMock(spec=AbstractExceptionHandler)
        self.sb.add_exception_handler(exception_handler=mock_exception_handler)

        actual_config = self.sb.skill_configuration

        assert actual_config.request_mappers is not None, (
            "Skill Configuration getter in Skill Builder didn't set request "
            "mappers correctly")
        assert actual_config.request_mappers[
            0].request_handler_chains is not None, (
                "Skill Configuration getter in Skill Builder didn't set handler "
                "chains in request mappers correctly")
        assert len(
            actual_config.request_mappers[0].request_handler_chains) == 1, (
                "Skill Configuration getter in Skill Builder didn't add valid "
                "handler in handler chain, "
                "when request handlers are registered")
        assert actual_config.request_mappers[0].request_handler_chains[
            0].request_handler == mock_request_handler, (
                "Skill Configuration getter in Skill Builder added invalid "
                "handler in handler chain, "
                "when request handlers are registered")

        assert actual_config.exception_mapper is not None, (
            "Skill Configuration getter in Skill Builder didn't create "
            "exception mapper, "
            "when exception handlers are registered")
        assert len(actual_config.exception_mapper.exception_handlers) == 1, (
            "Skill Configuration getter in Skill Builder added additional "
            "exception handlers than the registered ones "
            "in exception mapper")
        assert actual_config.exception_mapper.exception_handlers[
            0] == mock_exception_handler, (
                "Skill Configuration getter in Skill Builder added invalid "
                "handler in exception mapper, "
                "when exception handlers are registered")

    def test_create_skill(self):
        mock_request_handler = mock.MagicMock(spec=AbstractRequestHandler)
        self.sb.add_request_handler(request_handler=mock_request_handler)

        mock_exception_handler = mock.MagicMock(spec=AbstractExceptionHandler)
        self.sb.add_exception_handler(exception_handler=mock_exception_handler)

        actual_skill = self.sb.create()
        expected_skill = Skill(self.sb.skill_configuration)

        assert actual_skill.request_dispatcher.request_mappers[0].request_handler_chains[0].request_handler == \
            expected_skill.request_dispatcher.request_mappers[0].request_handler_chains[0].request_handler, (
            "Skill Builder created skill with incorrect request handlers when "
            "using create method")

        assert actual_skill.request_dispatcher.exception_mapper.exception_handlers[0] == \
            expected_skill.request_dispatcher.exception_mapper.exception_handlers[0], (
            "Skill Builder created skill with incorrect exception handlers "
            "when using create method")

    def test_lambda_handler_creation(self):
        handler_func = self.sb.lambda_handler()
        assert callable(handler_func), "Skill Builder Lambda Handler " \
                                       "function returned an invalid object"

        actual_arg_spec = inspect.getargspec(handler_func)
        assert len(actual_arg_spec.args) == 2, (
            "Skill Builder Lambda Handler function created a handler of "
            "different signature than AWS Lambda")
        assert "event" in actual_arg_spec.args, (
            "Skill Builder Lambda Handler function created a handler without "
            "named parameter event")
        assert "context" in actual_arg_spec.args, (
            "Skill Builder Lambda Handler function created a handler without "
            "named parameter context")

    def test_lambda_handler_invocation(self):
        mock_request_handler = mock.MagicMock(spec=AbstractRequestHandler)
        mock_request_handler.can_handle.return_value = True
        mock_response = Response()
        mock_response.output_speech = "test output speech"
        mock_request_handler.handle.return_value = mock_response
        self.sb.add_request_handler(request_handler=mock_request_handler)

        mock_request_envelope_payload = {
            "context": {
                "System": {
                    "application": {
                        "applicationId": "test"
                    }
                }
            }
        }

        self.sb.skill_id = "test"
        lambda_handler = self.sb.lambda_handler()

        response_envelope = lambda_handler(event=mock_request_envelope_payload,
                                           context=None)

        assert response_envelope["version"] == RESPONSE_FORMAT_VERSION, (
            "Response Envelope from lambda handler invocation has version "
            "different than expected")
        assert response_envelope["userAgent"] == user_agent_info(
            custom_user_agent=None
        ), ("Response Envelope from lambda handler invocation has user agent "
            "info different than expected")
        assert response_envelope["response"][
            "outputSpeech"] == "test output speech", (
                "Response Envelope from lambda handler invocation has incorrect "
                "response than built by skill")

    def test_request_handler_decorator_creation(self):
        request_handler_wrapper = self.sb.request_handler(can_handle_func=None)
        assert callable(request_handler_wrapper), (
            "Skill Builder Request Handler decorator returned an invalid "
            "wrapper object")

        actual_arg_spec = inspect.getargspec(request_handler_wrapper)
        assert len(actual_arg_spec.args) == 1, (
            "Skill Builder Request Handler decorator created a wrapper of "
            "different signature than expected")
        assert "handle_func" in actual_arg_spec.args, (
            "Skill Builder Request Handler decorator created a wrapper "
            "without named parameter handler_func")

    def test_request_handler_decorator_invalid_can_handle_func(self):
        request_handler_wrapper = self.sb.request_handler(can_handle_func=None)

        with self.assertRaises(SkillBuilderException) as exc:
            request_handler_wrapper(handle_func=None)

        assert "can_handle_func and handle_func input parameters should be callable" in str(
            exc.exception), (
                "Request Handler Decorator accepted invalid can_handle_func "
                "parameter")

    def test_request_handler_decorator_invalid_handle_func(self):
        request_handler_wrapper = self.sb.request_handler(
            can_handle_func=lambda x: True)

        with self.assertRaises(SkillBuilderException) as exc:
            request_handler_wrapper(handle_func=None)

        assert "can_handle_func and handle_func input parameters should be callable" in str(
            exc.exception), (
                "Request Handler Decorator was decorated on an invalid object")

    def test_request_handler_decorator_on_valid_handle_func(self):
        def test_can_handle(input):
            return True

        def test_handle(input):
            return "something"

        self.sb.request_handler(can_handle_func=test_can_handle)(
            handle_func=test_handle)

        actual_request_handler = self.sb.request_handlers[0]

        assert actual_request_handler.__class__.__name__ == "RequestHandlerTestHandle", (
            "Request Handler decorator created Request Handler of incorrect "
            "name")
        assert actual_request_handler.can_handle(None) is True, (
            "Request Handler decorator created Request Handler with incorrect "
            "can_handle function")
        assert actual_request_handler.handle(None) == "something", (
            "Request Handler decorator created Request Handler with incorrect "
            "handle function")

    def test_exception_handler_decorator_creation(self):
        exception_handler_wrapper = self.sb.exception_handler(
            can_handle_func=None)
        assert callable(exception_handler_wrapper), (
            "Skill Builder Exception Handler decorator returned an invalid "
            "wrapper object")

        actual_arg_spec = inspect.getargspec(exception_handler_wrapper)
        assert len(actual_arg_spec.args) == 1, (
            "Skill Builder Exception Handler decorator created a wrapper of "
            "different signature than expected")
        assert "handle_func" in actual_arg_spec.args, (
            "Skill Builder Exception Handler decorator created a wrapper "
            "without named parameter handler_func")

    def test_exception_handler_decorator_invalid_can_handle_func(self):
        exception_handler_wrapper = self.sb.exception_handler(
            can_handle_func=None)

        with self.assertRaises(SkillBuilderException) as exc:
            exception_handler_wrapper(handle_func=None)

        assert "can_handle_func and handle_func input parameters should be callable" in str(
            exc.exception), (
                "Exception Handler Decorator accepted invalid can_handle_func "
                "parameter")

    def test_exception_handler_decorator_invalid_handle_func(self):
        exception_handler_wrapper = self.sb.exception_handler(
            can_handle_func=lambda x: True)

        with self.assertRaises(SkillBuilderException) as exc:
            exception_handler_wrapper(handle_func=None)

        assert "can_handle_func and handle_func input parameters should be callable" in str(
            exc.exception
        ), ("Exception Handler Decorator was decorated on an invalid object")

    def test_exception_handler_decorator_on_valid_handle_func(self):
        def test_can_handle(input, exc):
            return True

        def test_handle(input, exc):
            return "something"

        self.sb.exception_handler(can_handle_func=test_can_handle)(
            handle_func=test_handle)

        actual_exception_handler = self.sb.exception_handlers[0]

        assert actual_exception_handler.__class__.__name__ == "ExceptionHandlerTestHandle", (
            "Exception Handler decorator created Exception Handler of incorrect name"
        )
        assert actual_exception_handler.can_handle(None, None) is True, (
            "Exception Handler decorator created Exception Handler with "
            "incorrect can_handle function")
        assert actual_exception_handler.handle(None, None) == "something", (
            "Exception Handler decorator created Exception Handler with "
            "incorrect handle function")

    def test_global_request_interceptor_decorator_creation(self):
        request_interceptor_wrapper = self.sb.global_request_interceptor()
        assert callable(request_interceptor_wrapper), (
            "Skill Builder Global Request Interceptor decorator returned an "
            "invalid wrapper object")

        actual_arg_spec = inspect.getargspec(request_interceptor_wrapper)
        assert len(actual_arg_spec.args) == 1, (
            "Skill Builder Global Request Interceptor decorator created a "
            "wrapper of different signature than expected")
        assert "process_func" in actual_arg_spec.args, (
            "Skill Builder Global Request Interceptor decorator created a "
            "wrapper without named parameter process_func")

    def test_global_request_interceptor_decorator_invalid_process_func(self):
        request_interceptor_wrapper = self.sb.global_request_interceptor()

        with self.assertRaises(SkillBuilderException) as exc:
            request_interceptor_wrapper(process_func=None)

        assert "process_func input parameter should be callable" in str(
            exc.exception
        ), ("Global Request Interceptor Decorator accepted invalid process_func parameter"
            )

    def test_global_request_interceptor_decorator_on_valid_process_func(self):
        def test_process(input):
            return "something"

        self.sb.global_request_interceptor()(process_func=test_process)

        actual_global_request_interceptor = self.sb.global_request_interceptors[
            0]

        assert actual_global_request_interceptor.__class__.__name__ == "RequestInterceptorTestProcess"
        assert actual_global_request_interceptor.process(None) == "something"

    def test_global_response_interceptor_decorator_creation(self):
        response_interceptor_wrapper = self.sb.global_response_interceptor()
        assert callable(response_interceptor_wrapper), (
            "Skill Builder Global Request Interceptor decorator returned an "
            "invalid wrapper object")

        actual_arg_spec = inspect.getargspec(response_interceptor_wrapper)
        assert len(actual_arg_spec.args) == 1, (
            "Skill Builder Global Response Interceptor decorator created a "
            "wrapper of different signature than "
            "expected")
        assert "process_func" in actual_arg_spec.args, (
            "Skill Builder Global Response Interceptor decorator created a "
            "wrapper without named parameter "
            "process_func")

    def test_global_response_interceptor_decorator_invalid_process_func(self):
        response_interceptor_wrapper = self.sb.global_response_interceptor()

        with self.assertRaises(SkillBuilderException) as exc:
            response_interceptor_wrapper(process_func=None)

        assert "process_func input parameter should be callable" in str(
            exc.exception), (
                "Global Response Interceptor Decorator accepted invalid "
                "process_func parameter")

    def test_global_response_interceptor_decorator_on_valid_process_func(self):
        def test_process(input, response):
            return "something"

        self.sb.global_response_interceptor()(process_func=test_process)

        actual_global_response_interceptor = self.sb.global_response_interceptors[
            0]

        assert actual_global_response_interceptor.__class__.__name__ == "ResponseInterceptorTestProcess"
        assert actual_global_response_interceptor.process(None,
                                                          None) == "something"
예제 #3
0
class TestSkillBuilder(unittest.TestCase):
    def setUp(self):
        self.sb = SkillBuilder()

    def test_skill_configuration_getter_no_registered_components(self):
        actual_config = self.sb.skill_configuration

        assert actual_config.request_mappers is not None, (
            "Skill Configuration getter in Skill Builder didn't set request "
            "mappers correctly")
        assert actual_config.request_mappers[
            0].request_handler_chains is not None, (
                "Skill Configuration getter in Skill Builder didn't set handler "
                "chains in request mappers correctly")
        assert len(
            actual_config.request_mappers[0].request_handler_chains) == 0, (
                "Skill Configuration getter in Skill Builder added invalid "
                "handler in handler chain, "
                "when no request handlers are registered")
        assert actual_config.handler_adapters is not None, (
            "Skill Configuration getter in Skill Builder didn't set handler "
            "adapters correctly")
        assert isinstance(
            actual_config.handler_adapters[0], GenericHandlerAdapter
        ), ("Skill Configuration getter in Skill Builder didn't set default "
            "handler adapter")
        assert isinstance(
            actual_config.exception_mapper, GenericExceptionMapper), (
                "Skill Configuration getter in Skill Builder created invalid "
                "exception mapper, "
                "when no exception handlers are registered")
        assert len(actual_config.exception_mapper.exception_handlers) == 0, (
            "Skill Configuration getter in Skill Builder created invalid "
            "exception handlers in exception mapper, "
            "when no exception handlers are registered")
        assert actual_config.request_interceptors == [], (
            "Skill Configuration getter in Skill Builder created invalid "
            "request interceptors, "
            "when no global request interceptors are registered")
        assert actual_config.response_interceptors == [], (
            "Skill Configuration getter in Skill Builder created invalid "
            "response interceptors, "
            "when no global response interceptors are registered")
        assert actual_config.custom_user_agent is None, (
            "Skill Configuration getter in Skill Builder set invalid custom "
            "user agent")
        assert actual_config.skill_id is None, (
            "Skill Configuration getter in Skill Builder set invalid skill id")

    def test_skill_configuration_getter_handlers_registered(self):
        mock_request_handler = mock.MagicMock(spec=AbstractRequestHandler)
        self.sb.add_request_handler(request_handler=mock_request_handler)

        mock_exception_handler = mock.MagicMock(spec=AbstractExceptionHandler)
        self.sb.add_exception_handler(exception_handler=mock_exception_handler)

        actual_config = self.sb.skill_configuration

        assert actual_config.request_mappers is not None, (
            "Skill Configuration getter in Skill Builder didn't set request "
            "mappers correctly")
        assert actual_config.request_mappers[
            0].request_handler_chains is not None, (
                "Skill Configuration getter in Skill Builder didn't set handler "
                "chains in request mappers correctly")
        assert len(
            actual_config.request_mappers[0].request_handler_chains) == 1, (
                "Skill Configuration getter in Skill Builder didn't add valid "
                "handler in handler chain, "
                "when request handlers are registered")
        assert actual_config.request_mappers[0].request_handler_chains[
            0].request_handler == mock_request_handler, (
                "Skill Configuration getter in Skill Builder added invalid "
                "handler in handler chain, "
                "when request handlers are registered")

        assert actual_config.exception_mapper is not None, (
            "Skill Configuration getter in Skill Builder didn't create "
            "exception mapper, "
            "when exception handlers are registered")
        assert len(actual_config.exception_mapper.exception_handlers) == 1, (
            "Skill Configuration getter in Skill Builder added additional "
            "exception handlers than the registered ones "
            "in exception mapper")
        assert actual_config.exception_mapper.exception_handlers[
            0] == mock_exception_handler, (
                "Skill Configuration getter in Skill Builder added invalid "
                "handler in exception mapper, "
                "when exception handlers are registered")

    def test_create_skill(self):
        mock_request_handler = mock.MagicMock(spec=AbstractRequestHandler)
        self.sb.add_request_handler(request_handler=mock_request_handler)

        mock_exception_handler = mock.MagicMock(spec=AbstractExceptionHandler)
        self.sb.add_exception_handler(exception_handler=mock_exception_handler)

        actual_skill = self.sb.create()
        expected_skill = CustomSkill(self.sb.skill_configuration)

        assert actual_skill.request_dispatcher.request_mappers[0].request_handler_chains[0].request_handler == \
            expected_skill.request_dispatcher.request_mappers[0].request_handler_chains[0].request_handler, (
            "Skill Builder created skill with incorrect request handlers when "
            "using create method")

        assert actual_skill.request_dispatcher.exception_mapper.exception_handlers[0] == \
            expected_skill.request_dispatcher.exception_mapper.exception_handlers[0], (
            "Skill Builder created skill with incorrect exception handlers "
            "when using create method")

    def test_lambda_handler_creation(self):
        handler_func = self.sb.lambda_handler()
        assert callable(handler_func), "Skill Builder Lambda Handler " \
                                       "function returned an invalid object"

        actual_arg_spec = inspect.getargspec(handler_func)
        assert len(actual_arg_spec.args) == 2, (
            "Skill Builder Lambda Handler function created a handler of "
            "different signature than AWS Lambda")
        assert "event" in actual_arg_spec.args, (
            "Skill Builder Lambda Handler function created a handler without "
            "named parameter event")
        assert "context" in actual_arg_spec.args, (
            "Skill Builder Lambda Handler function created a handler without "
            "named parameter context")

    def test_lambda_handler_invocation(self):
        mock_request_handler = mock.MagicMock(spec=AbstractRequestHandler)
        mock_request_handler.can_handle.return_value = True
        mock_response = Response()
        mock_response.output_speech = "test output speech"
        mock_request_handler.handle.return_value = mock_response
        self.sb.add_request_handler(request_handler=mock_request_handler)

        mock_request_envelope_payload = {
            "context": {
                "System": {
                    "application": {
                        "applicationId": "test"
                    }
                }
            }
        }

        self.sb.skill_id = "test"
        lambda_handler = self.sb.lambda_handler()

        response_envelope = lambda_handler(event=mock_request_envelope_payload,
                                           context=None)

        assert response_envelope["version"] == RESPONSE_FORMAT_VERSION, (
            "Response Envelope from lambda handler invocation has version "
            "different than expected")
        assert response_envelope["userAgent"] == user_agent_info(
            sdk_version=__version__, custom_user_agent=None
        ), ("Response Envelope from lambda handler invocation has user agent "
            "info different than expected")
        assert response_envelope["response"][
            "outputSpeech"] == "test output speech", (
                "Response Envelope from lambda handler invocation has incorrect "
                "response than built by skill")
예제 #4
0

@sb.exception_handler(can_handle_func=lambda i, e: True)
def all_exception_handler(handler_input, exception):
    # type: (HandlerInput, Exception) -> Response
    # Log the exception in CloudWatch Logs
    print(exception)
    speech = "Sorry, I didn't get it. Can you please say it again?"
    handler_input.response_builder.speak(speech).ask(speech)
    return handler_input.response_builder.response



app = Flask(__name__)
skill_response = SkillAdapter(
    skill=sb.create(), skill_id="AMAZON SKILL ID GOES HERE", app=app)

skill_response.register(app=app, route="/")


@app.route("/")
def invoke_skill():
    return skill_response.dispatch_request()


if __name__ == '__main__':
    app.run()



from intents.catch_all_exception_handler import CatchAllExceptionHandler

from intents.first_order_intent_handler import FirstOrderIntentHandler
from intents.second_order_intent_handler import SecondOrderIntentHandler
from intents.third_order_intent_handler import ThirdOrderIntentHandler

load_dotenv()

sb = SkillBuilder()

sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(CancelOrStopIntentHandler())
sb.add_request_handler(SessionEndedRequestHandler())
sb.add_request_handler(HelpIntentHandler())

sb.add_request_handler(FirstOrderIntentHandler())
sb.add_request_handler(SecondOrderIntentHandler())
sb.add_request_handler(ThirdOrderIntentHandler())

sb.add_exception_handler(CatchAllExceptionHandler())

app = Flask(__name__)
skill_response = SkillAdapter(skill=sb.create(),
                              skill_id=os.getenv('SKILL_ID'),
                              app=app)

skill_response.register(app=app, route="/")

if __name__ == '__main__':
    app.run(threaded=True)
예제 #6
0
파일: pilot.py 프로젝트: thaughbaer/pilot
    else:
        speech_text = 'Passenger {} is not on the manifest.'.format(hostname)

    return handler_input.response_builder.speak(speech_text).response


@skill_builder.request_handler(can_handle_func=is_request_type('SessionEndedRequest'))
def session_ended_request_handler(handler_input):
    return handler_input.response_builder.response


@skill_builder.global_request_interceptor()
def request_logger(handler_input):
    app.logger.debug('Request received: {}'.format(handler_input.request_envelope.request))


@skill_builder.global_response_interceptor()
def response_logger(handler_input, response):
    app.logger.debug('Response generated: {}'.format(response))


skill_response = SkillAdapter(skill=skill_builder.create(), skill_id=config['applicationId'], app=app)

skill_response.register(app=app, route='/')


if __name__ == '__main__':

    app.run(host = '0.0.0.0', debug = True)

from ask_sdk_core.skill_builder import SkillBuilder
from ask_sdk_model import request_envelope
from ask_sdk_model import context
import json

sb = SkillBuilder()
skill_obj = sb.create()


def requestBuilder(request_type,
                   attributes=None,
                   intent_name=None,
                   slots=None,
                   ingredient=None,
                   dialog_state=None,
                   userid="amzn1.ask.account.[unique-value-here]"):
    #input: userid, request type, session attributes
    session = {}
    session["new"] = True
    session["sessionId"] = "amzn1.echo-api.session.[unique-value-here]"
    if attributes == None:
        session["attributes"] = {}

    else:
        if ingredient == None:
            session["attributes"] = {
                "current_recipe":
                "{\"py/object\": \"recipe.recipe\", \"directions\": [], \"ingredients\": {\"py/set\": []}, \"title\": \""
                + attributes + "\"}"
            }
        else:
예제 #8
0
                .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 = SkillBuilder()

# Register all handlers, interceptors etc.
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(MoveNorthIntentHandler())
#sb.add_request_handler(HelloWorldIntentHandler())
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())

app = Flask(__name__)
app.config['ASK_SDK_VERIFY_TIMESTAMP'] = False
skill_response = SkillAdapter(
    skill=sb.create(), skill_id='amzn1.ask.skill.327b488d-bf14-476a-8456-d092972cd5b5', app=app)

skill_response.register(app=app, route="/")

if __name__ == '__main__':
    app.run()
예제 #9
0
        return (handler_input.response_builder.speak(speak_output).ask(
            speak_output).response)


#
# Create a skill builder and register the handles
#
print("Creating a skill builder ...")
skill_builder = SkillBuilder()
skill_builder.add_request_handler(LaunchRequestHandler())
skill_builder.add_request_handler(MoveRobotIntentHandler())
skill_builder.add_request_handler(FallbackIntentHandler())
skill_builder.add_request_handler(SessionEndedRequestHandler())
skill_builder.add_exception_handler(CatchAllExceptionHandler())

skill_obj = skill_builder.create()


#
# Define the routes for Flask
#
@app.route("/alexa-webhook", methods=['POST'])
def post():
    """
    Process the request as following :
    - Get the input request JSON
    - Deserialize it to Request Envelope
    - Verify the request was sent by Alexa
    - Invoke the skill
    - Return the serialized response
    """
예제 #10
0
    """

    # type: (HandlerInput, Exception) -> Response
    logger.error(exception, exc_info=True)
    return handler_input.response_builder.speak(ERROR_PROMPT).set_should_end_session(True).response

# --- aws lambda

lambda_handler = sb.lambda_handler()

# --- flask

from flask import Flask
from flask_ask_sdk.skill_adapter import SkillAdapter

app = Flask(__name__)

skill_adapter = SkillAdapter(skill=sb.create(), skill_id='TEST', app=app)

@app.route("/", methods=['POST'])
def invoke_skill():
    """
    POST Methode, die den Skill als FLASK app startet.

    :return: Startet den Skill
    :rtype: dispatch_request
    """
    return skill_adapter.dispatch_request()

if __name__ == '__main__':
    app.run(debug=True)
예제 #11
0
    # type: (HandlerInput, Exception) -> None
    print("Encountered following exception: {}".format(exception))
    #to do: changer le texte
    speech = "il y a un problème"
    handler_input.response_builder.speak(speech).ask(speech)

    return handler_input.response_builder.response

# Handler to be provided in lambda console.
lambda_handler = sb.lambda_handler()

#deploy on Kermit 
app = Flask(__name__)

skill_response = SkillAdapter(
    skill=sb.create(), skill_id = config.skill_id, app=app)

@app.route("/",methods=['GET','POST'])
def invoke_skill():
    return skill_response.dispatch_request()

    #API base de données 
    #GET collection
@app.route("/databases/<db_name>/collections/<db_collection>", methods= ['GET'])
def get_collection_api(db_name,db_collection):
    # API utilisant la connection créée dès le début du programme
    collection = functions.get_collection(client_bdd, db_name, db_collection)
    documents = collection.find()
    response = []
    for document in documents:
        del document['_id']
예제 #12
0
@skill_builder.exception_handler(can_handle_func=lambda i, e: True)
def all_exception_handler(handler_input, exception):
    # """Catch all exception handler, log exception and
    # respond with custom message.
    # """
    # type: (HandlerInput, Exception) -> Response
    logger.error(exception, exc_info=True)

    speech = "Sorry, there was some problem. Please try again!!"
    handler_input.response_builder.speak(speech).ask(speech)

    return handler_input.response_builder.response


# skill_id="amzn1.ask.skill.e909e9d9-3ad7-4563-bbfe-ec0247ab3f7a"
skill_adapter = SkillAdapter(skill=skill_builder.create(),
                             skill_id=10,
                             app=app)

skill_adapter.register(app=app, route="/moveplan")


@app.route('/heartbeat')
def default_route():
    """Default route to return a simple message"""
    return jsonify('hi! I am alive')


if __name__ == "__main__":
    app.run(host='0.0.0.0', debug=True)
예제 #13
0
# the below code was taken from a freely-available tutorial online

# 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 = SkillBuilder()

# Register all handlers, interceptors etc.
sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(MoveIntentHandler())
sb.add_request_handler(BuildIntentHandler())
#sb.add_request_handler(HelloWorldIntentHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(CancelOrStopIntentHandler())
sb.add_request_handler(SessionEndedRequestHandler())
sb.add_request_handler(FallbackIntentHandler())
sb.add_request_handler(IntentReflectorHandler()) # make sure IntentReflectorHandler is last so it doesn't override your custom intent handlers
sb.add_exception_handler(CatchAllExceptionHandler())

app = Flask(__name__)
app.config['ASK_SDK_VERIFY_TIMESTAMP'] = False
skill_response = SkillAdapter(
    skill=sb.create(), skill_id='amzn1.ask.skill.df7f27ea-302a-487c-852b-725e8e35460d', app=app)

skill_response.register(app=app, route="/")

if __name__ == '__main__':
    app.run()
예제 #14
0
        return handler_input.response_builder.response


from ask_sdk_core.dispatch_components import AbstractExceptionHandler


class AllExceptionHandler(AbstractExceptionHandler):
    def can_handle(self, handler_input, exception):
        # type: (HandlerInput, Exception) -> bool
        print('hey005')
        return True

    def handle(self, handler_input, exception):
        # type: (HandlerInput, Exception) -> Response
        # Log the exception in CloudWatch Logs
        print(exception)

        speech = "Sorry, I didn't get it. Can you please say it again!!"
        handler_input.response_builder.speak(speech).ask(speech)
        return handler_input.response_builder.response


sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(HelloWorldIntentHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(CancelAndStopIntentHandler())
sb.add_request_handler(SessionEndedRequestHandler())
sb.add_exception_handler(AllExceptionHandler())

myskill001 = sb.create()
예제 #15
0
sb.add_request_handler(AskForCocktailIntentHandler())
sb.add_request_handler(CocktailWithIngredientIntentHandler())
sb.add_request_handler(NonAlcoholicCocktailIntentHandler())
sb.add_request_handler(GlassIntentHandler())
sb.add_request_handler(MeasureIntentHandler())
sb.add_request_handler(RandomCocktailIntentHandler())
sb.add_request_handler(IngredientDescriptionIntentHandler())
sb.add_request_handler(YesMoreInfoIntentHandler())
sb.add_request_handler(NoMoreInfoIntentHandler())
sb.add_request_handler(RepeatIntentHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(CancelOrStopIntentHandler())
sb.add_request_handler(FallbackIntentHandler())
sb.add_request_handler(SessionEndedRequestHandler())
sb.add_exception_handler(CatchAllExceptionHandler())
sb.add_global_request_interceptor(RequestLogger())
sb.add_global_response_interceptor(ResponseLogger())


skill_adapter = SkillAdapter(
    skill=sb.create(), skill_id='TEST', app=app)


@app.route("/", methods=['POST'])
def invoke_skill():
    return skill_adapter.dispatch_request()


if __name__ == '__main__':
    app.run()
예제 #16
0
@sb.request_handler(can_handle_func=is_request_type("SessionEndedRequest"))
def session_ended_request_handler(handler_input):
    #any cleanup logic goes here
    return handler_input.response_builder.response

@sb.exception_handler(can_handle_func=lambda i, e: True)
def all_exception_handler(handler_input, exception):
    # Log the exception
    print(exception)

    speech_text = "Sorry, I didn't get it. Can you please say it again?"
    return build_response(handler_input, speech_text, "Sleep Schedule", ask=True)

skill_adapter = SkillAdapter(
    skill=sb.create(), skill_id="amzn1.ask.skill.b134fcc6-c7e1-47f6-a1ac-46b2216f665a", app=app)

def build_response(input, text, card_title="", card_content=None, end=False, ask=False):
    """ Function to build responses """

    if not card_content:
        card_content = text
    input.response_builder.speak(text)
    input.response_builder.set_card(SimpleCard(card_title, card_content))
    input.response_builder.set_should_end_session(end)
    if ask:
        input.response_builder.ask(text)

    return input.response_builder.response

@app.route("/")