WHOA if i got it right THIS ROCKS!
so basically the client exposes a DBus method to get notified by the engine
right? So the engine knows can target specific clients right? IF YES
I bow to your mighty implementation


2009/12/2 Mikkel Kamstrup Erlandsen <email address hidden>

> Mikkel Kamstrup Erlandsen has proposed merging
> lp:~kamstrup/zeitgeist/notification into lp:zeitgeist.
>
>    Requested reviews:
>    Zeitgeist-Engine (zeitgeist): thorough
> Related bugs:
>  #488967 Add event notification and subscription system
>  https://bugs.launchpad.net/bugs/488967
>
>
> The notification/monitoring branch looks very promising now and I'd like a
> more formal review now.
>
> What I do is add two new methods to the org.gnome.zeitgeist.Log interface:
>
> InstallMonitor(in o client_monitor_path, in E event_template)
> RemoveMonitor(in o client_monitor_path)
>
> The client_monitor_path points to a client side object that exposes the
> DBus interface org.gnome.zeitgeist.Monitor, which only has a single method:
>
> Notify(in aE events)
>
> I add some convenience methods in ZeitgeistClient to set up a monitor
> simply by calling: client.install_monitor(event_templates, notify_callback).
> Easy peasy lemon squeezy for application developers I hope.
>
> TODO: There are two missing items - which doesn't block a merge though
> IMHO:
>
>  - Unit test for RemoveMonitor and that monitors for crashing clients are
> cleaned up
>  - What to do in case of duplicate events when we notify? Or what to do
> about insertion errors causing dropped events? Right now I hook in at the
> remote.py level and that makes it a nice clean cut, but I can not detect
> these cases... I can hook in at the resonance_engine.py level and look for
> these details, but the logic will become a lot more complex...
> --
> https://code.launchpad.net/~kamstrup/zeitgeist/notification/+merge/15583<https://code.launchpad.net/%7Ekamstrup/zeitgeist/notification/+merge/15583>
> You are subscribed to branch lp:zeitgeist.
>
> === modified file '_zeitgeist/engine/Makefile.am'
> --- _zeitgeist/engine/Makefile.am       2009-11-26 17:32:59 +0000
> +++ _zeitgeist/engine/Makefile.am       2009-12-02 22:45:19 +0000
> @@ -3,5 +3,6 @@
>  app_PYTHON = \
>        __init__.py \
>        extension.py \
> +       notify.py \
>        resonance_engine.py \
>        remote.py
>
> === added file '_zeitgeist/engine/notify.py'
> --- _zeitgeist/engine/notify.py 1970-01-01 00:00:00 +0000
> +++ _zeitgeist/engine/notify.py 2009-12-02 22:45:19 +0000
> @@ -0,0 +1,209 @@
> +# -.- coding: utf-8 -.-
> +
> +# Zeitgeist
> +#
> +# Copyright © 2009 Mikkel Kamstrup Erlandsen <email address hidden>
> +#
> +# This program is free software: you can redistribute it and/or modify
> +# it under the terms of the GNU Lesser General Public License as published
> by
> +# the Free Software Foundation, either version 3 of the License, or
> +# (at your option) any later version.
> +#
> +# This program is distributed in the hope that it will be useful,
> +# but WITHOUT ANY WARRANTY; without even the implied warranty of
> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> +# GNU Lesser General Public License for more details.
> +#
> +# You should have received a copy of the GNU Lesser General Public License
> +# along with this program.  If not, see <http://www.gnu.org/licenses/>.
> +
> +import dbus
> +import logging
> +
> +logging.basicConfig(level=logging.DEBUG)
> +log = logging.getLogger("zeitgeist.notify")
> +
> +class _MonitorProxy (dbus.Interface):
> +       """
> +       Connection to a org.gnome.zeitgeist.Monitor interface running on
> some
> +       client to the Zeitgeist engine.
> +       """
> +
> +       def __init__ (self, owner, monitor_path, event_templates):
> +               """
> +               Create a new MonitorProxy for the unique DBus name *owner*
> on the
> +               path *monitor_path*. Note that the path points to an object
> +               living under *owner* and not necessarily inside the current
> +               process.
> +
> +               :param owner: Unique DBus name of the process owning the
> monitor
> +               :param monitor_path: The DBus object path to the monitor
> object
> +                   in the client process
> +               :param event_templates: List of event templates that any
> events
> +                   must match in order to notify this monitor
> +               :type event_templates: list of
> +                   :class:`Events <zeitgeist.datamodel.Event>`
> +               """
> +               bus = dbus.SessionBus()
> +               proxy = bus.get_object(owner, monitor_path)
> +               dbus.Interface.__init__(
> +                               self,
> +                               proxy,
> +                               "org.gnome.zeitgeist.Monitor"
> +               )
> +
> +               self._owner = owner
> +               self._path = monitor_path
> +               self._templates = event_templates
> +
> +       def __str__ (self):
> +               return "%s%s" % (self.owner, self.path)
> +
> +       def get_owner (self) : return self._owner
> +       owner = property(get_owner, doc="Read only property with the unique
> DBus name of the process owning the monitor")
> +
> +       def get_path (self) : return self._path
> +       path = property(get_path, doc="Read only property with the object
> path of the monitor in the process owning the monitor")
> +
> +       def __hash__ (self):
> +               return hash(_MonitorProxy.hash(self._owner, self._path))
> +
> +       def matches (self, event):
> +               """
> +               Returns True of this monitor has a template matching
> *event*
> +
> +               :param event: The event to check against the monitor's
> templates
> +               :type event: :class:`Event <zeitgeist.datamodel.Event>`
> +               """
> +               for tmpl in self._templates:
> +                       if event.matches_template(tmpl) : return True
> +               return False
> +
> +       def notify (self, events):
> +               """
> +               Asynchronously deliver a collection of events to the
> monitor
> +
> +               The events will not be filtered through the :meth:`matches`
> +               method. It is the responsability of the caller to do that.
> +               """
> +               for ev in events : ev._make_dbus_sendable()
> +               self.Notify(events,
> +                           reply_handler=self._notify_reply_handler,
> +                           error_handler=self._notify_error_handler)
> +
> +       @staticmethod
> +       def hash(owner, path):
> +               """
> +               Calculate an integer uniquely identifying the monitor based
> on
> +               the DBus name of the owner and object path of the monitor
> itself
> +               """
> +               return hash("%s#%s" % (owner, path))
> +
> +       def _notify_reply_handler (self):
> +               """
> +               Async reply handler for invoking Notify() over DBus
> +               """
> +               pass
> +
> +       def _notify_error_handler (self, error):
> +               """
> +               Async error handler for invoking Notify() over DBus
> +               """
> +               log.warn("Failed to deliver notification: %s" % error)
> +
> +class MonitorManager:
> +
> +       def __init__ (self):
> +               self._monitors = {} # hash -> Monitor
> +               self._connections = {} # owner -> list of paths
> +
> +               # Listen for disconnecting clients to clean up potential
> dangling monitors
> +               dbus.SessionBus().add_signal_receiver
> (self._name_owner_changed,
> +
>  signal_name="NameOwnerChanged",
> +
>  dbus_interface=dbus.BUS_DAEMON_IFACE,
> +                                                      arg2="")
> +
> +       def install_monitor (self, owner, monitor_path, event_templates):
> +               """
> +               Install a :class:`MonitorProxy` and set it up to receive
> +               notifications when events are pushed into the
> :meth;`dispatch`
> +               method.
> +
> +               Monitors will automatically be cleaned up if
> :const:`monitor.owner`
> +               disconnects from the bus. To manually remove a monitor call
> the
> +               :meth:`remove_monitor` on this object passing in
> +               :const:`monitor.owner` and :const:`monitor.path`.
> +
> +               :param owner: Unique DBus name of the process owning the
> monitor
> +               :type owner: string
> +               :param monitor_path: The DBus object path for the monitor
> object
> +                   in the client process
> +               :type monitor_path: String or :class:`dbus.ObjectPath`
> +               :param event_templates: A list of
> +                   :class:`Event <zeitgeist.datamodel.Event>` templates to
> match
> +               :returns: This method has no return value
> +               """
> +               monitor_key = _MonitorProxy.hash(owner, monitor_path)
> +               if monitor_key in self._monitors:
> +                       raise KeyError("Monitor for %s already installed at
> path %s" % (owner, monitor_path))
> +
> +               monitor = _MonitorProxy(owner, monitor_path,
> event_templates)
> +               self._monitors[monitor] = monitor
> +
> +               if not monitor.owner in self._connections:
> +                       self._connections[owner] = set()
> +
> +               self._connections[owner].add(monitor.path)
> +
> +       def remove_monitor (self, owner, monitor_path):
> +               """
> +               Remove an installed monitor.
> +
> +               :param owner: Unique DBus name of the process owning the
> monitor
> +               :type owner: string
> +               :param monitor_path: The DBus object path for the monitor
> object
> +                   in the client process
> +               :type monitor_path: String or :class:`dbus.ObjectPath`
> +               """
> +               log.debug("Removing monitor ", owner, path)
> +               mon = self._monitors.pop(_MonitorProxy.hash(owner,
> monitor_path))
> +
> +               if not mon:
> +                       raise KeyError("Unknown monitor %s for owner %s" %
> (monitor_path, owner))
> +
> +               conn = self._connections[owner]
> +               if conn : conn.remove(monitor_path)
> +
> +       def notify_monitors (self, events):
> +               """
> +               Send events to matching monitors.
> +               The monitors will only be notified about the events for
> which
> +               they have a matching template, ie.
> :meth:`MonitorProxy.matches`
> +               returns True.
> +
> +               :param events: The events to check against the monitor
> templates
> +               :type events: list of :class:`Events
> <zeitgeist.datamodel.Event>`
> +               """
> +               for mon in self._monitors.itervalues():
> +                       log.debug("Checking monitor %s" % mon)
> +                       matching_events = filter(mon.matches, events)
> +                       if matching_events :
> +                               log.debug("Notifying %s about %s events" %
> (mon, len(matching_events)))
> +                               mon.notify(matching_events)
> +
> +       def _name_owner_changed (self, owner, old, new):
> +               """
> +               Clean up monitors for processes disconnecting from the bus
> +               """
> +               # Don't proceed if this is a disconnect of an unknown
> connection
> +               if not owner in self._connections :
> +                       return
> +
> +               conn = self._connections[owner]
> +
> +               log.debug("Client disconnected %s" % owner)
> +               for path in conn:
> +                       self.remove_monitor(Monitor.hash(owner, path))
> +
> +               self._connections.pop(owner)
> +
>
> === modified file '_zeitgeist/engine/remote.py'
> --- _zeitgeist/engine/remote.py 2009-12-01 10:50:16 +0000
> +++ _zeitgeist/engine/remote.py 2009-12-02 22:45:19 +0000
> @@ -3,6 +3,7 @@
>  # Zeitgeist
>  #
>  # Copyright © 2009 Siegfried-Angel Gevatter Pujals <email address hidden>
> +# Copyright © 2009 Mikkel Kamstrup Erlandsen <email address hidden>
>  #
>  # This program is free software: you can redistribute it and/or modify
>  # it under the terms of the GNU Lesser General Public License as published
> by
> @@ -21,7 +22,9 @@
>  import dbus.service
>  import logging
>
> +from zeitgeist.datamodel import Event, Subject, TimeRange, StorageState,
> ResultType
>  from _zeitgeist.engine import get_default_engine
> +from _zeitgeist.engine.notify import MonitorManager
>  from zeitgeist.client import ZeitgeistDBusInterface
>  from _zeitgeist.singleton import SingletonApplication
>
> @@ -30,21 +33,6 @@
>  DBUS_INTERFACE = ZeitgeistDBusInterface.INTERFACE_NAME
>  SIG_EVENT = "asaasay"
>
> -def special_str(obj):
> -       """ Return a string representation of obj
> -       If obj is None, return an empty string.
> -       """
> -       return unicode(obj) if obj is not None else ""
> -
> -def make_dbus_sendable(event):
> -       for n, value in enumerate(event[0]):
> -               event[0][n] = special_str(value)
> -       for subject in event[1]:
> -               for n, value in enumerate(subject):
> -                       subject[n] = special_str(value)
> -       event[2] = special_str(event[2])
> -       return event
> -
>  class RemoteInterface(SingletonApplication):
>
>        _dbus_properties = {
> @@ -56,6 +44,7 @@
>        def __init__(self, start_dbus=True, mainloop=None):
>                SingletonApplication.__init__(self)
>                self._mainloop = mainloop
> +               self._notifications = MonitorManager()
>
>        # Reading stuff
>
> @@ -82,7 +71,8 @@
>                except ValueError:
>                        # This is what we want, it means that there are no
>                        # holes in the list
> -                       return [make_dbus_sendable(event) for event in
> events]
> +                       for ev in events : ev._make_dbus_sendable()
> +                       return events
>
>        @dbus.service.method(DBUS_INTERFACE,
>
>  in_signature="(xx)a("+SIG_EVENT+")uuu", out_signature="au")
> @@ -137,7 +127,13 @@
>                    the id of the existing event will be returned
>                :rtype: Array of unsigned 32 bits integers. DBus signature
> au.
>                """
> -               return _engine.insert_events(events)
> +               event_ids = _engine.insert_events(events)
> +
> +               # FIXME: Filter out duplicate- or failed event insertions
> +               events = map(Event, events)
> +               self._notifications.notify_monitors(events)
> +
> +               return event_ids
>
>        @dbus.service.method(DBUS_INTERFACE, in_signature="au",
> out_signature="")
>        def DeleteEvents(self, ids):
> @@ -166,8 +162,13 @@
>                as it will affect all applications using Zeitgeist"""
>                if self._mainloop:
>                        self._mainloop.quit()
> +<<<<<<< TREE
>
>        # Properties interface
> +=======
> +
> +       # Properties interface
> +>>>>>>> MERGE-SOURCE
>
>        @dbus.service.method(dbus_interface=dbus.PROPERTIES_IFACE,
>                                                 in_signature="ss",
> out_signature="v")
> @@ -190,3 +191,15 @@
>        def GetAll(self, interface_name):
>                return dict((k, v.fget(self)) for (k,v) in
> self._dbus_properties.items())
>
> +       # Notifications interface
> +
> +       @dbus.service.method(DBUS_INTERFACE,
> +                       in_signature="oa("+SIG_EVENT+")",
> sender_keyword="owner")
> +       def InstallMonitor(self, monitor_path, event_templates,
> owner=None):
> +               event_templates = map(Event, event_templates)
> +               self._notifications.install_monitor(owner, monitor_path,
> event_templates)
> +
> +       @dbus.service.method(DBUS_INTERFACE,
> +                       in_signature="o", sender_keyword="owner")
> +       def RemoveMonitor(self, monitor_path, owner=None):
> +               self._notifications.remove_monitor(owner, monitor_path)
>
> === modified file 'doc/dbus/source/index.rst'
> --- doc/dbus/source/index.rst   2009-11-30 21:46:25 +0000
> +++ doc/dbus/source/index.rst   2009-12-02 22:45:19 +0000
> @@ -68,6 +68,12 @@
>  .. autoclass:: ZeitgeistClient
>     :members:
>
> +Monitor
> ++++++++
> +
> +.. autoclass:: Monitor
> +    :members:
> +
>
>  .. module:: _zeitgeist.engine.remote
>
>
> === modified file 'test/datamodel-test.py'
> --- test/datamodel-test.py      2009-11-30 07:57:58 +0000
> +++ test/datamodel-test.py      2009-12-02 22:45:19 +0000
> @@ -7,7 +7,7 @@
>  sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
>
>  from zeitgeist.datamodel import *
> -
> +from testutils import parse_events
>  import unittest
>
>  class CategoryTest (unittest.TestCase):
> @@ -154,6 +154,12 @@
>
>                e.manifestation="ILLEGAL SNAFU"
>                self.assertFalse(e.matches_template(template))
> +
> +       def testTemplateFiltering(self):
> +               template =
> Event.new_for_values(interpretation="stfu:OpenEvent")
> +               events = parse_events("test/data/five_events.js")
> +               filtered_events = filter(template.matches_event, events)
> +               self.assertEquals(2, len(filtered_events))
>
>  if __name__ == '__main__':
>        unittest.main()
>
> === modified file 'test/remote-test.py'
> --- test/remote-test.py 2009-12-01 10:50:16 +0000
> +++ test/remote-test.py 2009-12-02 22:45:19 +0000
> @@ -111,5 +111,21 @@
>                result_events = self.getEventsAndWait(ids)
>                self.assertEquals(len(ids), len(result_events))
>
> +       def testMonitorEvents(self):
> +               result = []
> +               mainloop = gobject.MainLoop()
> +               tmpl =
> Event.new_for_values(interpretation="stfu:OpenEvent")
> +               events = parse_events("test/data/five_events.js")
> +
> +               def events_reply_handler(events):
> +                       result.extend(events)
> +                       mainloop.quit()
> +
> +               self.client.install_monitor([tmpl], events_reply_handler)
> +               self.client.insert_events(events)
> +               mainloop.run()
> +
> +               self.assertEquals(2, len(result))
> +
>  if __name__ == "__main__":
>        unittest.main()
>
> === modified file 'zeitgeist/client.py'
> --- zeitgeist/client.py 2009-12-01 10:49:34 +0000
> +++ zeitgeist/client.py 2009-12-02 22:45:19 +0000
> @@ -20,10 +20,12 @@
>  # along with this program.  If not, see <http://www.gnu.org/licenses/>.
>
>  import dbus
> +import dbus.service
>  import dbus.mainloop.glib
>  import logging
>  import os.path
>  import sys
> +import logging
>
>  from xml.dom.minidom import parseString as minidom_parse
>
> @@ -31,6 +33,11 @@
>
>  from zeitgeist.datamodel import Event, Subject, TimeRange, StorageState,
> ResultType
>
> +SIG_EVENT = "asaasay"
> +
> +logging.basicConfig(level=logging.DEBUG)
> +log = logging.getLogger("zeitgeist.client")
> +
>  class ZeitgeistDBusInterface(dbus.Interface):
>        """ Central DBus interface to the zeitgeist engine
>
> @@ -152,10 +159,72 @@
>                                self.INTERFACE_NAME
>                )
>
> +class Monitor (dbus.service.Object):
> +       """
> +       DBus object for monitoring the Zeitgeist log for certain types
> +       of events.
> +
> +       Monitors are normally instantiated indirectly by calling
> +       :meth:`ZeitgeistClient.install_monitor`.
> +
> +       It is important to understand that the Monitor instance lives on
> the
> +       client side, and expose a DBus service there, and the Zeitgeist
> engine
> +       calls back to the monitor when matching events are registered.
> +
> +       If you use Monitor objects as key in a :const:`dict` or
> :const:`set`
> +       their hash value is computed purely on their DBus path name.
> +       """
> +
> +       # Used in Monitor._next_path() to generate unique path names
> +       _last_path_id = 0
> +
> +       def __init__ (self, event_templates, callback, monitor_path=None):
> +               if not monitor_path:
> +                       monitor_path = Monitor._next_path()
> +               elif isinstance(monitor_path, (str, unicode)):
> +                       monitor_path = dbus.ObjectPath(monitor_path)
> +
> +               self._templates = event_templates
> +               self._path = monitor_path
> +               self._callback = callback
> +               dbus.service.Object.__init__(self, dbus.SessionBus(),
> monitor_path)
> +
> +
> +       def get_path (self): return self._path
> +       path = property(get_path, doc="Read only property with the DBus
> path of the monitor object")
> +
> +       def get_templates (self): return self._templates
> +       templates = property(get_templates, doc="Read only property with
> installed templates")
> +
> +       @dbus.service.method("org.gnome.zeitgeist.Monitor",
> +                            in_signature="a("+SIG_EVENT+")")
> +       def Notify(self, events):
> +               """
> +               Receive notification that a set of events matching the
> monitor's
> +               templates has been recorded in the log.
> +
> +               This method is the raw DBus callback and should normally
> not be
> +               overridden. Events are received via the *callback* argument
> given
> +               in the constructor to this class.
> +               """
> +               self._callback(map(Event, events))
> +
> +       def __hash__ (self):
> +               return hash(self._path)
> +
> +       @classmethod
> +       def _next_path(cls):
> +               """
> +               Generate a new unique DBus object path for a monitor
> +               """
> +               cls._last_path_id += 1
> +               return dbus.ObjectPath("/org/gnome/zeitgeist/monitor/%s" %
> cls._last_path_id)
> +
>  class ZeitgeistClient:
>        """
> -       Convenience APIs to have a Pythonic way to call the running
> Zeitgeist
> -       engine. For raw DBus access use the ZeitgeistDBusInterface class.
> +       Convenience APIs to have a Pythonic way to call and monitor the
> running
> +       Zeitgeist engine. For raw DBus access use the
> +       :class:`ZeitgeistDBusInterface` class.
>
>        Note that this class only does asynchronous DBus calls. This is
> almost
>        always the right thing to do. If you really want to do synchronous
> @@ -418,6 +487,57 @@
>                self._iface.GetEvents(event_ids,
>                                reply_handler=lambda raw :
> events_reply_handler(map(Event, raw)),
>                                error_handler=error_handler)
> +
> +       def install_monitor (self, event_templates, events_reply_handler,
> monitor_path=None):
> +               """
> +               Install a monitor in the Zeitgeist engine that calls back
> +               when events matching *event_templates* are logged. The
> matching
> +               is done exactly as in the *find_** family of methods and in
> +               :meth:`Event.matches_template
> <zeitgeist.datamodel.Event.matches_template>`
> +
> +               To remove a monitor call :meth:`remove_monitor` on the
> returned
> +               :class:`Monitor` instance.
> +
> +               :param event_templates: The event templates to look for
> +               :param events_reply_handler: Callback for receiving
> notifications
> +                   about matching events. The callback should take a list
> of Events
> +                   as its sole argument
> +               :param monitor_path: Optional argument specifying the DBus
> path
> +                   to install the client side monitor object on. If none
> is provided
> +                   the client will provide one for you namespaced under
> +                   /org/gnome/zeitgeist/monitor/*
> +               :returns: a :class:`Monitor`
> +               """
> +               self._check_list_or_tuple(event_templates)
> +               self._check_members(event_templates, Event)
> +               if not callable(events_reply_handler):
> +                       raise TypeError("Reply handler not callable, found
> %s" % events_reply_handler)
> +
> +               mon = Monitor(event_templates, events_reply_handler,
> monitor_path=monitor_path)
> +               self._iface.InstallMonitor(mon.path,
> +                                          mon.templates,
> +
>  reply_handler=self._void_reply_handler,
> +                                          error_handler=lambda err :
> log.warn("Error installing monitor: %s" % err))
> +               return mon
> +
> +       def remove_monitor (self, monitor):
> +               """
> +               Remove a :class:`Monitor` installed with
> :meth:`install_monitor`
> +
> +               :param monitor: Monitor to remove. Either as a
> :class:`Monitor`
> +                   instance or a DBus object path to the monitor either as
> a
> +                   string or :class:`dbus.ObjectPath`
> +               """
> +               if isinstance(monitor, (str,unicode)):
> +                       path = dbus.ObjectPath(monitor)
> +               elif isinstance(monitor, Monitor):
> +                       path = monitor.path
> +               else:
> +                       raise TypeError("Monitor, str, or unicode expected.
> Found %s" % type(monitor))
> +
> +               self._iface.RemoveMonitor(path,
> +
> reply_handler=self._void_reply_handler,
> +                                         error_handler=lambda err :
> log.warn("Error installing monitor: %s" % err))
>
>        def _check_list_or_tuple(self, collection):
>                """
>
> === modified file 'zeitgeist/datamodel.py'
> --- zeitgeist/datamodel.py      2009-12-01 13:07:14 +0000
> +++ zeitgeist/datamodel.py      2009-12-02 22:45:19 +0000
> @@ -789,6 +789,7 @@
>                data = self[0]
>                tdata = event_template[0]
>                for m in Event.Fields:
> +                       if m == Event.Timestamp : continue
>                        if tdata[m] and tdata[m] != data[m] : return False
>
>                # If template has no subjects we have a match
> @@ -803,3 +804,34 @@
>
>                # Template has subjects, but we never found a match
>                return False
> +
> +       def matches_event (self, event):
> +               """
> +               Interpret *self* as the template an match *event* against
> it.
> +               This method is the dual method of :meth:`matches_template`.
> +               """
> +               #print "T: %s" % self
> +               #print "E: %s" % event
> +               #print "------------"
> +               return event.matches_template(self)
> +
> +       def _special_str(self, obj):
> +               """ Return a string representation of obj
> +               If obj is None, return an empty string.
> +               """
> +               return unicode(obj) if obj is not None else ""
> +
> +       def _make_dbus_sendable(self):
> +               """
> +               Ensure that all fields in the event struct are non-None
> +               """
> +               for n, value in enumerate(self[0]):
> +                       self[0][n] = self._special_str(value)
> +               for subject in self[1]:
> +                       for n, value in enumerate(subject):
> +                               subject[n] = self._special_str(value)
> +               # The payload require special handling, since it is binary
> data
> +               # If there is indeed data here, we must not unicode encode
> it!
> +               if self[2] is None: self[2] = u""
> +
> +
>
>
>