code: def _request_handler(self, **kwargs):
          
          route = self._get_current_route(request)
  
          try:
              event = self._construct_event(request, self.port, route.binary_types)
          except UnicodeDecodeError:
              return ServiceErrorResponses.lambda_failure_response()
  
          stdout_stream = io.BytesIO()
          stdout_stream_writer = StreamWriter(stdout_stream, self.is_debugging)
  
          try:
              self.lambda_runner.invoke(route.function_name, event, stdout=stdout_stream_writer, stderr=self.stderr)
          except FunctionNotFound:
              return ServiceErrorResponses.lambda_not_found_response()
  
          lambda_response, lambda_logs, _ = LambdaOutputParser.get_lambda_output(stdout_stream)
  
          if self.stderr and lambda_logs:
              # Write the logs to stderr if available.
              self.stderr.write(lambda_logs)
  
          try:
              (status_code, headers, body) = self._parse_lambda_output(lambda_response,
                                                                       route.binary_types,
                                                                       request)
          except (KeyError, TypeError, ValueError):
              LOG.error("Function returned an invalid response (must include one of: body, headers or "
                        "statusCode in the response object). Response received: %s", lambda_response)
              return ServiceErrorResponses.lambda_failure_response()
  
          return self.service_response(body, headers, status_code)
docs: We handle all requests to the host:port. The general flow of handling a request is as follows
  
          * Fetch request from the Flask Global state. This is where Flask places the request and is per thread so
            multiple requests are still handled correctly
          * Find the Lambda function to invoke by doing a look up based on the request.endpoint and method
          * If we don't find the function, we will throw a 502 (just like the 404 and 405 responses we get
            from Flask.
          * Since we found a Lambda function to invoke, we construct the Lambda Event from the request
          * Then Invoke the Lambda function (docker container)
          * We then transform the response or errors we get from the Invoke and return the data back to
            the caller
  
          Parameters
          ----------
          kwargs dict
              Keyword Args that are passed to the function from Flask. This happens when we have path parameters
  
          Returns
          -------
          Response object