docs: def publish_message(self,
                          exchange,
                          routing_key,
                          properties,
                          body,
                          no_serialization=False,
                          no_encoding=False,
                          channel=None,
                          connection=None):
          """Publish a message to RabbitMQ on the same channel the original
          message was received on.
  
          By default, if you pass a non-string object to the body and the
          properties have a supported ``content_type`` set, the body will be
          auto-serialized in the specified ``content_type``.
  
          If the properties do not have a timestamp set, it will be set to the
          current time.
  
          If you specify a ``content_encoding`` in the properties and the
          encoding is supported, the body will be auto-encoded.
  
          Both of these behaviors can be disabled by setting
          ``no_serialization`` or ``no_encoding`` to ``True``.
  
          If you pass an unsupported content-type or content-encoding when using
          the auto-serialization and auto-encoding features, a :exc:`ValueError`
          will be raised.
  
          .. versionchanged:: 4.0.0
             The method returns a :py:class:`~tornado.concurrent.Future` if
             `publisher confirmations <https://www.rabbitmq.com/confirms.html>`_
             are enabled on for the connection. In addition, The ``channel``
             parameter is deprecated and will be removed in a future release.
  
          :param str exchange: The exchange to publish to
          :param str routing_key: The routing key to publish with
          :param dict properties: The message properties
          :param mixed body: The message body to publish
          :param bool no_serialization: Turn off auto-serialization of the body
          :param bool no_encoding: Turn off auto-encoding of the body
          :param str channel: **Deprecated in 4.0.0** Specify the connection
              parameter instead.
          :param str connection: The connection to use. If it is not
              specified, the channel that the message was delivered on is used.
          :rtype: tornado.concurrent.Future or None
          :raises: ValueError
  
          """
          # Auto-serialize the content if needed
          is_string = (isinstance(body, str) or isinstance(body, bytes)
                       or isinstance(body, unicode))
          if not no_serialization and not is_string and \
                  properties.get('content_type'):
              body = self._serialize(
                  body, headers.parse_content_type(properties['content_type']))
  
          # Auto-encode the message body if needed
          if not no_encoding and \
                  properties.get('content_encoding') in self._CODEC_MAP.keys():
              body = self._compress(
                  body, self._CODEC_MAP[properties['content_encoding']])
  
          return super(SmartConsumer, self).publish_message(
              exchange, routing_key, properties, body, channel or connection)