docs: def notify(self, cuuid, event_data):
          """This function will send a NOTIFY event to a registered client.
  
          NOTIFY messages are nearly identical to EVENT messages, except that
          NOTIFY messages are always sent from server -> client. EVENT messages
          are always sent from client -> server. In addition to this difference,
          NOTIFY messages are not processed by a middleware to determine if
          they are legal or not, since all messages from the server should be
          considered LEGAL.
  
          Args:
            cuuid (string): The client uuid to send the event data to.
            event_data (any): The event data that we will be sending to the
              client.
  
          Returns:
            None
  
          """
  
          # Generate an event uuid for the notify event
          euuid = str(uuid.uuid1())
  
          # If the client uses encryption, get their key to encrypt
          if "encryption" in self.registry[cuuid]:
              client_key = self.registry[cuuid]["encryption"]
          else:
              client_key = None
  
          logger.debug("<%s> <%s> Sending NOTIFY event to client with event data: "
                       "%s" % (str(cuuid), str(euuid), pformat(event_data)))
  
          # Look up the host details based on cuuid
          try:
              ip_address = self.registry[cuuid]["host"]
          except KeyError:
              logger.warning("<%s> <%s> Host not found in registry! Transmit "
                             "Canceled" % (str(cuuid), str(euuid)))
              return False
          try:
              port = self.registry[cuuid]["port"]
          except KeyError:
              logger.warning("<%s> <%s> Port not found! Transmit "
                             "Canceled" % (str(cuuid), str(euuid)))
              return False
  
          # Set up the packet and address to send to
          packet = serialize_data({"method": "NOTIFY",
                                   "event_data": event_data,
                                   "euuid": euuid},
                                  self.compression,
                                  self.encryption, client_key)
          address = (ip_address, port)
  
          # If we're not already processing this event, store the event uuid
          # until we receive a confirmation from the client that it received our
          # notification.
          self.event_uuids[euuid] = 0	# This is the current retry attempt
          logger.debug("<%s> Currently processing events: "
                       "%s" % (cuuid, pformat(self.event_uuids)))
          logger.debug("<%s> New NOTIFY event being processed:" % cuuid)
          logger.debug("<%s> EUUID: %s" % (cuuid, euuid))
          logger.debug("<%s> Event Data: %s" % (cuuid, pformat(event_data)))
  
          # Send the packet to the client
          self.listener.send_datagram(packet, address)
  
          # Schedule a task to run in x seconds to check to see if we've timed
          # out in receiving a response from the client/
          self.listener.call_later(self.timeout, self.retransmit,
                                   {"euuid": euuid,
                                    "response": packet,
                                    "cuuid": cuuid})