docs: def send(message, **kwargs):
      """Send a SocketIO message.
  
      This function sends a simple SocketIO message to one or more connected
      clients. The message can be a string or a JSON blob. This is a simpler
      version of ``emit()``, which should be preferred. This is a function that
      can only be called from a SocketIO event handler.
  
      :param message: The message to send, either a string or a JSON blob.
      :param json: ``True`` if ``message`` is a JSON blob, ``False``
                       otherwise.
      :param namespace: The namespace under which the message is to be sent.
                        Defaults to the namespace used by the originating event.
                        An empty string can be used to use the global namespace.
      :param callback: Callback function to invoke with the client's
                       acknowledgement.
      :param broadcast: ``True`` to send the message to all connected clients, or
                        ``False`` to only reply to the sender of the originating
                        event.
      :param room: Send the message to all the users in the given room.
      :param include_self: ``True`` to include the sender when broadcasting or
                           addressing a room, or ``False`` to send to everyone
                           but the sender.
      :param ignore_queue: Only used when a message queue is configured. If
                           set to ``True``, the event is emitted to the
                           clients directly, without going through the queue.
                           This is more efficient, but only works when a
                           single server process is used, or when there is a
                           single addresee. It is recommended to always leave
                           this parameter with its default value of ``False``.
      """
      json = kwargs.get('json', False)
      if 'namespace' in kwargs:
          namespace = kwargs['namespace']
      else:
          namespace = flask.request.namespace
      callback = kwargs.get('callback')
      broadcast = kwargs.get('broadcast')
      room = kwargs.get('room')
      if room is None and not broadcast:
          room = flask.request.sid
      include_self = kwargs.get('include_self', True)
      ignore_queue = kwargs.get('ignore_queue', False)
  
      socketio = flask.current_app.extensions['socketio']
      return socketio.send(message, json=json, namespace=namespace, room=room,
                           include_self=include_self, callback=callback,
                           ignore_queue=ignore_queue)