docs: def queue_bind(self, queue, exchange, routing_key='',
          nowait=False, arguments=None, ticket=None):
          """
          bind queue to an exchange
  
          This method binds a queue to an exchange.  Until a queue is
          bound it will not receive any messages.  In a classic
          messaging model, store-and-forward queues are bound to a dest
          exchange and subscription queues are bound to a dest_wild
          exchange.
  
          RULE:
  
              A server MUST allow ignore duplicate bindings - that is,
              two or more bind methods for a specific queue, with
              identical arguments - without treating these as an error.
  
          RULE:
  
              If a bind fails, the server MUST raise a connection
              exception.
  
          RULE:
  
              The server MUST NOT allow a durable queue to bind to a
              transient exchange. If the client attempts this the server
              MUST raise a channel exception.
  
          RULE:
  
              Bindings for durable queues are automatically durable and
              the server SHOULD restore such bindings after a server
              restart.
  
          RULE:
  
              If the client attempts to an exchange that was declared as
              internal, the server MUST raise a connection exception
              with reply code 530 (not allowed).
  
          RULE:
  
              The server SHOULD support at least 4 bindings per queue,
              and ideally, impose no limit except as defined by
              available resources.
  
          PARAMETERS:
              queue: shortstr
  
                  Specifies the name of the queue to bind.  If the queue
                  name is empty, 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).
  
                  RULE:
  
                      If the queue does not exist the server MUST raise
                      a channel exception with reply code 404 (not
                      found).
  
              exchange: shortstr
  
                  The name of the exchange to bind to.
  
                  RULE:
  
                      If the exchange does not exist the server MUST
                      raise a channel exception with reply code 404 (not
                      found).
  
              routing_key: shortstr
  
                  message routing key
  
                  Specifies the routing key for the binding.  The
                  routing key is used for routing messages depending on
                  the exchange configuration. Not all exchanges use a
                  routing key - refer to the specific exchange
                  documentation.  If the routing key is empty and the
                  queue name is empty, the routing key will be the
                  current queue for the channel, which is the last
                  declared queue.
  
              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.
  
              arguments: table
  
                  arguments for binding
  
                  A set of arguments for the binding.  The syntax and
                  semantics of these arguments depends on the exchange
                  class.
  
              ticket: short
  
                  The client provides a valid access ticket giving
                  "active" access rights to the queue's access realm.
  
          """
          if arguments is None:
              arguments = {}
  
          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(exchange)
          args.write_shortstr(routing_key)
          args.write_bit(nowait)
          args.write_table(arguments)
          self._send_method((50, 20), args)
  
          if not nowait:
              return self.wait(allowed_methods=[
                                (50, 21),    # Channel.queue_bind_ok
                              ])