code: def publish(self, payload, **kwargs):
          
          publish_kwargs = self.publish_kwargs.copy()
  
          # merge headers from when the publisher was instantiated
          # with any provided now; "extra" headers always win
          headers = publish_kwargs.pop('headers', {}).copy()
          headers.update(kwargs.pop('headers', {}))
          headers.update(kwargs.pop('extra_headers', {}))
  
          use_confirms = kwargs.pop('use_confirms', self.use_confirms)
          transport_options = kwargs.pop('transport_options',
                                         self.transport_options
                                         )
          transport_options['confirm_publish'] = use_confirms
  
          delivery_mode = kwargs.pop('delivery_mode', self.delivery_mode)
          mandatory = kwargs.pop('mandatory', self.mandatory)
          priority = kwargs.pop('priority', self.priority)
          expiration = kwargs.pop('expiration', self.expiration)
          serializer = kwargs.pop('serializer', self.serializer)
          compression = kwargs.pop('compression', self.compression)
          retry = kwargs.pop('retry', self.retry)
          retry_policy = kwargs.pop('retry_policy', self.retry_policy)
  
          declare = self.declare[:]
          declare.extend(kwargs.pop('declare', ()))
  
          publish_kwargs.update(kwargs)  # remaining publish-time kwargs win
  
          with get_producer(self.amqp_uri,
                            use_confirms,
                            self.ssl,
                            transport_options,
                            ) as producer:
              try:
                  producer.publish(
                      payload,
                      headers=headers,
                      delivery_mode=delivery_mode,
                      mandatory=mandatory,
                      priority=priority,
                      expiration=expiration,
                      compression=compression,
                      declare=declare,
                      retry=retry,
                      retry_policy=retry_policy,
                      serializer=serializer,
                      **publish_kwargs
                  )
              except ChannelError as exc:
                  if "NO_ROUTE" in str(exc):
                      raise UndeliverableMessage()
                  raise
  
              if mandatory:
                  if not use_confirms:
                      warnings.warn(
                          "Mandatory delivery was requested, but "
                          "unroutable messages cannot be detected without "
                          "publish confirms enabled."
                      )
docs: Publish a message.