docs: async def handle_request(self, channel: Channel, body, envelope,
                               properties, futurize=True):
          """
          the 'futurize' param is simply because aioamqp doesnt send another job until
           this method returns (completes), so we ensure the future of
           ourselves and return immediately so we can handle many requests
           at a time.
          """
          if futurize:
              asyncio.ensure_future(
                  self.handle_request(channel, body, envelope, properties,
                                      futurize=False))
              return
  
          self._counter += 1
          headers = properties.headers or {}
          query = headers.pop('x-wasp-query-string', '').lstrip('?')
          correlation_id = properties.correlation_id
          message_id = properties.message_id
          reply_to = properties.reply_to
          route = envelope.routing_key
  
          method, path = route.split('.', 1)
          try:
              method = Methods(method.upper())
          except ValueError:
              path = route
              method = 'POST'
          path = path.replace('.', '/')
          # need to use `?` to represent `.` in rabbit
          # since its not valid in a path, it should work correctly everywhere
          path = path.replace('?', '.')
          path = urllib.parse.unquote(path)
  
          request = Request(
              headers=headers,
              path=path,
              correlation_id=correlation_id,
              method=method,
              query_string=query,
              body=body,
          )
          if properties.content_type:
              headers['content-type'] = properties.content_type
              request.content_type = properties.content_type
          if properties.content_encoding:
              headers['content-encoding'] = properties.content_encoding
  
          logger.debug('received incoming request via rabbitmq: %s', request)
          response = await self._handler(request)
          if response is None:
              # task got cancelled. Dont send a response.
              return
          if reply_to:
              response.headers['Status'] = str(response.status.value)
  
              payload = response.raw_body or b'null'
  
              properties = {
                  'correlation_id': response.correlation_id,
                  'headers': response.headers,
                  'content_type': response.content_type,
                  'message_id': message_id,
                  'expiration': '30000',
              }
              await self._channel_ready.wait()
              await channel.basic_publish(exchange_name='',
                                          payload=payload,
                                          routing_key=reply_to,
                                          properties=properties)
  
          if self._use_acks:
              await self.channel.basic_client_ack(delivery_tag=envelope.delivery_tag)
          self._counter -= 1