docs: async def basic_consume(self, queue_name='', consumer_tag='',
                              no_local=False, no_ack=False, exclusive=False,
                              no_wait=False, arguments=None, wait_message=True,
                              timeout=0):
          """Starts the consumption of message into a queue.
          the callback will be called each time we're receiving a message.
  
              Args:
                  queue_name:     str, the queue to receive message from
                  consumer_tag:   str, optional consumer tag
                  no_local:       bool, if set the server will not send messages
                                  to the connection that published them.
                  no_ack:         bool, if set the server does not expect
                                  acknowledgements for messages
                  exclusive:      bool, request exclusive consumer access,
                                  meaning only this consumer can access the queue
                  no_wait:        bool, if set, the server will not respond to
                                  the method
                  arguments:      dict, AMQP arguments to be passed to the server
                  wait_message:   Indicates if the consumer should wait for new
                                  messages in the queue or simply return None if
                                  the queue is empty.
                  timeout:        A timeout for waiting messages.
                                  ``wait_message`` has precendence over timeout.
          """
          # If a consumer tag was not passed, create one
          consumer_tag = consumer_tag or 'ctag%i.%s' % (
              self.channel_id, uuid.uuid4().hex)
  
          if arguments is None:
              arguments = {}
  
          frame = amqp_frame.AmqpRequest(
              self.protocol._stream_writer, amqp_constants.TYPE_METHOD,
              self.channel_id)
          frame.declare_method(
              amqp_constants.CLASS_BASIC, amqp_constants.BASIC_CONSUME)
          request = amqp_frame.AmqpEncoder()
          request.write_short(0)
          request.write_shortstr(queue_name)
          request.write_shortstr(consumer_tag)
          request.write_bits(no_local, no_ack, exclusive, no_wait)
          request.write_table(arguments)
  
          self.consumer_queues[consumer_tag] = asyncio.Queue(self.max_queue_size)
          self.last_consumer_tag = consumer_tag
  
          consumer = self.CONSUMER_CLASS(
              self, self.consumer_queues[consumer_tag],
              consumer_tag, nowait=not wait_message,
              timeout=timeout)
  
          await self._write_frame_awaiting_response(
              'basic_consume', frame, request, no_wait)
  
          if not no_wait:
              self._ctag_events[consumer_tag].set()
  
          return consumer