docs: def event(self, event_data, priority="normal", event_method="EVENT"):
          """This function will send event packets to the server. This is the
          main method you would use to send data from your application to the
          server.
  
          Whenever an event is sent to the server, a universally unique event id
          (euuid) is created for each event and stored in the "event_uuids"
          dictionary. This dictionary contains a list of all events that are
          currently waiting for a response from the server. The event will only
          be removed from this dictionary if the server responds with LEGAL or
          ILLEGAL or if the request times out.
  
          Args:
            event_data (dict): The event data to send to the server. This data
              will be passed through the server's middleware to determine if the
              event is legal or not, and then processed by the server it is legal
            priority (string): The event's priority informs the server of whether
              or not the client is going to wait for a confirmation message from
              the server indicating whether its event was LEGAL or ILLEGAL.
              Setting this to "normal" informs the server that the client will
              wait for a response from the server before processing the event.
              Setting this to "high" informs the server that the client will NOT
              wait for a response. Defaults to "normal".
            event_method (string): The type of event to send to the server. Valid
              methods are "EVENT", "AUTH". Defaults to "EVENT".
  
          Returns:
            A universally unique identifier (uuid) of the event.
  
          Examples:
            >>> event_data
            >>> priority
  
          """
  
          logger.debug("event: " + str(event_data))
  
          # Generate an event UUID for this event
          euuid = uuid.uuid1()
          logger.debug("<%s> <euuid:%s> Sending event data to server: "
                 "%s" % (str(self.cuuid), str(euuid), str(self.server)))
          if not self.listener.listening:
              logger.warning("Neteria client is not listening.")
  
          # If we're not even registered, don't even bother.
          if not self.registered:
              logger.warning("<%s> <euuid:%s> Client is currently not registered. "
                              "Event not sent." % (str(self.cuuid), str(euuid)))
              return False
  
          # Send the event data to the server
          packet = {"method": event_method,
                    "cuuid": str(self.cuuid),
                    "euuid": str(euuid),
                    "event_data": event_data,
                    "timestamp": str(datetime.now()),
                    "retry": 0,
                    "priority": priority}
  
          self.listener.send_datagram(
              serialize_data(packet, self.compression,
                             self.encryption, self.server_key),
              self.server)
  
          logger.debug("<%s> Sending EVENT Packet: %s" % (str(self.cuuid),
                                                           pformat(packet)))
  
          # Set the sent event to our event buffer to see if we need to roll back
          # or anything
          self.event_uuids[str(euuid)] = packet
  
          # Now we need to reschedule a timeout/retransmit check
          logger.debug("<%s> Scheduling retry in %s seconds" % (str(self.cuuid),
                                                                 str(self.timeout)))
          self.listener.call_later(self.timeout, self.retransmit, packet)
  
          return euuid