code: def exception_handler(self, can_handle_func):
          # type: (Callable[[Input, Exception], bool]) -> Callable
          
          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
docs: 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.