Decorator that can be used to add exception handlers easily
        to the builder.

        The can_handle_func has to be a Callable instance, which takes
        two parameters and no varargs or kwargs. This is because of the
        ExceptionHandler class signature restrictions. The returned
        wrapper function can be applied as a decorator on any function
        that processes the exception raised during dispatcher and
        returns a response object by the skill. The function should
        follow the signature of the handle function in
        :py:class:`ask_sdk_runtime.dispatch_components.exception_components.AbstractExceptionHandler`
        class.

        :param can_handle_func: The function that validates if the
            exception can be handled.
        :type can_handle_func: Callable[[Input, Exception], bool]
        :return: Wrapper function that can be decorated on a handle
            function.

def exception_handler(self, can_handle_func):
        # type: (Callable[[Input, Exception], bool]) -> Callable
        """Decorator that can be used to add exception handlers easily
        to the builder.

        The can_handle_func has to be a Callable instance, which takes
        two parameters and no varargs or kwargs. This is because of the
        ExceptionHandler class signature restrictions. The returned
        wrapper function can be applied as a decorator on any function
        that processes the exception raised during dispatcher and
        returns a response object by the skill. The function should
        follow the signature of the handle function in
        :py:class:`ask_sdk_runtime.dispatch_components.exception_components.AbstractExceptionHandler`
        class.

        :param can_handle_func: The function that validates if the
            exception can be handled.
        :type can_handle_func: Callable[[Input, Exception], bool]
        :return: Wrapper function that can be decorated on a handle
            function.
        """
        def wrapper(handle_func):
            if not callable(can_handle_func) or not callable(handle_func):
                raise SkillBuilderException(
                    "Exception Handler can_handle_func and handle_func input "
                    "parameters should be callable")

            class_attributes = {
                "can_handle": (
                    lambda self, handler_input, exception: can_handle_func(
                        handler_input, exception)),
                "handle": lambda self, handler_input, exception: handle_func(
                    handler_input, exception)
            }

            exception_handler_class = type(
                "ExceptionHandler{}".format(
                    handle_func.__name__.title().replace("_", "")),
                (AbstractExceptionHandler,), class_attributes)

            self.add_exception_handler(
                exception_handler=exception_handler_class())
        return wrapper