docs: def basic_consume(self, queue='', consumer_tag='', no_local=False,
          no_ack=False, exclusive=False, nowait=False,
          callback=None, ticket=None):
          """
          start a queue consumer
  
          This method asks the server to start a "consumer", which is a
          transient request for messages from a specific queue.
          Consumers last as long as the channel they were created on, or
          until the client cancels them.
  
          RULE:
  
              The server SHOULD support at least 16 consumers per queue,
              unless the queue was declared as private, and ideally,
              impose no limit except as defined by available resources.
  
          PARAMETERS:
              queue: shortstr
  
                  Specifies the name of the queue to consume from.  If
                  the queue name is null, refers to the current queue
                  for the channel, which is the last declared queue.
  
                  RULE:
  
                      If the client did not previously declare a queue,
                      and the queue name in this method is empty, the
                      server MUST raise a connection exception with
                      reply code 530 (not allowed).
  
              consumer_tag: shortstr
  
                  Specifies the identifier for the consumer. The
                  consumer tag is local to a connection, so two clients
                  can use the same consumer tags. If this field is empty
                  the server will generate a unique tag.
  
                  RULE:
  
                      The tag MUST NOT refer to an existing consumer. If
                      the client attempts to create two consumers with
                      the same non-empty tag the server MUST raise a
                      connection exception with reply code 530 (not
                      allowed).
  
              no_local: boolean
  
                  do not deliver own messages
  
                  If the no-local field is set the server will not send
                  messages to the client that published them.
  
              no_ack: boolean
  
                  no acknowledgement needed
  
                  If this field is set the server does not expect
                  acknowledgments for messages.  That is, when a message
                  is delivered to the client the server automatically and
                  silently acknowledges it on behalf of the client.  This
                  functionality increases performance but at the cost of
                  reliability.  Messages can get lost if a client dies
                  before it can deliver them to the application.
  
              exclusive: boolean
  
                  request exclusive access
  
                  Request exclusive consumer access, meaning only this
                  consumer can access the queue.
  
                  RULE:
  
                      If the server cannot grant exclusive access to the
                      queue when asked, - because there are other
                      consumers active - it MUST raise a channel
                      exception with return code 403 (access refused).
  
              nowait: boolean
  
                  do not send a reply method
  
                  If set, the server will not respond to the method. The
                  client should not wait for a reply method.  If the
                  server could not complete the method it will raise a
                  channel or connection exception.
  
              callback: Python callable
  
                  function/method called with each delivered message
  
                  For each message delivered by the broker, the
                  callable will be called with a Message object
                  as the single argument.  If no callable is specified,
                  messages are quietly discarded, no_ack should probably
                  be set to True in that case.
  
              ticket: short
  
                  RULE:
  
                      The client MUST provide a valid access ticket
                      giving "read" access rights to the realm for the
                      queue.
  
          """
          args = AMQPWriter()
          if ticket is not None:
              args.write_short(ticket)
          else:
              args.write_short(self.default_ticket)
          args.write_shortstr(queue)
          args.write_shortstr(consumer_tag)
          args.write_bit(no_local)
          args.write_bit(no_ack)
          args.write_bit(exclusive)
          args.write_bit(nowait)
          self._send_method((60, 20), args)
  
          if not nowait:
              consumer_tag = self.wait(allowed_methods=[
                                (60, 21),    # Channel.basic_consume_ok
                              ])
  
          self.callbacks[consumer_tag] = callback
  
          return consumer_tag