docs: def emit(event, *args, **kwargs):
      """Emit a SocketIO event.
  
      This function emits a SocketIO event to one or more connected clients. A
      JSON blob can be attached to the event as payload. This is a function that
      can only be called from a SocketIO event handler, as in obtains some
      information from the current client context. Example::
  
          @socketio.on('my event')
          def handle_my_custom_event(json):
              emit('my response', {'data': 42})
  
      :param event: The name of the user event to emit.
      :param args: A dictionary with the JSON data to send as payload.
      :param namespace: The namespace under which the message is to be sent.
                        Defaults to the namespace used by the originating event.
                        A ``'/'`` can be used to explicitly specify the global
                        namespace.
      :param callback: Callback function to invoke with the client's
                       acknowledgement.
      :param broadcast: ``True`` to send the message to all 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. If this
                   argument is set, then broadcast is implied to be ``True``.
      :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``.
      """
      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.emit(event, *args, namespace=namespace, room=room,
                           include_self=include_self, callback=callback,
                           ignore_queue=ignore_queue)