code: async def emit(self, event, data=None, room=None, skip_sid=None,
                     namespace=None, callback=None, **kwargs):
          
          namespace = namespace or '/'
          self.logger.info('emitting event "%s" to %s [%s]', event,
                           room or 'all', namespace)
          await self.manager.emit(event, data, namespace, room=room,
                                  skip_sid=skip_sid, callback=callback,
                                  **kwargs)
docs: Emit a custom event to one or more connected clients.
  
          :param event: The event name. It can be any string. The event names
                        ``'connect'``, ``'message'`` and ``'disconnect'`` are
                        reserved and should not be used.
          :param data: The data to send to the client or clients. Data can be of
                       type ``str``, ``bytes``, ``list`` or ``dict``. If a
                       ``list`` or ``dict``, the data will be serialized as JSON.
          :param room: The recipient of the message. This can be set to the
                       session ID of a client to address that client's room, or
                       to any custom room created by the application, If this
                       argument is omitted the event is broadcasted to all
                       connected clients.
          :param skip_sid: The session ID of a client to skip when broadcasting
                           to a room or to all clients. This can be used to
                           prevent a message from being sent to the sender.
          :param namespace: The Socket.IO namespace for the event. If this
                            argument is omitted the event is emitted to the
                            default namespace.
          :param callback: If given, this function will be called to acknowledge
                           the the client has received the message. The arguments
                           that will be passed to the function are those provided
                           by the client. Callback functions can only be used
                           when addressing an individual client.
          :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. It is recommended
                               to always leave this parameter with its default
                               value of ``False``.
  
          Note: this method is a coroutine.