code: def __dispatch_request(self, handler_input):
          # type: (Input) -> Union[Output, None]
          
          request_handler_chain = None
          for mapper in self.request_mappers:
              request_handler_chain = mapper.get_request_handler_chain(
                  handler_input)
              if request_handler_chain is not None:
                  break
  
          if request_handler_chain is None:
              raise DispatchException(
                  "Unable to find a suitable request handler")
  
          request_handler = request_handler_chain.request_handler
          supported_handler_adapter = None
          for adapter in self.handler_adapters:
              if adapter.supports(request_handler):
                  supported_handler_adapter = adapter
                  break
  
          if supported_handler_adapter is None:
              raise DispatchException(
                  "Unable to find a suitable request adapter")
  
          local_request_interceptors = request_handler_chain.request_interceptors
          for interceptor in local_request_interceptors:
              interceptor.process(handler_input=handler_input)
  
          output = supported_handler_adapter.execute(
              handler_input=handler_input, handler=request_handler)  # type: Union[Output, None]
  
          local_response_interceptors = (
              request_handler_chain.response_interceptors)
          for response_interceptor in local_response_interceptors:
              response_interceptor.process(
                  handler_input=handler_input, dispatch_output=output)
  
          return output
docs: Process the request and return handler output.
  
          When the method is invoked, using the registered list of
          :py:class:`RequestMapper`, a Handler Chain is found that can
          handle the request. The handler invocation is delegated to the
          supported :py:class:`HandlerAdapter`. The registered
          request interceptors in the handler chain are processed before
          executing the handler. The registered response interceptors in
          the handler chain are processed after executing the handler.
  
          :param handler_input: generic input to the dispatcher containing
              incoming request and other context.
          :type handler_input: Input
          :return: Output from the 'handle' method execution of the
              supporting handler.
          :rtype: Union[None, Output]
          :raises DispatchException if there is no supporting
              handler chain or adapter