* Remove all bindings

29 files changed, 0 insertions, 3794 deletions

diff --git a/python/.cvsignore b/python/.cvsignore
deleted file mode 100644
index cce7eeaf..00000000
--- a/python/.cvsignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.deps
-Makefile.in
-Makefile
-dbus_bindings.pxd
-*.lo
-*.la
-dbus_bindings.c
-dbus_glib_bindings.c
-*.pyc
-.libs
diff --git a/python/Makefile.am b/python/Makefile.am
deleted file mode 100644
index ea261cb1..00000000
--- a/python/Makefile.am
+++ /dev/null
@@ -1,56 +0,0 @@
-SUBDIRS=examples
-
-INCLUDES=-I$(srcdir)/$(top_builddir) -I$(srcdir)/$(top_builddir)/dbus $(DBUS_CLIENT_CFLAGS) $(PYTHON_INCLUDES) -DDBUS_COMPILATION=1
-
-dbusmoduledir = $(pyexecdir)
-dbusmodule_PYTHON = dbus.pth
-
-dbusdir = $(pyexecdir)/dbus
-dbus_PYTHON =		\
-	__init__.py 	\
-	_dbus.py 	\
-	decorators.py 	\
-	exceptions.py 	\
-	service.py 	\
-	proxies.py 	\
-	_util.py 	\
-	types.py 	\
-	matchrules.py 	\
-	glib.py 	\
-	introspect_parser.py
-
-dbusbindingsdir = $(pyexecdir)/dbus
-dbusbindings_LTLIBRARIES = dbus_bindings.la dbus_glib_bindings.la
-
-dbus_bindings_la_LDFLAGS = -module -avoid-version -fPIC -export-symbols-regex initdbus_bindings
-dbus_bindings_la_LIBADD = $(top_builddir)/dbus/libdbus-1.la
-nodist_dbus_bindings_la_SOURCES = dbus_bindings.c
-
-dbus_glib_bindings_la_LDFLAGS = -module -avoid-version -fPIC -export-symbols-regex initdbus_glib_bindings 
-dbus_glib_bindings_la_LIBADD = $(top_builddir)/dbus/libdbus-1.la $(top_builddir)/glib/libdbus-glib-1.la
-dbus_glib_bindings_la_CFLAGS = $(DBUS_GLIB_CFLAGS) $(DBUS_GLIB_TOOL_CFLAGS)
-nodist_dbus_glib_bindings_la_SOURCES = dbus_glib_bindings.c
-
-
-EXTRA_DIST = 			\
-	dbus_h_wrapper.h	\
-	dbus_bindings.pyx	\
-	dbus_glib_bindings.pyx  \
-	dbus_bindings.pxd.in	\
-	extract.py
-
-CLEANFILES =			\
-	dbus_bindings.pxd	\
-	dbus_bindings.c		\
-	dbus_glib_bindings.c	
-
-
-dbus_bindings.pxd: $(srcdir)/dbus_bindings.pxd.in $(srcdir)/extract.py
-	-$(PYTHON) $(srcdir)/extract.py $(srcdir)/dbus_bindings.pxd.in -I$(srcdir)/$(top_builddir)  -I$(srcdir) > $@.tmp && mv $@.tmp $@
-
-dbus_bindings.c: $(srcdir)/dbus_bindings.pyx dbus_bindings.pxd 
-	pyrexc $(srcdir)/dbus_bindings.pyx -I. -o ./dbus_bindings.c
-
-dbus_glib_bindings.c: $(srcdir)/dbus_glib_bindings.pyx dbus_bindings.pxd 
-	pyrexc $(srcdir)/dbus_glib_bindings.pyx  -I. -o ./dbus_glib_bindings.c
-
diff --git a/python/__init__.py b/python/__init__.py
deleted file mode 100644
index 7d937831..00000000
--- a/python/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from _dbus import *
-from types import *
-
-version = (0, 51, 0)
-_dbus_main_loop_setup_function = None
diff --git a/python/_dbus.py b/python/_dbus.py
deleted file mode 100644
index 7e17d9f6..00000000
--- a/python/_dbus.py
+++ /dev/null
@@ -1,308 +0,0 @@
-
-"""Module for high-level communication over the FreeDesktop.org Bus (DBus)
-
-DBus allows you to share and access remote objects between processes
-running on the desktop, and also to access system services (such as
-the print spool).
-
-To use DBus, first get a Bus object, which provides a connection to one
-of a few standard dbus-daemon instances that might be running. From the
-Bus you can get a RemoteService. A service is provided by an application or
-process connected to the Bus, and represents a set of objects. Once you
-have a RemoteService you can get a RemoteObject that implements a specific interface
-(an interface is just a standard group of member functions). Then you can call
-those member functions directly.
-
-You can think of a complete method call as looking something like:
-
-Bus:SESSION -> Service:org.gnome.Evolution -> Object:/org/gnome/Evolution/Inbox -> Interface: org.gnome.Evolution.MailFolder -> Method: Forward('message1', 'seth@gnome.org')
-
-This communicates over the SESSION Bus to the org.gnome.Evolution process to call the
-Forward method of the /org/gnome/Evolution/Inbox object (which provides the
-org.gnome.Evolution.MailFolder interface) with two string arguments.
-
-For example, the dbus-daemon itself provides a service and some objects:
-
-# Get a connection to the desktop-wide SESSION bus
-bus = dbus.Bus(dbus.Bus.TYPE_SESSION)
-
-# Get the service provided by the dbus-daemon named org.freedesktop.DBus
-dbus_service = bus.get_service('org.freedesktop.DBus')
-
-# Get a reference to the desktop bus' standard object, denoted
-# by the path /org/freedesktop/DBus. The object /org/freedesktop/DBus
-# implements the 'org.freedesktop.DBus' interface
-dbus_object = dbus_service.get_object('/org/freedesktop/DBus',
-                                       'org.freedesktop.DBus')
-
-# One of the member functions in the org.freedesktop.DBus interface
-# is ListServices(), which provides a list of all the other services
-# registered on this bus. Call it, and print the list.
-print(dbus_object.ListServices())
-"""
-
-import dbus
-import dbus_bindings
-import weakref
-
-from proxies import *
-from exceptions import *
-from matchrules import *
-
-class Bus(object):
-    """A connection to a DBus daemon.
-
-    One of three possible standard buses, the SESSION, SYSTEM,
-    or STARTER bus
-    """
-    TYPE_SESSION    = dbus_bindings.BUS_SESSION
-    TYPE_SYSTEM     = dbus_bindings.BUS_SYSTEM
-    TYPE_STARTER = dbus_bindings.BUS_STARTER
-
-    """bus_type=[Bus.TYPE_SESSION | Bus.TYPE_SYSTEM | Bus.TYPE_STARTER]
-    """
-
-    ProxyObjectClass = ProxyObject
-
-    START_REPLY_SUCCESS = dbus_bindings.DBUS_START_REPLY_SUCCESS
-    START_REPLY_ALREADY_RUNNING = dbus_bindings.DBUS_START_REPLY_ALREADY_RUNNING
-
-    _shared_instances = weakref.WeakValueDictionary()
-
-    def __new__(cls, bus_type=TYPE_SESSION, use_default_mainloop=True, private=False):
-        if (not private and bus_type in cls._shared_instances):
-            return cls._shared_instances[bus_type]
-
-        # this is a bit odd, but we create instances of the subtypes
-        # so we can return the shared instances if someone tries to
-        # construct one of them (otherwise we'd eg try and return an
-        # instance of Bus from __new__ in SessionBus). why are there
-        # three ways to construct this class? we just don't know.
-        if bus_type == cls.TYPE_SESSION:
-            subclass = SessionBus
-        elif bus_type == cls.TYPE_SYSTEM:
-            subclass = SystemBus
-        elif bus_type == cls.TYPE_STARTER:
-            subclass = StarterBus
-        else:
-            raise ValueError('invalid bus_type %s' % bus_type)
-
-        bus = object.__new__(subclass)
-
-        bus._bus_type = bus_type
-        bus._bus_names = weakref.WeakValueDictionary()
-        bus._match_rule_tree = SignalMatchTree()
-
-        # FIXME: if you get a starter and a system/session bus connection
-        # in the same process, it's the same underlying connection that
-        # is returned by bus_get, but we initialise it twice
-        bus._connection = dbus_bindings.bus_get(bus_type, private)
-        bus._connection.add_filter(bus._signal_func)
-
-        if use_default_mainloop:
-            func = getattr(dbus, "_dbus_mainloop_setup_function", None)
-            if func:
-                func(bus)
-
-        if not private:
-            cls._shared_instances[bus_type] = bus
-
-        return bus
-
-    def __init__(self, *args, **keywords):
-        # do nothing here because this can get called multiple times on the
-        # same object if __new__ returns a shared instance
-        pass
-
-    def close(self):
-        self._connection.close()
-
-    def get_connection(self):
-        return self._connection
-
-    def get_session(private=False):
-        """Static method that returns the session bus"""
-        return SessionBus(private=private)
-
-    get_session = staticmethod(get_session)
-
-    def get_system(private=False):
-        """Static method that returns the system bus"""
-        return SystemBus(private=private)
-
-    get_system = staticmethod(get_system)
-
-
-    def get_starter(private=False):
-        """Static method that returns the starter bus"""
-        return StarterBus(private=private)
-
-    get_starter = staticmethod(get_starter)
-
-
-    def get_object(self, named_service, object_path):
-        """Get a proxy object to call over the bus"""
-        return self.ProxyObjectClass(self, named_service, object_path)
-
-    def _create_args_dict(self, keywords):
-        args_dict = None 
-        for (key, value) in keywords.iteritems():
-            if key.startswith('arg'):
-                try:
-                    snum = key[3:]
-                    num = int(snum)
-
-                    if not args_dict:
-                        args_dict = {}
-
-                    args_dict[num] = value
-                except ValueError:
-                    raise TypeError("Invalid arg index %s"%snum)
-            elif key in ("sender_keyword", "path_keyword"):
-                pass
-            else:
-                raise TypeError("Unknown keyword %s"%(key)) 
-
-        return args_dict    
-
-    def add_signal_receiver(self, handler_function, 
-                                  signal_name=None,
-                                  dbus_interface=None,
-                                  named_service=None,
-                                  path=None,
-                                  **keywords):
-
-        args_dict = self._create_args_dict(keywords)
-
-        if (named_service and named_service[0] != ':'):
-            bus_object = self.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus')
-            named_service = bus_object.GetNameOwner(named_service, dbus_interface='org.freedesktop.DBus')
-        
-        match_rule = SignalMatchRule(signal_name, dbus_interface, named_service, path)
-
-        for kw in ("sender_keyword", "path_keyword"):
-            if kw in keywords:
-                setattr(match_rule, kw, keywords[kw])
-            else:
-                setattr(match_rule, kw, None)
-
-        if args_dict:
-            match_rule.add_args_match(args_dict)
-
-        match_rule.add_handler(handler_function)
-
-        self._match_rule_tree.add(match_rule)
-
-        dbus_bindings.bus_add_match(self._connection, repr(match_rule))
-
-    def remove_signal_receiver(self, handler_function, 
-                               signal_name=None,
-                               dbus_interface=None,
-                               named_service=None,
-                               path=None,
-                               **keywords):
-
-        args_dict = self._create_args_dict(keywords)
-    
-        if (named_service and named_service[0] != ':'):
-            bus_object = self.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus')
-            named_service = bus_object.GetNameOwner(named_service, dbus_interface='org.freedesktop.DBus')
-        
-        match_rule = SignalMatchRule(signal_name, dbus_interface, named_service, path)
-
-        if (args_dict):
-            match_rule.add_args_match(args_dict)
-
-        if (handler_function):
-            match_rule.add_handler(handler_function)
-        
-        self._match_rule_tree.remove(match_rule)
-        
-        #TODO we leak match rules in the lower level bindings.  We need to ref count them
-
-    def get_unix_user(self, named_service):
-        """Get the unix user for the given named_service on this Bus"""
-        return dbus_bindings.bus_get_unix_user(self._connection, named_service)
-    
-    def _signal_func(self, connection, message):
-        if (message.get_type() != dbus_bindings.MESSAGE_TYPE_SIGNAL):
-            return dbus_bindings.HANDLER_RESULT_NOT_YET_HANDLED
-        
-        dbus_interface      = message.get_interface()
-        named_service       = message.get_sender()
-        path                = message.get_path()
-        signal_name         = message.get_member()
-
-        match_rule = SignalMatchRule(signal_name, dbus_interface, named_service, path)
-
-        self._match_rule_tree.exec_matches(match_rule, message)
-
-    def start_service_by_name(self, named_service):
-        return dbus_bindings.bus_start_service_by_name(self._connection, named_service)
-
-    def __repr__(self):
-        if self._bus_type == self.TYPE_SESSION:
-            name = 'SESSION'
-        elif self._bus_type == self.TYPE_SYSTEM:
-            name = 'SYSTEM'
-        elif self._bus_type == self.TYPE_STARTER:
-            name = 'STARTER'
-        else:
-            assert False, 'Unable to represent unknown bus type.'
-
-        return '<dbus.Bus on %s at %#x>' % (name, id(self))
-    __str__ = __repr__
-
-class SystemBus(Bus):
-    """The system-wide message bus
-    """
-    def __new__(cls, use_default_mainloop=True, private=False):
-        return Bus.__new__(cls, Bus.TYPE_SYSTEM, use_default_mainloop, private)
-
-class SessionBus(Bus):
-    """The session (current login) message bus
-    """
-    def __new__(cls, use_default_mainloop=True, private=False):
-        return Bus.__new__(cls, Bus.TYPE_SESSION, use_default_mainloop, private)
-
-class StarterBus(Bus):
-    """The bus that activated this process (if
-    this process was launched by DBus activation)
-    """
-    def __new__(cls, use_default_mainloop=True, private=False):
-        return Bus.__new__(cls, Bus.TYPE_STARTER, use_default_mainloop, private)
-
-class Interface:
-    """An interface into a remote object
-
-    An Interface can be used to wrap ProxyObjects
-    so that calls can be routed to their correct
-    dbus interface
-    """
-
-    def __init__(self, object, dbus_interface):
-        self._obj = object
-        self._dbus_interface = dbus_interface
-
-    def connect_to_signal(self, signal_name, handler_function, dbus_interface = None, **keywords):
-        if not dbus_interface:
-            dbus_interface = self._dbus_interface
-            
-        self._obj.connect_to_signal(signal_name, handler_function, dbus_interface, **keywords)
-
-    def __getattr__(self, member, **keywords):
-        if (keywords.has_key('dbus_interface')):
-            _dbus_interface = keywords['dbus_interface']
-        else:
-            _dbus_interface = self._dbus_interface
-
-        if member == '__call__':
-            return object.__call__
-        else:
-            ret = self._obj.__getattr__(member, dbus_interface=_dbus_interface)
-            return ret
-
-    def __repr__(self):
-        return '<Interface %r implementing %r at %#x>'%(
-        self._obj, self._dbus_interface, id(self))
-    __str__ = __repr__
diff --git a/python/_util.py b/python/_util.py
deleted file mode 100644
index c254178e..00000000
--- a/python/_util.py
+++ /dev/null
@@ -1,13 +0,0 @@
-import re
-from exceptions import ValidationException
-
-def _validate_interface_or_name(value):
-    elements = value.split('.')
-    if len(elements) <= 1:
-        raise ValidationException("%s must contain at least two elements seperated by a period ('.')"%(value))
-
-    validate = re.compile('[A-Za-z][\w_]*')
-    for element in elements:
-        if not validate.match(element):
-            raise ValidationException("Element %s of %s has invalid characters"%(element ,value))
-
diff --git a/python/dbus.pth b/python/dbus.pth
deleted file mode 100644
index e2182f1e..00000000
--- a/python/dbus.pth
+++ /dev/null
@@ -1 +0,0 @@
-dbus
diff --git a/python/dbus_bindings.pxd.in b/python/dbus_bindings.pxd.in
deleted file mode 100644
index f1707208..00000000
--- a/python/dbus_bindings.pxd.in
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "dbus_h_wrapper.h"
-
-cdef class Connection:
-    cdef DBusConnection *conn
-
-    cdef __cinit__(self, address, DBusConnection *_conn)
-    cdef _set_conn(self, DBusConnection *conn)
-    cdef DBusConnection *_get_conn(self)
diff --git a/python/dbus_bindings.pyx b/python/dbus_bindings.pyx
deleted file mode 100644
index c29dea2d..00000000
--- a/python/dbus_bindings.pyx
+++ /dev/null
@@ -1,1849 +0,0 @@
-# -*- Mode: Python -*-
-
-# jdahlin is the most coolest and awesomest person in the world
-# and wrote all the good parts of this code. all the bad parts
-# where python conditionals have a ( ) around them, thus violating
-# PEP-8 were written by the lame wannabe python programmer seth
-
-#FIXME: find memory leaks that I am sure exist
-
-cdef extern from "sys/types.h":
-    ctypedef size_t
-    ctypedef __int64_t
-    ctypedef __uint64_t
-
-cdef extern from "stdlib.h":
-    cdef void *malloc(size_t size)
-    cdef void free(void *ptr)
-    cdef void *calloc(size_t nmemb, size_t size)
-
-cdef extern from "Python.h":
-    void Py_XINCREF (object)
-    void Py_XDECREF (object)
-    object PyString_FromStringAndSize(char *, int)
-    ctypedef void *PyGILState_STATE
-    void PyErr_Clear()
-    PyGILState_STATE PyGILState_Ensure()
-    void PyGILState_Release(PyGILState_STATE)
-
-ctypedef struct DBusError:
-    char *name
-    char *message
-    unsigned int dummy1 
-    unsigned int dummy2
-    unsigned int dummy3
-    unsigned int dummy4
-    unsigned int dummy5
-    void *padding1
-    
-ctypedef struct DBusMessageIter:
-    void *dummy1
-    void *dummy2
-    dbus_uint32_t dummy3
-    int dummy4
-    int dummy5
-    int dummy6
-    int dummy7
-    int dummy8
-    int dummy9
-    int dummy10
-    int dummy11
-    int pad1
-    int pad2
-    void *pad3
-
-ctypedef struct DBusObjectPathVTable:
-  DBusObjectPathUnregisterFunction   unregister_function
-  DBusObjectPathMessageFunction      message_function
-  void (* dbus_internal_pad1) (void *)
-  void (* dbus_internal_pad2) (void *)
-  void (* dbus_internal_pad3) (void *)
-  void (* dbus_internal_pad4) (void *)
-
-class DBusException(Exception):
-    pass
-
-class ConnectionError(Exception):
-    pass
-
-class ObjectPath(str):
-    def __init__(self, value):
-        str.__init__(self, value)
-
-class ByteArray(str):
-    def __init__(self, value):
-        str.__init__(self, value)
-
-class SignatureIter(object):
-    def __init__(self, string):
-        object.__init__(self)
-        self.remaining = string
-
-    def next(self):
-        if self.remaining == '':
-            raise StopIteration
-
-        signature = self.remaining
-        block_depth = 0
-        block_type = None
-        end = len(signature)
-
-        for marker in range(0, end):
-            cur_sig = ord(signature[marker])
-
-            if cur_sig == TYPE_ARRAY:
-                pass
-            elif cur_sig == DICT_ENTRY_BEGIN or cur_sig == STRUCT_BEGIN:
-                if block_type == None:
-                    block_type = cur_sig
-
-                if block_type == cur_sig:
-                    block_depth = block_depth + 1
-
-            elif cur_sig == DICT_ENTRY_END:
-                if block_type == DICT_ENTRY_BEGIN:
-                    block_depth = block_depth - 1
-
-                if block_depth == 0:
-                    end = marker
-                    break
-
-            elif cur_sig == STRUCT_END:
-                if block_type == STRUCT_BEGIN:
-                    block_depth = block_depth - 1
-
-                if block_depth == 0:
-                    end = marker
-                    break
-
-            else:
-                if block_depth == 0:
-                    end = marker
-                    break
-
-        end = end + 1
-        self.remaining = signature[end:]
-        return Signature(signature[0:end])
-
-class Signature(str):
-    """An iterable method signature. Iterating gives the signature of each
-    argument in turn."""
-    def __init__(self, value):
-        return str.__init__(self, value)
-
-    def __iter__(self):
-        return SignatureIter(self)
-
-class VariantSignature(object):
-    """A fake method signature which when iterated, is an endless stream
-    of variants (handy with zip()). It has no string representation."""
-    def __iter__(self):
-        return self
-
-    def next(self):
-        return 'v'
-
-class Byte(int):
-    def __init__(self, value):
-        int.__init__(self, value)
-
-class Boolean(int):
-    def __init__(self, value):
-        int.__init__(self, value)
-
-class Int16(int):
-    def __init__(self, value):
-        int.__init__(self, value)
-
-class UInt16(int):
-    def __init__(self, value):
-        if value < 0:
-            raise TypeError('Unsigned integers must not have a negitive value') 
-        int.__init__(self, value)
-
-class Int32(int):
-    def __init__(self, value):
-        int.__init__(self, value)
-
-class UInt32(long):
-    def __init__(self, value):
-        if value < 0:
-            raise TypeError('Unsigned integers must not have a negitive value') 
-        long.__init__(self, value)
-
-class Int64(long):
-    def __init__(self, value):
-        long.__init__(self, value)
-
-class UInt64(long):
-    def __init__(self, value):
-        if value < 0:
-            raise TypeError('Unsigned integers must not have a negitive value') 
-        long.__init__(self, value)
-
-class Double(float):
-    def __init__(self, value):
-        float.__init__(self, value)
-
-class String(unicode):
-    def __init__(self, value):
-        unicode.__init__(self, value)
-
-class Array(list):
-    def __init__(self, value, type=None, signature=None):
-        if signature and type:
-            raise TypeError('Can not mix type and signature arguments in a D-BUS Array')
-    
-        self.type = type
-        self.signature = signature
-        list.__init__(self, value)
-
-class Variant:
-    def __init__(self, value, type=None, signature=None):
-        self.value = value
-        if signature and type:
-            raise TypeError('Can not mix type and signature arguments in a D-BUS Variant')
-
-        self.type = type
-        self.signature = signature
-
-    def __repr__(self):
-        return repr(self.value)
-
-    def __str__(self):
-        return str(self.value)
-
-class Struct(tuple):
-    def __init__(self, value):
-        tuple.__init__(self, value)
-
-class Dictionary(dict):
-    def __init__(self, value, key_type=None, value_type=None, signature=None):
-        if key_type and not value_type:
-             raise TypeError('When specifying a key_type you must also have a value_type in a D-BUS Dictionary')
-        elif value_type and not key_type:
-             raise TypeError('When specifying a value_type you must also have a key_type in a D-BUS Dictionary')
-        elif key_type and signature:
-              raise TypeError('Can not mix type arguments with signature arguments in a D-BUS Dictionary')
-              
-        self.key_type = key_type
-        self.value_type = value_type
-        self.signature = signature
-        dict.__init__(self, value)
-
-#forward delcerations
-cdef class Message
-cdef class PendingCall
-cdef class Watch
-cdef class MessageIter
-
-cdef void _GIL_safe_cunregister_function_handler (DBusConnection *connection,
-                                                  void *user_data):
-    cdef Connection conn
-
-    tup = <object>user_data
-    assert (type(tup) == tuple)    
-    function = tup[1]
-    conn = Connection()
-    conn.__cinit__(None, connection)
-
-    args = (conn)
-    function(*args)
-    Py_XDECREF(tup) 
-
-cdef void cunregister_function_handler (DBusConnection *connection,
-                                        void *user_data):
-    cdef PyGILState_STATE gil
-    gil = PyGILState_Ensure()
-    try:
-        _GIL_safe_cunregister_function_handler (connection, user_data);
-    finally:
-        PyGILState_Release(gil)
-
-
-
-cdef DBusHandlerResult _GIL_safe_cmessage_function_handler ( 
-                                                  DBusConnection *connection,
-                                                  DBusMessage *msg,
-                                                  void *user_data):
-    cdef Connection conn
-    cdef Message message
-
-    tup = <object>user_data
-    assert (type(tup) == tuple)
-    function = tup[0]
-    message = EmptyMessage()
-
-    #we don't own the message so we need to ref it
-    dbus_message_ref(msg)
-    message._set_msg(msg)
-    conn = Connection()
-    conn.__cinit__(None, connection)
-    args = (conn,
-            message)
- 
-    retval = function(*args)
-
-    if (retval == None):
-        retval = DBUS_HANDLER_RESULT_HANDLED
-    return retval
-
-cdef DBusHandlerResult cmessage_function_handler (DBusConnection *connection,
-                                                  DBusMessage *msg,
-                                                  void *user_data):
-    cdef PyGILState_STATE gil
-    gil = PyGILState_Ensure()
-    try:
-        return _GIL_safe_cmessage_function_handler (connection, msg, user_data);
-    finally:
-        PyGILState_Release(gil)
-
-
-cdef class Connection:
-    def __init__(self, address=None, Connection _conn=None):
-        cdef DBusConnection *c_conn
-        cdef char *c_address
-        c_conn=NULL
-        self.conn = NULL
-        if (_conn != None):
-            c_conn = _conn.conn
-
-        if (address != None or _conn != None):
-            self.__cinit__(c_address, c_conn)
-
-    # hack to be able to pass in a c pointer to the constructor
-    # while still alowing python programs to create a Connection object
-    cdef __cinit__(self, address, DBusConnection *_conn):
-        cdef DBusError error
-        dbus_error_init(&error)
-        if _conn != NULL:
-            self.conn = _conn
-            dbus_connection_ref(self.conn)
-        else:
-            self.conn = dbus_connection_open(address,
-                                         &error)
-            if dbus_error_is_set(&error):
-                errormsg = error.message
-                dbus_error_free (&error)
-                raise DBusException, errormsg
-
-    def __dealloc__(self):
-        if self.conn != NULL:
-            dbus_connection_unref(self.conn)
-
-    cdef _set_conn(self, DBusConnection *conn):
-        self.conn = conn
-    
-    cdef DBusConnection *_get_conn(self):
-        return self.conn
-    
-    def get_unique_name(self):
-        return bus_get_unique_name(self)
-
-    def close(self):
-        dbus_connection_close(self.conn)
-
-    def get_is_connected(self):
-        return dbus_connection_get_is_connected(self.conn)
-    
-    def get_is_authenticated(self):
-        return dbus_connection_get_is_authenticated(self.conn)
-
-    def flush(self):
-        dbus_connection_flush(self.conn)
-
-    def borrow_message(self):
-        cdef Message m
-        m = EmptyMessage()
-        m._set_msg(dbus_connection_borrow_message(self.conn))
-        return m
-    
-    def return_message(self, Message message):
-        cdef DBusMessage *msg
-        msg = message._get_msg()
-        dbus_connection_return_message(self.conn, msg)
-
-    def steal_borrowed_message(self, Message message):
-        cdef DBusMessage *msg
-        msg = message._get_msg()
-        dbus_connection_steal_borrowed_message(self.conn,
-                                               msg)
-    
-    def pop_message(self):
-        cdef DBusMessage *msg
-        cdef Message m
- 
-        msg = dbus_connection_pop_message(self.conn)
-        if msg != NULL:
-            m = EmptyMessage()
-            m._set_msg(msg)
-        else:
-            m = None
-        return m        
-
-    def get_dispatch_status(self):
-        return dbus_connection_get_dispatch_status(self.conn)
-    
-    def dispatch(self):
-        return dbus_connection_dispatch(self.conn)
-
-    def send(self, Message message):
-        #cdef dbus_uint32_t client_serial
-        #if type(message) != Message:
-        #    raise TypeError
-        cdef DBusMessage *msg
-        msg = message._get_msg()
-        retval = dbus_connection_send(self.conn,
-                                      msg,
-                                      NULL)
-        return retval
-
-    def send_with_reply_handlers(self, Message message, timeout_milliseconds, reply_handler, error_handler):
-        retval = False
-        try:
-            (retval, pending_call) = self.send_with_reply(message, timeout_milliseconds)
-            if pending_call:
-                pending_call.set_notify(reply_handler, error_handler)
-        except Exception, e:
-            error_handler(e)
-            
-        return (retval, pending_call)
-
-    def send_with_reply(self, Message message, timeout_milliseconds):
-        cdef dbus_bool_t retval
-        cdef DBusPendingCall *cpending_call
-        cdef DBusMessage *msg
-        cdef PendingCall pending_call
-
-        cpending_call = NULL
-        
-        msg = message._get_msg()
-
-        retval = dbus_connection_send_with_reply(self.conn,
-                                                 msg,
-                                                 &cpending_call,
-                                                 timeout_milliseconds)
-
-        if (cpending_call != NULL):
-            pending_call = PendingCall()
-            pending_call.__cinit__(cpending_call)
-        else:
-            pending_call = None
-
-        return (retval, pending_call)
-                                
-    def send_with_reply_and_block(self, Message message,
-                                  timeout_milliseconds=-1):
-        cdef DBusMessage * retval
-        cdef DBusError error
-        cdef DBusMessage *msg
-        cdef Message m
-
-        dbus_error_init(&error)
-
-        msg = message._get_msg()
-
-        retval = dbus_connection_send_with_reply_and_block(
-            self.conn,
-            msg,
-            timeout_milliseconds,
-            &error)
-
-        if dbus_error_is_set(&error):
-            errormsg = error.message
-            dbus_error_free (&error)
-            raise DBusException, errormsg
-
-        assert(retval != NULL)
-
-        m = EmptyMessage()
-        m._set_msg(retval)
-
-        return m
-
-    def set_watch_functions(self, add_function, remove_function, data):
-        pass
-
-    def set_timeout_functions(self, add_function, remove_function, data):
-        pass
-
-    def set_wakeup_main_function(self, wakeup_main_function, data):
-        pass
-
-    # FIXME: set_dispatch_status_function, get_unix_user, set_unix_user_function
-
-    def add_filter(self, filter_function):
-        user_data = (filter_function,)
-        Py_XINCREF(user_data)
-       
-        return dbus_connection_add_filter(self.conn,
-                                          cmessage_function_handler,
-                                          <void*>user_data,
-                                          NULL)
-
-
-    #FIXME: remove_filter
-    #       this is pretty tricky, we want to only remove the filter
-    #       if we truly have no more calls to our message_function_handler...ugh
-
-    def set_data(self, slot, data):
-        pass
-
-    def get_data(self, slot):
-        pass
-
-    def set_max_message_size(self, size):
-        dbus_connection_set_max_message_size(self.conn, size)
-
-    def get_max_message_size(self):
-        return dbus_connection_get_max_message_size(self.conn)
-
-    def set_max_received_size(self, size):
-        dbus_connection_set_max_received_size(self.conn, size)
-
-    def get_max_received_size(self):
-        return dbus_connection_get_max_received_size(self.conn)
-
-    def get_outgoing_size(self):
-        return dbus_connection_get_outgoing_size(self.conn)    
-
-    # preallocate_send, free_preallocated_send, send_preallocated
-
-    def register_object_path(self, path, unregister_cb, message_cb):
-        cdef DBusObjectPathVTable cvtable
-        
-        cvtable.unregister_function = cunregister_function_handler 
-        cvtable.message_function    = cmessage_function_handler
-
-        user_data = (message_cb, unregister_cb)
-        Py_XINCREF(user_data)
-        
-        return dbus_connection_register_object_path(self.conn, path, &cvtable,
-                                                    <void*>user_data) 
-
-    def register_fallback(self, path, unregister_cb, message_cb):
-        cdef DBusObjectPathVTable cvtable
-
-        cvtable.unregister_function = cunregister_function_handler 
-        cvtable.message_function    = cmessage_function_handler
-
-        user_data = (message_cb, unregister_cb)
-        Py_XINCREF(user_data)
-       
-        return dbus_connection_register_fallback(self.conn, path, &cvtable,
-                                                 <void*>user_data) 
-
-    #FIXME: unregister_object_path , see problems with remove_filter
-
-    def list_registered (self, parent_path):
-        cdef char **cchild_entries
-        cdef dbus_bool_t retval
-        
-        retval = dbus_connection_list_registered(self.conn, parent_path, &cchild_entries)
-
-        if (not retval):
-            #FIXME: raise out of memory exception?
-            return None
-
-        i = 0
-        child_entries = []
-
-        while (cchild_entries[i] != NULL):
-            child_entries.append(cchild_entries[i])
-            i = i + 1
-
-        dbus_free_string_array(cchild_entries)
-
-        return child_entries
-
-cdef void _GIL_safe_pending_call_notification (DBusPendingCall *pending_call, 
-                                               void *user_data):
-    cdef DBusMessage *dbus_message
-    cdef Message message
-  
-    (reply_handler, error_handler) = <object>user_data
-   
-    dbus_message = dbus_pending_call_steal_reply(pending_call)
-    message = EmptyMessage()
-    message._set_msg(dbus_message)
-
-    type = message.get_type()
-
-    if type == MESSAGE_TYPE_METHOD_RETURN:
-        args = message.get_args_list()
-        reply_handler(*args)
-    elif type == MESSAGE_TYPE_ERROR:
-        args = message.get_args_list()
-        if len(args) > 0:
-            error_handler(DBusException(args[0]))
-        else:
-            error_handler(DBusException(""))
-    else:
-        error_handler(DBusException('Unexpected Message Type: ' + message.type_to_name(type)))
-
-    dbus_pending_call_unref(pending_call)
-    Py_XDECREF(<object>user_data)
-
-cdef void _pending_call_notification(DBusPendingCall *pending_call, 
-                                     void *user_data):
-    cdef PyGILState_STATE gil
-    gil = PyGILState_Ensure()
-    try:
-        _GIL_safe_pending_call_notification (pending_call, user_data);
-    finally:
-        PyGILState_Release(gil)
-
-cdef void _pending_call_free_user_data(void *data):
-    call_tuple = <object>data
-    Py_XDECREF(call_tuple)
-
-cdef class PendingCall:
-    cdef DBusPendingCall *pending_call
-
-    def __init__(self, PendingCall _pending_call=None):
-        self.pending_call = NULL
-        if (_pending_call != None):
-            self.__cinit__(_pending_call.pending_call)
-
-    cdef void __cinit__(self, DBusPendingCall *_pending_call):
-        self.pending_call = _pending_call
-        dbus_pending_call_ref(self.pending_call)
-
-    def __dealloc__(self):
-        if self.pending_call != NULL:
-            dbus_pending_call_unref(self.pending_call)
-
-    cdef DBusPendingCall *_get_pending_call(self):
-        return self.pending_call
-
-    def cancel(self):
-        dbus_pending_call_cancel(self.pending_call)
-
-    def get_completed(self):
-        return dbus_pending_call_get_completed(self.pending_call)
-
-    def get_reply(self):
-        cdef Message message
-        message = EmptyMessage()
-        message._set_msg(dbus_pending_call_steal_reply(self.pending_call))
-        return message
-
-    def block(self):
-        dbus_pending_call_block(self.pending_call)
-
-    def set_notify(self, reply_handler, error_handler):
-        user_data = (reply_handler, error_handler)
-        Py_XINCREF(user_data)
-        dbus_pending_call_ref(self.pending_call)
-        dbus_pending_call_set_notify(self.pending_call, _pending_call_notification, 
-                                     <void *>user_data, _pending_call_free_user_data)
-        
-
-cdef class Watch:
-    cdef DBusWatch* watch
-
-    def __init__(self):
-        pass
-
-    cdef __cinit__(self, DBusWatch *cwatch):
-        self.watch = cwatch
-
-    def get_fd(self):
-        return dbus_watch_get_fd(self.watch)
-
-    # FIXME: not picked up correctly by extract.py
-    #def get_flags(self):
-    #    return dbus_watch_get_flags(self.watch)
-
-    def handle(self, flags):
-        return dbus_watch_handle(self.watch, flags)
-
-    def get_enabled(self):
-        return dbus_watch_get_enabled(self.watch)
-    
-cdef class MessageIter:
-    cdef DBusMessageIter *iter
-    cdef DBusMessageIter real_iter
-    cdef dbus_uint32_t level
-
-    def __init__(self, level=0):
-        self.iter = &self.real_iter
-        self.level = level
-        if(self.level > 32):
-            raise TypeError, 'Type recurion is too deep' 
-
-    cdef __cinit__(self, DBusMessageIter *iter):
-        self.real_iter = iter[0]
-
-    cdef DBusMessageIter *_get_iter(self):
-        return self.iter
-
-    def has_next(self):
-        return dbus_message_iter_has_next(self.iter)
-    
-    def next(self):
-        return dbus_message_iter_next(self.iter)
-
-    def get(self, arg_type=None):
-        if(arg_type == None):
-            arg_type = self.get_arg_type()
-
-        if arg_type == TYPE_INVALID:
-            raise TypeError, 'Invalid arg type in MessageIter'
-        elif arg_type == TYPE_STRING:
-            retval = self.get_string()
-        elif arg_type == TYPE_INT16:
-            retval = self.get_int16()
-        elif arg_type == TYPE_UINT16:
-            retval = self.get_uint16()
-        elif arg_type == TYPE_INT32:
-            retval = self.get_int32()
-        elif arg_type == TYPE_UINT32:
-            retval = self.get_uint32()
-        elif arg_type == TYPE_INT64:
-            retval = self.get_int64()
-        elif arg_type == TYPE_UINT64:
-            retval = self.get_uint64()
-        elif arg_type == TYPE_DOUBLE:
-            retval = self.get_double()
-        elif arg_type == TYPE_BYTE:
-            retval = self.get_byte()
-        elif arg_type == TYPE_BOOLEAN:
-            retval = self.get_boolean()
-        elif arg_type == TYPE_SIGNATURE:
-            retval = self.get_signature()
-        elif arg_type == TYPE_ARRAY:
-            array_type = self.get_element_type()
-            if array_type == TYPE_DICT_ENTRY:
-                retval = self.get_dict()
-            else:
-                retval = self.get_array(array_type)
-        elif arg_type == TYPE_OBJECT_PATH:
-            retval = self.get_object_path()
-        elif arg_type == TYPE_STRUCT:
-            retval = self.get_struct()
-        elif arg_type == TYPE_VARIANT:
-            retval = self.get_variant()
-        elif arg_type == TYPE_DICT_ENTRY:
-            raise TypeError, 'Dictionary Entries can only appear as part of an array container'
-        else:
-            raise TypeError, 'Unknown arg type %d in MessageIter' % (arg_type)
-
-        return retval
-
-    def get_arg_type(self):
-        return dbus_message_iter_get_arg_type(self.iter)
-
-    def get_element_type(self):
-        return dbus_message_iter_get_element_type(self.iter)
-
-    def get_byte(self):
-        cdef unsigned char c_val
-        dbus_message_iter_get_basic(self.iter, <unsigned char *>&c_val)
-        return c_val
-
-    def get_boolean(self):
-        cdef dbus_bool_t c_val
-        dbus_message_iter_get_basic(self.iter, <dbus_bool_t *>&c_val)
-
-        if c_val:
-            return True
-        else:
-            return False 
-
-    def get_signature(self):
-        signature_string = self.get_string()
-        return Signature(signature_string)
-
-    def get_int16(self):
-        cdef dbus_int16_t c_val
-        dbus_message_iter_get_basic(self.iter, <dbus_int16_t *>&c_val)
-
-        return c_val
-
-    def get_uint16(self):
-        cdef dbus_uint16_t c_val
-        dbus_message_iter_get_basic(self.iter, <dbus_uint16_t *>&c_val)
-        return c_val
-
-    def get_int32(self):
-        cdef dbus_int32_t c_val
-        dbus_message_iter_get_basic(self.iter, <dbus_int32_t *>&c_val)
-        return c_val
-        
-    def get_uint32(self):
-        cdef dbus_uint32_t c_val
-        dbus_message_iter_get_basic(self.iter, <dbus_uint32_t *>&c_val)
-        return c_val
-        
-    def get_int64(self):
-        cdef dbus_int64_t c_val
-        dbus_message_iter_get_basic(self.iter, <dbus_int64_t *>&c_val)
-        return c_val
-
-    def get_uint64(self):
-        cdef dbus_uint64_t c_val
-        dbus_message_iter_get_basic(self.iter, <dbus_uint64_t *>&c_val)
-        return c_val
-
-    def get_double(self):
-        cdef double c_val
-        dbus_message_iter_get_basic(self.iter, <double *>&c_val)
-        return c_val
-
-    def get_string(self):
-        cdef char *c_str
-        dbus_message_iter_get_basic(self.iter, <char **>&c_str)
-        ret = c_str.decode('utf8')
-
-        return ret
-
-    def get_object_path(self):
-        object_path_string = self.get_string()
-        return ObjectPath(object_path_string)
-
-    def get_dict(self):
-        cdef DBusMessageIter c_dict_iter
-        cdef MessageIter dict_iter
-        level = self.level + 1
-
-        dbus_message_iter_recurse(self.iter, <DBusMessageIter *>&c_dict_iter)
-        dict_iter = MessageIter(level)
-        dict_iter.__cinit__(&c_dict_iter)
-        
-        python_dict = {}
-        cur_arg_type = dict_iter.get_arg_type()
-        while cur_arg_type == TYPE_DICT_ENTRY:
-            if cur_arg_type != TYPE_DICT_ENTRY:
-                raise TypeError, "Dictionary elements must be of type TYPE_DICT_ENTRY '%s != %s'" % (TYPE_DICT_ENTRY, cur_arg_type)
-                
-            dict_entry = dict_iter.get_struct()
-            if len(dict_entry) != 2:
-                raise TypeError, "Dictionary entries must be structs of two elements.  This entry had %i elements.'" % (len(dict_entry))
-
-            python_dict[dict_entry[0]] = dict_entry[1]
-            
-            dict_iter.next()
-            cur_arg_type = dict_iter.get_arg_type()
-
-        return python_dict
-   
-    def get_array(self, type):
-        cdef DBusMessageIter c_array_iter
-        cdef MessageIter array_iter
-        level = self.level + 1
-
-        dbus_message_iter_recurse(self.iter, <DBusMessageIter *>&c_array_iter)
-        array_iter = MessageIter(level)
-        array_iter.__cinit__(&c_array_iter)
-        
-        python_list = []
-        cur_arg_type = array_iter.get_arg_type()
-        while cur_arg_type != TYPE_INVALID:
-            if cur_arg_type != type:
-                raise TypeError, "Array elements must be of the same type '%s != %s'" % (type, cur_arg_type)
-                
-            value = array_iter.get(type)
-            python_list.append(value)
-            
-            array_iter.next()
-            cur_arg_type = array_iter.get_arg_type()
-
-        return python_list
-
-    def get_variant(self):
-        cdef DBusMessageIter c_var_iter
-        cdef MessageIter var_iter
-        level = self.level + 1
-
-        dbus_message_iter_recurse(self.iter, <DBusMessageIter *>&c_var_iter)
-        var_iter = MessageIter(level)
-        var_iter.__cinit__(&c_var_iter)
-        
-        return var_iter.get() 
-
-    def get_struct(self):
-        cdef DBusMessageIter c_struct_iter
-        cdef MessageIter struct_iter
-        level = self.level + 1
-
-        dbus_message_iter_recurse(self.iter, <DBusMessageIter *>&c_struct_iter)
-        struct_iter = MessageIter(level)
-        struct_iter.__cinit__(&c_struct_iter)
-
-        python_list = []
-        while struct_iter.get_arg_type() != TYPE_INVALID:
-            value = struct_iter.get()
-            python_list.append(value)
-            
-            struct_iter.next()
-
-        return tuple(python_list)
-
-    def python_value_to_dbus_sig(self, value, level = 0):
-
-        if(level > 32):
-            raise TypeError, 'Type recurion is too deep' 
-
-        level = level + 1
-
-        ptype = type(value)
-        ret = ""
-        if ptype == bool:
-            ret = TYPE_BOOLEAN
-            ret = str(chr(ret))
-        elif ptype == int:
-            ret = TYPE_INT32
-            ret = str(chr(ret))
-        elif ptype == long:
-            ret = TYPE_INT64
-            ret = str(chr(ret))
-        elif (ptype == str or ptype == unicode):
-            ret = TYPE_STRING
-            ret = str(chr(ret))
-        elif ptype == float:
-            ret = TYPE_DOUBLE
-            ret = str(chr(ret))
-        elif ptype == dict:
-            dict_list = value.items()
-            key, value = dict_list[0]
-
-            ret = str(chr(TYPE_ARRAY)) + str(chr(DICT_ENTRY_BEGIN))
-            ret = ret + self.python_value_to_dbus_sig(key, level)
-            ret = ret + self.python_value_to_dbus_sig(value, level)
-            ret = ret + str(chr(DICT_ENTRY_END))
-
-        elif ptype == tuple:
-            ret = str(chr(STRUCT_BEGIN))
-            for item in value:
-                ret = ret + self.python_value_to_dbus_sig(item, level)
-            ret = ret + str(chr(STRUCT_END))
-        elif ptype == list:
-            ret = str(chr(TYPE_ARRAY))
-            ret = ret + self.python_value_to_dbus_sig(value[0], level)
-        elif isinstance(value, ObjectPath) or value == ObjectPath:
-
-            ret = TYPE_OBJECT_PATH
-            ret = str(chr(ret))
-        elif isinstance(value, ByteArray) or value == ByteArray:
-            ret = str(chr(TYPE_ARRAY)) + str(chr(TYPE_BYTE))
-        elif isinstance(value, Signature) or value == Signature:
-            ret = TYPE_SIGNATURE
-            ret = str(chr(ret))
-        elif isinstance(value, Byte) or value == Byte:
-            ret = TYPE_BYTE
-            ret = str(chr(ret))
-        elif isinstance(value, Boolean) or value == Boolean:
-            ret = TYPE_BOOLEAN
-            ret = str(chr(ret))
-        elif isinstance(value, Int16) or value == Int16:
-            ret = TYPE_INT16
-            ret = str(chr(ret))
-        elif isinstance(value, UInt16) or value == UInt16:
-            ret = TYPE_UINT16
-            ret = str(chr(ret))
-        elif isinstance(value, Int32) or value == Int32:
-            ret = TYPE_INT32
-            ret = str(chr(ret))
-        elif isinstance(value, UInt32) or value == UInt32:
-            ret = TYPE_UINT32
-            ret = str(chr(ret))
-        elif isinstance(value, Int64) or value == Int64:
-            ret = TYPE_INT64
-            ret = str(chr(ret))
-        elif isinstance(value, UInt64) or value == UInt64:
-            ret = TYPE_UINT64
-            ret = str(chr(ret))
-        elif isinstance(value, Double) or value == Double:
-            ret = TYPE_DOUBLE
-            ret = str(chr(ret))
-        elif isinstance(value, String) or value == String:
-            ret = TYPE_STRING
-            ret = str(chr(ret))
-        elif isinstance(value, Array):
-            ret = str(chr(TYPE_ARRAY))
-            if value.type == None:
-                if value.signature:
-                    ret = ret + value.signature
-                else:
-                    ret = ret + self.python_value_to_dbus_sig(value[0], level)
-            else:
-                ret = ret + self.python_value_to_dbus_sig(value.type, level)
-
-        elif isinstance(value, Struct) or value == Struct:
-            ret = str(chr(STRUCT_BEGIN))
-            for item in value:
-                ret = ret + self.python_value_to_dbus_sig(item, level)
-            ret = ret + str(chr(STRUCT_END))
-        elif isinstance(value, Dictionary):
-            ret = str(chr(TYPE_ARRAY)) + str(chr(DICT_ENTRY_BEGIN))
-            
-            if value.key_type and value.value_type:
-                ret = ret + self.python_value_to_dbus_sig(value.key_type, level)
-                ret = ret + self.python_value_to_dbus_sig(value.value_type, level)
-            elif value.signature:
-                ret = ret + value.signature
-            else:
-                dict_list = value.items()
-
-                key, val = dict_list[0]
-                ret = ret + self.python_value_to_dbus_sig(key, level)
-                ret = ret + self.python_value_to_dbus_sig(val, level)
-                
-            ret = ret + str(chr(DICT_ENTRY_END))
-        elif isinstance(value, Variant) or value == Variant:
-            ret = ret + str(chr(TYPE_VARIANT))
-        else:
-            raise TypeError, "Argument of unknown type '%s'" % (ptype)
-
-        return ret
-
-    def append_strict(self, value, sig):
-    
-        if sig == TYPE_INVALID or sig == None:
-            raise TypeError, 'Invalid arg type sent to append_strict'
-
-        sig_type = ord(sig[0])
-	    
-        if sig_type == TYPE_STRING:
-            retval = self.append_string(value)
-        elif sig_type == TYPE_INT16:
-            retval = self.append_int16(value)
-        elif sig_type == TYPE_UINT16:
-            retval = self.append_uint16(value)
-        elif sig_type == TYPE_INT32:
-            retval = self.append_int32(value)
-        elif sig_type == TYPE_UINT32:
-            retval = self.append_uint32(value)
-        elif sig_type == TYPE_INT64:
-            retval = self.append_int64(value)
-        elif sig_type == TYPE_UINT64:
-            retval = self.append_uint64(value)
-        elif sig_type == TYPE_DOUBLE:
-            retval = self.append_double(value)
-        elif sig_type == TYPE_BYTE:
-            retval = self.append_byte(value)
-        elif sig_type == TYPE_BOOLEAN:
-            retval = self.append_boolean(value)
-        elif sig_type == TYPE_SIGNATURE:
-            retval = self.append_signature(value)
-        elif sig_type == TYPE_ARRAY:
-            if len(sig) < 2:
-                raise TypeError, "Invalid array signature in append_strict.  Arrays must be followed by a type."
-
-            array_type = ord(sig[1])            
-            if array_type == DICT_ENTRY_BEGIN:
-                if ord(sig[-1]) != DICT_ENTRY_END:
-                    raise TypeError, "Invalid dict entry in append_strict.  No termination in signature %s."%(sig)
-
-                tmp_sig = sig[2:-1]
-                retval = self.append_dict(Dictionary(value, signature=tmp_sig))
-            else:
-                tmp_sig = sig[1:]
-                retval = self.append_array(Array(value, signature=tmp_sig))
-        elif sig_type == TYPE_OBJECT_PATH:
-            retval = self.append_object_path(value)
-        elif sig_type == STRUCT_BEGIN:
-            if ord(sig[-1]) != STRUCT_END:
-                raise TypeError, "Invalid struct entry in append_strict. No termination in signature %s." % (sig)
-
-            tmp_sig = sig[1:-1]
-            retval = self.append_struct(value, signature = tmp_sig)
-        elif sig_type == TYPE_VARIANT:
-            if isinstance(value, Variant):
-                retval = self.append_variant(value)
-            else:
-                retval = self.append_variant(Variant(value))
-        elif sig_type == DICT_ENTRY_BEGIN:
-            raise TypeError, "Signiture is invalid in append_strict. A dict entry must be part of an array." 
-        else:
-            raise TypeError, "Argument of unknown type '%s' in append_strict" % (sig)
-
-        return retval
-
-    def append(self, value):
-        value_type = type(value)
-        if value_type == bool:
-            retval = self.append_boolean(value)
-        elif value_type == int:
-            retval = self.append_int32(value)
-        elif value_type == long:
-            retval = self.append_int64(value)
-        elif (value_type == str or value_type == unicode):
-            retval = self.append_string(value)
-        elif value_type == float:
-            retval = self.append_double(value)
-        elif value_type == dict:
-            retval = self.append_dict(value)
-        elif value_type == tuple:
-            retval = self.append_struct(value)
-        elif value_type == list:
-             retval = self.append_array(value)
-        #elif value_type == None.__class__:
-        #    retval = self.append_nil()
-        elif isinstance(value, ObjectPath):
-            retval = self.append_object_path(value)
-        elif isinstance(value, ByteArray):
-            retval = self.append_array(value)
-        elif isinstance(value, Signature):
-            retval = self.append_signature(value)
-        elif isinstance(value, Byte):
-            retval = self.append_byte(value)
-        elif isinstance(value, Boolean):
-            retval = self.append_boolean(value)
-        elif isinstance(value, Int16):
-            retval = self.append_int16(value)
-        elif isinstance(value, UInt16):
-            retval = self.append_uint16(value)
-        elif isinstance(value, Int32):
-            retval = self.append_int32(value)
-        elif isinstance(value, UInt32):
-            retval = self.append_uint32(value)
-        elif isinstance(value, Int64):
-            retval = self.append_int64(value)
-        elif isinstance(value, UInt64):
-            retval = self.append_uint64(value)
-        elif isinstance(value, Double):
-            retval = self.append_double(value)
-        elif isinstance(value, String):
-            retval = self.append_string(value)
-        elif isinstance(value, Array):
-            retval = self.append_array(value)
-        elif isinstance(value, Struct):
-            retval = self.append_struct(value)
-        elif isinstance(value, Dictionary):
-            retval = self.append_dict(value)
-        elif isinstance(value, Variant):
-            retval = self.append_variant(value)
-        else:
-            raise TypeError, "Argument of unknown type '%s'" % (value_type)
-
-        return retval
-
-    def append_boolean(self, value):
-        cdef dbus_bool_t c_value
-        c_value = value
-        return dbus_message_iter_append_basic(self.iter, TYPE_BOOLEAN, <dbus_bool_t *>&c_value)
-
-    def append_byte(self, value):
-        cdef char b
-        if type(value) == str and len(value) == 1:
-                b = ord(value)
-        elif type(value) == Byte:
-                b = value
-        else:
-            raise TypeError
-
-        return dbus_message_iter_append_basic(self.iter, TYPE_BYTE, <char *>&b)
-
-    def append_int16(self, value):
-        cdef dbus_int16_t c_value
-        c_value = value
-        return dbus_message_iter_append_basic(self.iter, TYPE_INT16, <dbus_int16_t *>&c_value)
-
-    def append_uint16(self, value):
-        cdef dbus_uint16_t c_value
-        c_value = value
-        return dbus_message_iter_append_basic(self.iter, TYPE_UINT16, <dbus_uint16_t *>&c_value)
-
-    def append_int32(self, value):
-        cdef dbus_int32_t c_value
-        c_value = value
-        return dbus_message_iter_append_basic(self.iter, TYPE_INT32, <dbus_int32_t *>&c_value)
-
-    def append_uint32(self, value):
-        cdef dbus_uint32_t c_value
-        c_value = value
-        return dbus_message_iter_append_basic(self.iter, TYPE_UINT32, <dbus_uint32_t *>&c_value)
-
-    def append_int64(self, value):
-        cdef dbus_int64_t c_value
-        c_value = value
-        return dbus_message_iter_append_basic(self.iter, TYPE_INT64, <dbus_int64_t *>&c_value)
-
-    def append_uint64(self, value):
-        cdef dbus_uint64_t c_value
-        c_value = value
-        return dbus_message_iter_append_basic(self.iter, TYPE_UINT64, <dbus_uint64_t *>&c_value)
-
-    def append_double(self, value):
-        cdef double c_value
-        c_value = value
-        return dbus_message_iter_append_basic(self.iter, TYPE_DOUBLE, <double *>&c_value)
-
-    def append_string(self, value):
-        cdef char *c_value
-        tmp = value.encode('utf8')
-        c_value = tmp
-        return dbus_message_iter_append_basic(self.iter, TYPE_STRING, <char **>&c_value)
-
-    def append_object_path(self, value):
-        cdef char *c_value
-        c_value = value
-        return dbus_message_iter_append_basic(self.iter, TYPE_OBJECT_PATH, <char **>&c_value)
-
-    def append_signature(self, value):
-        cdef char *c_value
-        c_value = value
-        return dbus_message_iter_append_basic(self.iter, TYPE_SIGNATURE, <char **>&c_value)
-
-
-    def append_dict(self, python_dict):
-        cdef DBusMessageIter c_dict_iter, c_dict_entry_iter
-        cdef MessageIter dict_iter, dict_entry_iter
-        
-        level = self.level + 1
-
-        key = None
-        value = None
-
-        sig = str(chr(DICT_ENTRY_BEGIN))
-
-        if isinstance(python_dict, Dictionary):
-            key = python_dict.key_type
-            value = python_dict.value_type
-            signature = python_dict.signature
-
-        dict_list = python_dict.items()
-
-        if signature:
-            sig = sig + signature
-        else: 
-            if not (key and value):
-                key, value = dict_list[0]
-
-            sig = sig + self.python_value_to_dbus_sig(key)
-            sig = sig + self.python_value_to_dbus_sig(value)
-
-        sig = sig + str(chr(DICT_ENTRY_END))
-
-        dbus_message_iter_open_container(self.iter, TYPE_ARRAY, sig, <DBusMessageIter *>&c_dict_iter)
-        dict_iter = MessageIter(level)
-        dict_iter.__cinit__(&c_dict_iter)
-
-        for key, value in dict_list:
-            dbus_message_iter_open_container(dict_iter.iter, TYPE_DICT_ENTRY, sig, <DBusMessageIter *>&c_dict_entry_iter)
-            dict_entry_iter = MessageIter(level)
-            dict_entry_iter.__cinit__(&c_dict_entry_iter)
-
-            if signature:
-                signature_iter = iter(Signature(signature))
-                tmp_sig = signature_iter.next()
-                if not dict_entry_iter.append_strict(key, tmp_sig):
-                    dbus_message_iter_close_container(dict_iter.iter, dict_entry_iter.iter)
-                    dbus_message_iter_close_container(self.iter, dict_iter.iter)
-                    return False
-
-                tmp_sig = signature_iter.next()
-                if not dict_entry_iter.append_strict(value, tmp_sig):
-                    dbus_message_iter_close_container(dict_iter.iter, dict_entry_iter.iter)
-                    dbus_message_iter_close_container(self.iter, dict_iter.iter)
-                    return False
-
-            else:
-                if not dict_entry_iter.append(key):
-                    dbus_message_iter_close_container(dict_iter.iter, dict_entry_iter.iter)
-                    dbus_message_iter_close_container(self.iter, dict_iter.iter)
-                    return False
-                
-                if not dict_entry_iter.append(value):
-                    dbus_message_iter_close_container(dict_iter.iter, dict_entry_iter.iter)
-                    dbus_message_iter_close_container(self.iter, dict_iter.iter)
-                    return False
-
-            dbus_message_iter_close_container(dict_iter.iter, dict_entry_iter.iter)
-
-        dbus_message_iter_close_container(self.iter, dict_iter.iter)
-
-        return True
-
-    def append_struct(self, python_struct, signature = None):
-        cdef DBusMessageIter c_struct_iter
-        cdef MessageIter struct_iter
-
-        level = self.level + 1
-        dbus_message_iter_open_container(self.iter, TYPE_STRUCT, NULL, <DBusMessageIter *>&c_struct_iter)
-        struct_iter = MessageIter(level)
-        struct_iter.__cinit__(&c_struct_iter)
-
-        signature_iter = iter(Signature(signature))
-        for item in python_struct:
-            if signature:
-                sig = signature_iter.next()
-
-                if sig == '':
-                    dbus_message_iter_close_container(self.iter, struct_iter.iter)
-                    return False
-
-                if not struct_iter.append_strict(item, sig):
-                    dbus_message_iter_close_container(self.iter, struct_iter.iter)
-                    return False
-            else:
-                if not struct_iter.append(item):
-                    dbus_message_iter_close_container(self.iter, struct_iter.iter)
-                    return False
-
-        dbus_message_iter_close_container(self.iter, struct_iter.iter)
-
-        return True
-
-    def append_array(self, python_list):
-        cdef DBusMessageIter c_array_iter
-        cdef MessageIter array_iter
-
-        level = self.level + 1
-
-        sig = None
-        if isinstance(python_list, Array):
-            if python_list.type:
-                sig = self.python_value_to_dbus_sig(python_list.type)
-            elif python_list.signature:
-                sig = python_list.signature
-            else:
-                sig = self.python_value_to_dbus_sig(python_list[0])
-        else:
-            sig = self.python_value_to_dbus_sig(python_list[0])
-
-        dbus_message_iter_open_container(self.iter, TYPE_ARRAY, sig, <DBusMessageIter *>&c_array_iter)
-        array_iter = MessageIter(level)
-        array_iter.__cinit__(&c_array_iter)
-
-        length = len(python_list)
-        for item in python_list:
-            if not array_iter.append_strict(item, sig):
-                dbus_message_iter_close_container(self.iter, array_iter.iter)
-                return False
-
-        dbus_message_iter_close_container(self.iter, array_iter.iter)
-
-        return True
-
-    def append_variant(self, value):
-        cdef DBusMessageIter c_variant_iter
-        cdef MessageIter variant_iter
-
-        level = self.level + 1
-    
-        if value.signature:
-            sig = value.signature
-        elif value.type:
-            sig = self.python_value_to_dbus_sig(value.type)
-        else:
-            sig = self.python_value_to_dbus_sig(value.value)
-    
-        dbus_message_iter_open_container(self.iter, TYPE_VARIANT, sig, <DBusMessageIter *>&c_variant_iter)
-        
-        variant_iter = MessageIter(level)
-        variant_iter.__cinit__(&c_variant_iter)
-
-        if not variant_iter.append(value.value):
-            dbus_message_iter_close_container(self.iter, variant_iter.iter)
-            return False
-
-        dbus_message_iter_close_container(self.iter, variant_iter.iter)
-        return True
-
-    def __str__(self):
-        cdef DBusMessageIter c_array_iter
-        cdef MessageIter array_iter
-
-        value_at_iter = True
-        retval = ""
-        while (value_at_iter):
-            type = self.get_arg_type()
-            if type == TYPE_INVALID:
-                break
-            elif type == TYPE_STRING:
-                str = iter.get_string()
-                arg = 'string:%s\n' % (str)
-            elif type == TYPE_OBJECT_PATH:
-                path = iter.get_object_path()
-                arg = 'object_path:%s\n' % (path)
-            elif type == TYPE_INT16:
-                num = iter.get_int16()
-                arg = 'int16:%d\n' % (num)
-            elif type == TYPE_UINT16:
-                num = iter.get_uint16()
-                arg = 'uint16:%u\n' % (num)
-            elif type == TYPE_INT32:
-                num = iter.get_int32()
-                arg = 'int32:%d\n' % (num)
-            elif type == TYPE_UINT32:
-                num = iter.get_uint32()
-                arg = 'uint32:%u\n' % (num)
-            elif type == TYPE_INT64:
-                num = iter.get_int64()
-                arg = 'int64:%d\n' % (num)
-            elif type == TYPE_UINT64:
-                num = iter.get_uint64()
-                arg = 'uint64:%u\n' % (num)
-            elif type == TYPE_DOUBLE:
-                num = iter.get_double()
-                arg = 'double:%f\n' % (num)
-            elif type == TYPE_BYTE:
-                num = iter.get_byte()
-                arg = 'byte:%x(%s)\n' % (num, str(chr(num)))
-            elif type == TYPE_BOOLEAN:
-                bool = iter.get_boolean()
-                if (bool):
-                    str = "true"
-                else:
-                    str = "false"
-                arg = 'boolean:%s\n' % (str)
-            elif type == TYPE_ARRAY:
-                dbus_message_iter_recurse(self.iter, <DBusMessageIter *>&c_array_iter)
-                array_iter = MessageIter(self.level + 1)
-                array_iter.__cinit__(&c_array_iter)
-                if array_iter.has_next():
-                    arg = 'array [' + str(array_iter) + ']'
-                else:
-                    arg = 'array []'
-            else:
-                arg = '(unknown arg type %d)\n' % type
-
-            retval = retval + arg
-            value_at_iter = self.next()
-
-        return retval
-
-
-(MESSAGE_TYPE_INVALID, MESSAGE_TYPE_METHOD_CALL, MESSAGE_TYPE_METHOD_RETURN, MESSAGE_TYPE_ERROR, MESSAGE_TYPE_SIGNAL) = range(5)
-(TYPE_INVALID, TYPE_BYTE, TYPE_BOOLEAN, TYPE_INT16, TYPE_UINT16, TYPE_INT32, TYPE_UINT32, TYPE_INT64, TYPE_UINT64, TYPE_DOUBLE, TYPE_STRING, TYPE_OBJECT_PATH, TYPE_SIGNATURE, TYPE_ARRAY, TYPE_STRUCT, STRUCT_BEGIN, STRUCT_END, TYPE_VARIANT, TYPE_DICT_ENTRY, DICT_ENTRY_BEGIN, DICT_ENTRY_END) = (0, ord('y'), ord('b'), ord('n'), ord('q'), ord('i'), ord('u'), ord('x'), ord('t'), ord('d'), ord('s'), ord('o'), ord('g'), ord('a'), ord('r'), ord('('), ord(')'), ord('v'), ord('e'), ord('{'), ord('}'))
-(HANDLER_RESULT_HANDLED, HANDLER_RESULT_NOT_YET_HANDLED, HANDLER_RESULT_NEED_MEMORY) = range(3)
-    
-cdef class Message:
-    cdef DBusMessage *msg
-
-    def __init__(self, message_type=MESSAGE_TYPE_INVALID,
-                 service=None, path=None, dbus_interface=None, method=None,
-                 Message method_call=None,
-                 name=None,
-                 Message reply_to=None, error_name=None, error_message=None,
-                 _create=1):
-
-        self.msg = NULL
-
-        cdef char *cservice
-        cdef char *ciface
-        cdef DBusMessage *cmsg
-
-        ciface = NULL
-        if (dbus_interface != None):
-            ciface = dbus_interface
-
-        cservice = NULL
-        if (service != None):
-            cservice = service
-            
-        if _create:
-            if message_type == MESSAGE_TYPE_METHOD_CALL:
-                self.msg = dbus_message_new_method_call(cservice, path, ciface, method)
-            elif message_type == MESSAGE_TYPE_METHOD_RETURN:
-                cmsg = method_call._get_msg()
-                self.msg = dbus_message_new_method_return(cmsg)
-            elif message_type == MESSAGE_TYPE_SIGNAL:
-                self.msg = dbus_message_new_signal(path, ciface, name)
-            elif message_type == MESSAGE_TYPE_ERROR:
-                cmsg = reply_to._get_msg()
-                self.msg = dbus_message_new_error(cmsg, error_name, error_message)
- 
-
-    def __dealloc__(self):
-        if self.msg != NULL:
-            dbus_message_unref(self.msg)
-            
-    def type_to_name(self, type):
-        if type == MESSAGE_TYPE_SIGNAL:
-            return "signal"
-        elif type == MESSAGE_TYPE_METHOD_CALL:
-            return "method call"
-        elif type == MESSAGE_TYPE_METHOD_RETURN:
-            return "method return"
-        elif type == MESSAGE_TYPE_ERROR:
-            return "error"
-        else:
-            return "(unknown message type)"
-
-    def __str__(self):
-        message_type = self.get_type()
-        sender = self.get_sender()
-
-        if sender == None:
-            sender = "(no sender)"
-
-        if (message_type == MESSAGE_TYPE_METHOD_CALL) or (message_type == MESSAGE_TYPE_SIGNAL):
-            retval = '%s interface=%s; member=%s; sender=%s' % (self.type_to_name(message_type),
-                                                                self.get_interface(),
-                                                                self.get_member(),
-                                                                sender)
-        elif message_type == MESSAGE_TYPE_METHOD_RETURN:
-            retval = '%s sender=%s' % (self.type_to_name(message_type),
-                                        sender)
-        elif message_type == MESSAGE_TYPE_ERROR:
-            retval = '%s name=%s; sender=%s' % (self.type_to_name(message_type),
-                                                self.get_error_name(),
-                                                sender)
-        else:
-            retval = "Message of unknown type %d" % (message_type)
-
-
-        # FIXME: should really use self.convert_to_tuple() here
-        
-        iter = self.get_iter()
-
-        retval = retval + "\n" + str(iter) 
-
-        return retval
-    
-    cdef _set_msg(self, DBusMessage *msg):
-        self.msg = msg
-
-    cdef DBusMessage *_get_msg(self):
-        return self.msg
-
-    def get_iter(self, append=False):
-        cdef DBusMessageIter iter
-        cdef MessageIter message_iter
-        cdef DBusMessage *msg
-
-        msg = self._get_msg()
-
-        if append:
-            dbus_message_iter_init_append(msg, &iter)
-        else:
-            dbus_message_iter_init(msg, &iter)
-
-        message_iter = MessageIter(0)
-        message_iter.__cinit__(&iter)
-
-        return message_iter
-
-    def get_args_list(self):
-        retval = [ ]
-
-        iter = self.get_iter()
-        try:
-            retval.append(iter.get())
-        except TypeError, e:
-            return [ ]
-            
-        value_at_iter = iter.next()
-        while (value_at_iter):
-            retval.append(iter.get())
-            value_at_iter = iter.next()        
-
-        return retval
-            
-    # FIXME: implement dbus_message_copy?
-
-    def get_type(self):
-        return dbus_message_get_type(self.msg)
-
-    def set_path(self, object_path):
-        return dbus_message_set_path(self.msg, object_path)
-    
-    def get_path(self):
-        return dbus_message_get_path(self.msg)
-    
-    def set_interface(self, interface):
-        return dbus_message_set_interface(self.msg, interface)
-
-    def get_interface(self):
-        return dbus_message_get_interface(self.msg)    
-
-    def set_member(self, member):
-        return dbus_message_set_member(self.msg, member)
-
-    def get_member(self):
-        return dbus_message_get_member(self.msg)
-
-    def set_error_name(self, name):
-        return dbus_message_set_error_name(self.msg, name)
-
-    def get_error_name(self):
-        return dbus_message_get_error_name(self.msg)
-
-    def set_destination(self, destination):
-        return dbus_message_set_destination(self.msg, destination)
-
-    def get_destination(self):
-        return dbus_message_get_destination(self.msg)
-
-    def set_sender(self, sender):
-        return dbus_message_set_sender(self.msg, sender)
-    
-    def get_sender(self):
-        cdef char *sender
-        sender = dbus_message_get_sender(self.msg)
-        if (sender == NULL):
-            return None
-        else:
-            return sender
-
-    def set_no_reply(self, no_reply):
-        dbus_message_set_no_reply(self.msg, no_reply)
-
-    def get_no_reply(self):
-        return dbus_message_get_no_reply(self.msg)
-
-    def is_method_call(self, interface, method):
-        return dbus_message_is_method_call(self.msg, interface, method)
-
-    def is_signal(self, interface, signal_name):
-        return dbus_message_is_signal(self.msg, interface, signal_name)
-
-    def is_error(self, error_name):
-        return dbus_message_is_error(self.msg, error_name)
-
-    def has_destination(self, service):
-        return dbus_message_has_destination(self.msg, service)
-
-    def has_sender(self, service):
-        return dbus_message_has_sender(self.msg, service)
-
-    def get_serial(self):
-        return dbus_message_get_serial(self.msg)
-
-    def set_reply_serial(self, reply_serial):
-        return dbus_message_set_reply_serial(self.msg, reply_serial)
-
-    def get_reply_serial(self):
-        return dbus_message_get_reply_serial(self.msg)    
-
-    #FIXME: dbus_message_get_path_decomposed
-    
-    # FIXME: all the different dbus_message_*args* methods
-
-class Signal(Message):
-    def __init__(self, spath, sinterface, sname):
-        Message.__init__(self, MESSAGE_TYPE_SIGNAL, path=spath, dbus_interface=sinterface, name=sname)
-
-class EmptyMessage(Message):
-    def __init__(self):
-        Message.__init__(self, _create=False)
-
-class MethodCall(Message):
-    def __init__(self, mpath, minterface, mmethod):
-        Message.__init__(self, MESSAGE_TYPE_METHOD_CALL, path=mpath, dbus_interface=minterface, method=mmethod)
-
-class MethodReturn(Message):
-    def __init__(self, method_call):
-        Message.__init__(self, MESSAGE_TYPE_METHOD_RETURN, method_call=method_call)
-
-class Error(Message):
-    def __init__(self, reply_to, error_name, error_message):
-        Message.__init__(self, MESSAGE_TYPE_ERROR, reply_to=reply_to, error_name=error_name, error_message=error_message)
-        
-cdef class Server:
-    cdef DBusServer *server
-    def __init__(self, address):
-        cdef DBusError error
-        dbus_error_init(&error)
-        self.server = dbus_server_listen(address,
-                                         &error)
-        if dbus_error_is_set(&error):
-            errormsg = error.message
-            dbus_error_free (&error)
-            raise DBusException, errormsg
-
-    def disconnect(self):
-        dbus_server_disconnect(self.server)
-
-    def get_is_connected(self):
-        return dbus_server_get_is_connected(self.server)
-
-#    def set_new_connection_function(self, function, data):
-#        dbus_server_set_new_connection_function(self.conn, function,
-#                                                data, NULL)
-        
-#    def set_watch_functions(self, add_function, remove_function, data):
-#        dbus_server_set_watch_functions(self.server,
-#                                        add_function, remove_function,
-#                                        data, NULL)
-        
-#    def set_timeout_functions(self, add_function, remove_function, data):
-#        dbus_server_set_timeout_functions(self.server,
-#                                          add_function, remove_function,
-#                                          data, NULL)
-        
-#    def handle_watch(self, watch, condition):
-#        dbus_server_handle_watch(self.conn, watch, condition)
-
-BUS_SESSION = DBUS_BUS_SESSION
-BUS_SYSTEM = DBUS_BUS_SYSTEM
-BUS_STARTER = DBUS_BUS_STARTER
-
-def bus_get (bus_type, private=False):
-    cdef DBusError error
-    cdef Connection conn
-    cdef DBusConnection *connection
-
-    dbus_error_init(&error)
-    if private:
-        connection = dbus_bus_get_private(bus_type,
-                                          &error)
-    else:
-        connection = dbus_bus_get(bus_type,
-                                  &error)
-
-    if dbus_error_is_set(&error):
-        errormsg = error.message
-        dbus_error_free(&error)
-        raise DBusException, errormsg 
-
-    conn = Connection()
-    conn.__cinit__(None, connection)
-    return conn 
-
-def bus_get_unique_name(Connection connection):
-    cdef DBusConnection *conn
-    conn = connection._get_conn()
-    return dbus_bus_get_unique_name(conn)
-
-def bus_get_unix_user(Connection connection, service_name):
-    cdef DBusError error
-    dbus_error_init(&error)
-    cdef int retval
-    cdef DBusConnection *conn
-
-    conn = connection._get_conn()
-    retval = dbus_bus_get_unix_user(conn, service_name, &error)
-
-    if dbus_error_is_set(&error):
-        errormsg = error.message
-        dbus_error_free(&error)
-        raise DBusException, errormsg 
-
-    return retval
-
-# these are defines, not enums, so they aren't auto generated
-DBUS_START_REPLY_SUCCESS = 0
-DBUS_START_REPLY_ALREADY_RUNNING = 1
-
-def bus_start_service_by_name(Connection connection, service_name, flags=0):
-    cdef DBusError error
-    dbus_error_init(&error)
-    cdef dbus_bool_t retval
-    cdef dbus_uint32_t results
-    cdef DBusConnection *conn
-
-    conn = connection._get_conn()
-
-    retval = dbus_bus_start_service_by_name(conn, service_name, flags, &results, &error)
-
-    if dbus_error_is_set(&error):
-        errormsg = error.message
-        dbus_error_free(&error)
-        raise DBusException, errormsg
-
-    return (retval, results) 
-
-def bus_register(Connection connection):
-    cdef DBusError error
-    dbus_error_init(&error)
-    cdef dbus_bool_t retval
-    cdef DBusConnection *conn
-
-    conn = connection._get_conn()
-    retval = dbus_bus_register(conn,
-                               &error)
-    if dbus_error_is_set(&error):
-        msg = error.message
-        dbus_error_free(&error)
-        raise DBusException, errormsg 
-
-    return retval
-
-NAME_FLAG_ALLOW_REPLACEMENT    = 0x1
-NAME_FLAG_REPLACE_EXISTING     = 0x2
-NAME_FLAG_DO_NOT_QUEUE         = 0x4
-
-REQUEST_NAME_REPLY_PRIMARY_OWNER = 1
-REQUEST_NAME_REPLY_IN_QUEUE      = 2
-REQUEST_NAME_REPLY_EXISTS        = 3
-REQUEST_NAME_REPLY_ALREADY_OWNER = 4
-
-def bus_request_name(Connection connection, service_name, flags=0):
-    cdef DBusError error
-    dbus_error_init(&error)
-    cdef int retval
-    cdef DBusConnection *conn
-
-    conn = connection._get_conn()
-    retval = dbus_bus_request_name(conn,
-                                   service_name,
-                                   flags,
-                                   &error)
-    if dbus_error_is_set(&error):
-        errormsg = error.message
-        dbus_error_free(&error)
-        raise DBusException, errormsg
-
-    return retval
-
-RELEASE_NAME_REPLY_RELEASED = 1
-RELEASE_NAME_REPLY_NON_EXISTENT = 2
-RELEASE_NAME_REPLY_NOT_OWNER = 3
-
-def bus_release_name(Connection connection, service_name):
-    cdef DBusError error
-    dbus_error_init(&error)
-    cdef int retval
-    cdef DBusConnection *conn
-
-    conn = connection._get_conn()
-    retval = dbus_bus_release_name(conn,
-                                   service_name,
-                                   &error)
-    if dbus_error_is_set(&error):
-        errormsg = error.message
-        dbus_error_free(&error)
-        raise DBusException, errormsg
-
-    return retval
-
-def bus_name_has_owner(Connection connection, service_name):
-    cdef DBusError error
-    dbus_error_init(&error)
-    cdef dbus_bool_t retval
-    cdef DBusConnection *conn
-
-    conn = connection._get_conn()
-    retval = dbus_bus_name_has_owner(conn,
-                                     service_name,
-                                     &error)
-    if dbus_error_is_set(&error):
-        errormsg = error.message
-        dbus_error_free(&error)
-        raise DBusException, errormsg
-        
-    return retval
-
-def bus_add_match(Connection connection, rule):
-    cdef DBusError error
-    cdef DBusConnection *conn
-
-    dbus_error_init(&error)
-    
-    conn = connection._get_conn()
-    dbus_bus_add_match (conn, rule, &error)
-    
-    if dbus_error_is_set(&error):
-        errormsg = error.message
-        dbus_error_free(&error)
-        raise DBusException, errormsg
-
-def bus_remove_match(Connection connection, rule):
-    cdef DBusError error
-    cdef DBusConnection *conn
-
-    dbus_error_init(&error)
-
-    conn = connection._get_conn()
-    dbus_bus_remove_match (conn, rule, &error)
-    
-    if dbus_error_is_set(&error):
-        errormsg = error.message
-        dbus_error_free(&error)
-        raise DBusException, errormsg
-
diff --git a/python/dbus_glib_bindings.pyx b/python/dbus_glib_bindings.pyx
deleted file mode 100644
index 3e2e33bd..00000000
--- a/python/dbus_glib_bindings.pyx
+++ /dev/null
@@ -1,17 +0,0 @@
-cimport dbus_bindings
-import dbus_bindings
-
-cdef extern from "dbus-glib.h":
-    ctypedef struct GMainContext
-    cdef void dbus_g_thread_init ()
-
-cdef extern from "dbus-glib-lowlevel.h":
-    cdef void dbus_connection_setup_with_g_main (dbus_bindings.DBusConnection *connection,
-                                                 GMainContext   *context)
-def setup_with_g_main(conn):
-   cdef dbus_bindings.Connection connection
-   connection = conn
-   dbus_connection_setup_with_g_main(connection._get_conn(), NULL)
-
-def gthreads_init ():
-    dbus_g_thread_init ()
diff --git a/python/dbus_h_wrapper.h b/python/dbus_h_wrapper.h
deleted file mode 100644
index 2e218c8c..00000000
--- a/python/dbus_h_wrapper.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#define DBUS_API_SUBJECT_TO_CHANGE 1
-#include <dbus/dbus.h>
-
diff --git a/python/decorators.py b/python/decorators.py
deleted file mode 100644
index c9bc17fa..00000000
--- a/python/decorators.py
+++ /dev/null
@@ -1,83 +0,0 @@
-import _util
-import inspect
-import dbus_bindings
-
-def method(dbus_interface, in_signature=None, out_signature=None, async_callbacks=None, sender_keyword=None):
-    _util._validate_interface_or_name(dbus_interface)
-
-    def decorator(func):
-        args = inspect.getargspec(func)[0]
-        args.pop(0)
-
-        if async_callbacks:
-            if type(async_callbacks) != tuple:
-                raise TypeError('async_callbacks must be a tuple of (keyword for return callback, keyword for error callback)')
-            if len(async_callbacks) != 2:
-                raise ValueError('async_callbacks must be a tuple of (keyword for return callback, keyword for error callback)')
-            args.remove(async_callbacks[0])
-            args.remove(async_callbacks[1])
-
-        if sender_keyword:
-            args.remove(sender_keyword)
-
-        if in_signature:
-            in_sig = tuple(dbus_bindings.Signature(in_signature))
-
-            if len(in_sig) > len(args):
-                raise ValueError, 'input signature is longer than the number of arguments taken'
-            elif len(in_sig) < len(args):
-                raise ValueError, 'input signature is shorter than the number of arguments taken'
-
-        func._dbus_is_method = True
-        func._dbus_async_callbacks = async_callbacks
-        func._dbus_interface = dbus_interface
-        func._dbus_in_signature = in_signature
-        func._dbus_out_signature = out_signature
-        func._dbus_sender_keyword = sender_keyword
-        func._dbus_args = args
-        return func
-
-    return decorator
-
-def signal(dbus_interface, signature=None):
-    _util._validate_interface_or_name(dbus_interface)
-    def decorator(func):
-        def emit_signal(self, *args, **keywords):
-            func(self, *args, **keywords)
-            message = dbus_bindings.Signal(self._object_path, dbus_interface, func.__name__)
-            iter = message.get_iter(True)
-
-            if emit_signal._dbus_signature:
-                signature = tuple(dbus_bindings.Signature(emit_signal._dbus_signature))
-                for (arg, sig) in zip(args, signature):
-                    iter.append_strict(arg, sig)
-            else:
-                for arg in args:
-                    iter.append(arg)
-
-            self._connection.send(message)
-
-        args = inspect.getargspec(func)[0]
-        args.pop(0)
-
-        if signature:
-            sig = tuple(dbus_bindings.Signature(signature))
-
-            if len(sig) > len(args):
-                raise ValueError, 'signal signature is longer than the number of arguments provided'
-            elif len(sig) < len(args):
-                raise ValueError, 'signal signature is shorter than the number of arguments provided'
-
-        emit_signal.__name__ = func.__name__
-        emit_signal.__doc__ = func.__doc__
-        emit_signal._dbus_is_signal = True
-        emit_signal._dbus_interface = dbus_interface
-        emit_signal._dbus_signature = signature
-        emit_signal._dbus_args = args
-        return emit_signal
-
-    return decorator
-
-def explicitly_pass_message(func):
-    func._dbus_pass_message = True
-    return func
diff --git a/python/examples/.cvsignore b/python/examples/.cvsignore
deleted file mode 100644
index 282522db..00000000
--- a/python/examples/.cvsignore
+++ /dev/null
@@ -1,2 +0,0 @@
-Makefile
-Makefile.in
diff --git a/python/examples/Makefile.am b/python/examples/Makefile.am
deleted file mode 100644
index f7a1b22e..00000000
--- a/python/examples/Makefile.am
+++ /dev/null
@@ -1,13 +0,0 @@
-NULL=
-
-EXTRA_DIST = 				\
-	example-service.py 		\
-	example-client.py		\
-	example-signal-emitter.py	\
-	example-signal-recipient.py	\
-	gconf-proxy-client.py		\
-	gconf-proxy-service.py		\
-	gconf-proxy-service2.py		\
-	list-system-services.py 	\
-	$(NULL)
-
diff --git a/python/examples/example-client.py b/python/examples/example-client.py
deleted file mode 100644
index 3d170bd4..00000000
--- a/python/examples/example-client.py
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env python
-
-import dbus
-
-bus = dbus.SessionBus()
-remote_object = bus.get_object("org.designfu.SampleService", "/SomeObject")
-iface = dbus.Interface(remote_object, "org.designfu.SampleInterface")
-
-hello_reply_list = remote_object.HelloWorld("Hello from example-client.py!", dbus_interface = "org.designfu.SampleInterface")
-
-hello_reply_tuple = iface.GetTuple()
-
-hello_reply_dict = iface.GetDict()
-
-print (hello_reply_list)
-
-print str(hello_reply_tuple)
-
-print str(hello_reply_dict)
-
-print remote_object.Introspect(dbus_interface="org.freedesktop.DBus.Introspectable")
-
diff --git a/python/examples/example-service.py b/python/examples/example-service.py
deleted file mode 100644
index cb25d203..00000000
--- a/python/examples/example-service.py
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/usr/bin/env python
-
-import dbus
-import dbus.service
-import dbus.glib
-import gobject
-
-class SomeObject(dbus.service.Object):
-    def __init__(self, bus_name, object_path="/SomeObject"):
-        dbus.service.Object.__init__(self, bus_name, object_path)
-
-    @dbus.service.method("org.designfu.SampleInterface")
-    def HelloWorld(self, hello_message):
-        print (str(hello_message))
-        return ["Hello", " from example-service.py"]
-
-    @dbus.service.method("org.designfu.SampleInterface")
-    def GetTuple(self):
-        return ("Hello Tuple", " from example-service.py")
-
-    @dbus.service.method("org.designfu.SampleInterface")
-    def GetDict(self):
-        return {"first": "Hello Dict", "second": " from example-service.py"}
-
-session_bus = dbus.SessionBus()
-name = dbus.service.BusName("org.designfu.SampleService", bus=session_bus)
-object = SomeObject(name)
-
-mainloop = gobject.MainLoop()
-mainloop.run()
diff --git a/python/examples/example-signal-emitter.py b/python/examples/example-signal-emitter.py
deleted file mode 100644
index 02eff893..00000000
--- a/python/examples/example-signal-emitter.py
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/usr/bin/env python
-
-import dbus
-import dbus.service
-import dbus.glib
-import gobject
-
-class TestObject(dbus.service.Object):
-    def __init__(self, bus_name, object_path='/org/designfu/TestService/object'):
-        dbus.service.Object.__init__(self, bus_name, object_path)
-
-    @dbus.service.signal('org.designfu.TestService')
-    def HelloSignal(self, message):
-        # The signal is emitted when this method exits
-        # You can have code here if you wish
-        pass
-
-    @dbus.service.method('org.designfu.TestService')
-    def emitHelloSignal(self):
-        #you emit signals by calling the signal's skeleton method
-        self.HelloSignal('Hello')
-        return 'Signal emitted'
-
-session_bus = dbus.SessionBus()
-name = dbus.service.BusName('org.designfu.TestService', bus=session_bus)
-object = TestObject(name)
-
-loop = gobject.MainLoop()
-loop.run()
diff --git a/python/examples/example-signal-recipient.py b/python/examples/example-signal-recipient.py
deleted file mode 100644
index a06d4943..00000000
--- a/python/examples/example-signal-recipient.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/env python
-
-import dbus
-import dbus.decorators
-import dbus.glib
-import gobject
-
-def handle_reply(msg):
-    print msg
-
-def handle_error(e):
-    print str(e)
-
-def emit_signal():
-   #call the emitHelloSignal method 
-   object.emitHelloSignal(dbus_interface="org.designfu.TestService")
-                          #reply_handler = handle_reply, error_handler = handle_error)
-   return True
-
-bus = dbus.SessionBus()
-object  = bus.get_object("org.designfu.TestService","/org/designfu/TestService/object")
-
-def hello_signal_handler(hello_string):
-    print ("Received signal and it says: " + hello_string)
-
-@dbus.decorators.explicitly_pass_message
-def catchall_signal_handler(*args, **keywords):
-    #The dbus.handler directive passes in the special __dbus_message__ variable
-    dbus_message = keywords["dbus_message"]
-    print "Caught signal " + dbus_message.get_member()
-    for arg in args:
-        print "        " + str(arg)
-
-def catchall_hello_signals_handler(hello_string):
-    print ("Received a hello signal and it says ") + hello_string
-    
-@dbus.decorators.explicitly_pass_message
-def catchall_testservice_interface_handler(hello_string, dbus_message):
-    print "org.designfu.TestService interface says " + hello_string + " when it sent signal " + dbus_message.get_member()
-
-object.connect_to_signal("HelloSignal", hello_signal_handler, dbus_interface="org.designfu.TestService", arg0="Hello")
-
-#lets make a catchall
-bus.add_signal_receiver(catchall_signal_handler)
-bus.add_signal_receiver(catchall_hello_signals_handler, dbus_interface = "org.designfu.TestService", signal_name = "HelloSignal")
-bus.add_signal_receiver(catchall_testservice_interface_handler, dbus_interface = "org.designfu.TestService")
-
-
-gobject.timeout_add(2000, emit_signal)
-
-# Tell the remote object to emit the signal
-
-loop = gobject.MainLoop()
-loop.run()
diff --git a/python/examples/gconf-proxy-client.py b/python/examples/gconf-proxy-client.py
deleted file mode 100644
index f763e3fa..00000000
--- a/python/examples/gconf-proxy-client.py
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/usr/bin/env python
-
-import dbus
-
-gconf_key = "/desktop/gnome/file_views/icon_theme"
-
-bus = dbus.SessionBus()
-gconf_service = bus.get_service("org.gnome.GConf")
-gconf_key_object = gconf_service.get_object("/org/gnome/GConf" + gconf_key, "org.gnome.GConf")
-
-value = gconf_key_object.getString()
-
-print ("Value of GConf key %s is %s" % (gconf_key, value))
diff --git a/python/examples/gconf-proxy-service.py b/python/examples/gconf-proxy-service.py
deleted file mode 100644
index a899cf21..00000000
--- a/python/examples/gconf-proxy-service.py
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/usr/bin/env python
-#FIXME: Doesn't work with the new bindings
-import dbus
-
-import gobject
-import gconf
-
-class GConfService(dbus.Service):
-
-    def __init__(self):
-        dbus.Service.__init__(self, "org.gnome.GConf", dbus.SessionBus())
-
-        gconf_object_tree = self.GConfObjectTree(self)
-        
-    class GConfObjectTree(dbus.ObjectTree):
-        def __init__(self, service):
-            dbus.ObjectTree.__init__(self, "/org/gnome/GConf", service, dbus_methods=[ self.getString, self.setString, self.getInt, self.setInt ])
-
-            self.client = gconf.client_get_default()
-
-        def getString(self, message, object_path):
-            print ("getString called on GConf key %s" % (object_path))
-            return self.client.get_string(object_path)
-
-        def setString(self, message, object_path, new_value):
-            print ("setString called on GConf key %s" % (object_path))            
-            self.client.set_string(object_path, new_value)
-
-        def getInt(self, message, object_path):
-            print ("getInt called on GConf key %s" % (object_path))
-            return self.client.get_int(object_path)
-
-        def setInt(self, message, object_path, new_value):
-            print ("setInt called on GConf key %s" % (object_path))
-            self.client.set_int(object_path, new_value)
-            
-gconf_service = GConfService()
-
-print ("GConf Proxy service started.")
-print ("Run 'gconf-proxy-client.py' to fetch a GConf key through the proxy...")
-
-mainloop = gobject.MainLoop()
-mainloop.run()
diff --git a/python/examples/gconf-proxy-service2.py b/python/examples/gconf-proxy-service2.py
deleted file mode 100644
index 5731ab28..00000000
--- a/python/examples/gconf-proxy-service2.py
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/usr/bin/env python
-#FIXME: doesn't work with the new bindings
-import dbus
-
-import gobject
-import gconf
-
-class GConfService(dbus.Service):
-
-    def __init__(self):
-        dbus.Service.__init__(self, "org.gnome.GConf", dbus.SessionBus())
-
-        gconf_object_tree = self.GConfObjectTree(self)
-        
-    class GConfObjectTree(dbus.ObjectTree):
-        def __init__(self, service):
-            dbus.ObjectTree.__init__(self, "/org/gnome/GConf", service)
-
-            self.client = gconf.client_get_default()
-
-        def object_method_called(self, message, object_path, method_name, argument_list):
-            print ("Method %s called on GConf key %s" % (method_name, object_path))
-
-            if "getString" == method_name:
-                return self.client.get_string(object_path)
-            elif "setString" == method_name:
-                self.client.set_int(object_path, argument_list[0])
-            elif "getInt" == method_name:
-                return self.client.get_int(object_path)                
-            elif "setInt" == method_name:
-                self.client.set_int(object_path, argument_list[0])
-
-gconf_service = GConfService()
-
-print ("GConf Proxy service started.")
-print ("Run 'gconf-proxy-client.py' to fetch a GConf key through the proxy...")
-
-mainloop = gobject.MainLoop()
-mainloop.run()
diff --git a/python/examples/list-system-services.py b/python/examples/list-system-services.py
deleted file mode 100644
index 4cad8717..00000000
--- a/python/examples/list-system-services.py
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env python
-
-"""Lists services on the system bus
-"""
-
-import dbus
-
-# Get a connection to the SYSTEM bus
-bus = dbus.SystemBus()
-
-# Get a reference to the desktop bus' standard object, denoted
-# by the path /org/freedesktop/DBus. 
-dbus_object = bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus')
-
-# The object /org/freedesktop/DBus
-# implements the 'org.freedesktop.DBus' interface
-dbus_iface = dbus.Interface(dbus_object, 'org.freedesktop.DBus')
-
-# One of the member functions in the org.freedesktop.DBus interface
-# is ListServices(), which provides a list of all the other services
-# registered on this bus. Call it, and print the list.
-print dbus_object.ListNames()
diff --git a/python/exceptions.py b/python/exceptions.py
deleted file mode 100644
index 2b01b96e..00000000
--- a/python/exceptions.py
+++ /dev/null
@@ -1,29 +0,0 @@
-import dbus_bindings
-
-DBusException = dbus_bindings.DBusException
-ConnectionError = dbus_bindings.ConnectionError
-
-class MissingErrorHandlerException(DBusException):
-    def __init__(self):
-        DBusException.__init__(self, "error_handler not defined: if you define a reply_handler you must also define an error_handler")
-
-class MissingReplyHandlerException(DBusException):
-    def __init__(self):
-        DBusException.__init__(self, "reply_handler not defined: if you define an error_handler you must also define a reply_handler")
-
-class ValidationException(DBusException):
-    def __init__(self, msg=''):
-        DBusException.__init__(self, "Error validating string: %s"%msg)
-
-class IntrospectionParserException(DBusException):
-    def __init__(self, msg=''):
-        DBusException.__init__(self, "Error parsing introspect data: %s"%msg)
-
-class UnknownMethodException(DBusException):
-    def __init__(self, method):
-        DBusException.__init__(self, "Unknown method: %s"%method)
-
-class NameExistsException(DBusException):
-    def __init__(self, name):
-        DBusException.__init__(self, "Bus name already exists: %s"%name)
-
diff --git a/python/extract.py b/python/extract.py
deleted file mode 100644
index 3cdb9755..00000000
--- a/python/extract.py
+++ /dev/null
@@ -1,234 +0,0 @@
-import commands
-import re
-import string
-import sys
-
-def clean_func(buf):
-    buf = strip_comments(buf)
-    pat = re.compile(r"""\\\n""", re.MULTILINE) 
-    buf = pat.sub('',buf)
-    pat = re.compile(r"""^[#].*?$""", re.MULTILINE) 
-    buf = pat.sub('',buf)
-    pat = re.compile(r"""^(typedef|struct|enum)(\s|.|\n)*?;\s*""", re.MULTILINE) 
-    buf = pat.sub('',buf)
-    pat = re.compile(r"""\s+""", re.MULTILINE) 
-    buf = pat.sub(' ',buf)
-    pat = re.compile(r""";\s*""", re.MULTILINE) 
-    buf = pat.sub('\n',buf)
-    buf = buf.lstrip()
-    #pat=re.compile(r'\s+([*|&]+)\s*(\w+)')
-    pat = re.compile(r' \s+ ([*|&]+) \s* (\w+)',re.VERBOSE)
-    buf = pat.sub(r'\1 \2', buf)
-    pat = re.compile(r'\s+ (\w+) \[ \s* \]',re.VERBOSE)
-    buf = pat.sub(r'[] \1', buf)
-#    buf = string.replace(buf, 'G_CONST_RETURN ', 'const-')
-    buf = string.replace(buf, 'const ', '')
-    return buf
-
-def strip_comments(buf):
-    parts = []
-    lastpos = 0
-    while 1:
-        pos = string.find(buf, '/*', lastpos)
-        if pos >= 0:
-            parts.append(buf[lastpos:pos])
-            pos = string.find(buf, '*/', pos)
-            if pos >= 0:
-                lastpos = pos + 2
-            else:
-                break
-        else:
-            parts.append(buf[lastpos:])
-            break
-    return string.join(parts, '')
-
-def find_enums(buf):
-    enums = []    
-    buf = strip_comments(buf)
-    buf = re.sub('\n', ' ', buf)
-    
-    enum_pat = re.compile(r'enum\s*{([^}]*)}\s*([A-Z][A-Za-z]*)(\s|;)')
-    splitter = re.compile(r'\s*,\s', re.MULTILINE)
-    pos = 0
-    while pos < len(buf):
-        m = enum_pat.search(buf, pos)
-        if not m: break
-
-        name = m.group(2)
-        vals = m.group(1)
-        isflags = string.find(vals, '<<') >= 0
-        entries = []
-        for val in splitter.split(vals):
-            if not string.strip(val): continue
-            entries.append(string.split(val)[0])
-        enums.append((name, isflags, entries))
-        
-        pos = m.end()
-    return enums
-
-#typedef unsigned int   dbus_bool_t;
-#typedef struct {
-#
-# }
-#typedef struct FooStruct FooStruct;
-# typedef void (* DBusAddWatchFunction)      (DBusWatch      *watch,
-#					    void           *data);
-
-def find_typedefs(buf):
-    typedefs = []
-    buf = re.sub('\n', ' ', strip_comments(buf))
-    typedef_pat = re.compile(
-        r"""typedef\s*(?P<type>\w*)
-            \s*
-            ([(]\s*\*\s*(?P<callback>[\w* ]*)[)]|{([^}]*)}|)
-            \s*
-            (?P<args1>[(](?P<args2>[\s\w*,_]*)[)]|[\w ]*)""",
-        re.MULTILINE | re.VERBOSE)
-    pat = re.compile(r"""\s+""", re.MULTILINE) 
-    pos = 0
-    while pos < len(buf):
-        m = typedef_pat.search(buf, pos)
-        if not m:
-            break
-        if m.group('type') == 'enum':
-            pos = m.end()
-            continue
-        if m.group('args2') != None:
-            args = pat.sub(' ', m.group('args2'))
-            
-            current = '%s (* %s) (%s)' % (m.group('type'),
-                                          m.group('callback'),
-                                          args)
-        else:
-            current = '%s %s' % (m.group('type'), m.group('args1'))
-        typedefs.append(current)
-        pos = m.end()
-    return typedefs
-
-proto_pat = re.compile(r"""
-(?P<ret>(-|\w|\&|\*|\s)+\s*)      # return type
-\s+                            # skip whitespace
-(?P<func>\w+)\s*[(]  # match the function name until the opening (
-(?P<args>.*?)[)]               # group the function arguments
-""", re.IGNORECASE|re.VERBOSE)
-arg_split_pat = re.compile("\s*,\s*")
-
-
-def find_functions(buf):
-    functions = []
-    buf = clean_func(buf)
-    buf = string.split(buf,'\n')
-    for p in buf:
-        if len(p) == 0:
-            continue
-        m = proto_pat.match(p)
-        if m == None:
-            continue
-        
-        func = m.group('func')
-        ret = m.group('ret')
-        args = m.group('args')
-        args = arg_split_pat.split(args)
-#        for i in range(len(args)):
-#            spaces = string.count(args[i], ' ')
-#            if spaces > 1:
-#                args[i] = string.replace(args[i], ' ', '-', spaces - 1)
-
-        functions.append((func, ret, args))
-    return functions
-
-class Writer:
-    def __init__(self, filename, enums, typedefs, functions):
-        if not (enums or typedefs or functions):
-            return
-        print 'cdef extern from "%s":' % filename
-
-        self.output_enums(enums)
-        self.output_typedefs(typedefs)
-        self.output_functions(functions)        
-        
-        print '    pass'
-        print
-        
-    def output_enums(self, enums):
-        for enum in enums:
-            print '    ctypedef enum %s:' % enum[0]
-            if enum[1] == 0:
-                for item in enum[2]:
-                    print '        %s' % item
-            else:
-                i = 0
-                for item in enum[2]:
-                    print '        %s' % item                    
-#                    print '        %s = 1 << %d' % (item, i)
-                    i += 1
-            print
-    def output_typedefs(self, typedefs):
-        for typedef in typedefs:
-            if typedef.find('va_list') != -1:
-                continue
-            
-            parts = typedef.split()
-            if parts[0] == 'struct':
-                if parts[-2] == parts[-1]:
-                    parts = parts[:-1]
-                print '    ctypedef %s' % ' '.join(parts)
-            else:
-                print '    ctypedef %s' % typedef
-
-    def output_functions(self, functions):
-        for func, ret, args in functions:
-            if func[0] == '_':
-                continue
-
-            str = ', '.join(args)
-            if str.find('...') != -1:
-                continue
-            if str.find('va_list') != -1:
-                continue
-            if str.strip() == 'void':
-                continue
-            print '    %-20s %s (%s)' % (ret, func, str)
-
-def do_buffer(name, buffer):
-    functions = find_functions(buffer)
-    typedefs = find_typedefs(buffer)
-    enums = find_enums(buffer)
-
-    Writer(name, enums, typedefs, functions)
-    
-def do_header(filename, name=None):
-    if name == None:
-        name = filename
-        
-    buffer = ""
-    for line in open(filename).readlines():
-        if line[0] == '#':
-            continue
-        buffer += line
-
-    print '# -- %s -- ' % filename
-    do_buffer(name, buffer)
-    
-filename = sys.argv[1]
-
-if filename.endswith('.h'):
-    do_header(filename)
-    raise SystemExit
-
-cppflags = ""
-
-for flag in sys.argv[2:]:
-    cppflags = cppflags + " " + flag
-
-fd = open(filename)
-
-for line in fd.readlines():
-    if line.startswith('#include'):
-        filename = line.split(' ')[1][1:-2]
-        command = "echo '%s'|cpp %s" % (line, cppflags)
-        sys.stderr.write('running %s' % (command))
-        output = commands.getoutput(command)
-        do_buffer(filename, output)
-    else:
-        print line[:-1]
diff --git a/python/glib.py b/python/glib.py
deleted file mode 100644
index e1c3d9ca..00000000
--- a/python/glib.py
+++ /dev/null
@@ -1,17 +0,0 @@
-import dbus
-import dbus_glib_bindings
-
-def _setup_with_g_main(conn):
-    dbus_glib_bindings.setup_with_g_main(conn._connection)
-
-_dbus_gthreads_initialized = False
-def threads_init():
-    global _dbus_gthreads_initialized
-    if not _dbus_gthreads_initialized:
-        dbus_glib_bindings.gthreads_init()
-        _dbus_gthreads_initialized = True
-
-def init_threads():
-    threads_init()
-
-setattr(dbus, "_dbus_mainloop_setup_function", _setup_with_g_main)
diff --git a/python/introspect_parser.py b/python/introspect_parser.py
deleted file mode 100644
index 47c9806e..00000000
--- a/python/introspect_parser.py
+++ /dev/null
@@ -1,51 +0,0 @@
-import libxml2
-import cStringIO
-import exceptions
-
-def process_introspection_data(data):
-    method_map = {}
-
-    XMLREADER_START_ELEMENT_NODE_TYPE = 1
-    XMLREADER_END_ELEMENT_NODE_TYPE = 15
-
-    stream = cStringIO.StringIO(data.encode('utf-8'))
-    input_source = libxml2.inputBuffer(stream)
-    reader = input_source.newTextReader("urn:introspect")
-
-    ret = reader.Read()
-    current_iface = None
-    current_method = None
-    current_sigstr = ''
-
-    while ret == 1:
-        name = reader.LocalName()
-        if reader.NodeType() == XMLREADER_START_ELEMENT_NODE_TYPE:
-            if (not current_iface and not current_method and name == 'interface'):
-                current_iface = reader.GetAttribute('name')
-            elif (current_iface and not current_method and name == 'method'):
-                current_method = reader.GetAttribute('name')
-                if reader.IsEmptyElement():
-                    method_map[current_iface + '.' + current_method] = ''
-                    current_method = None
-                    current_sigstr = ''
-
-            elif (current_iface and current_method and name == 'arg'):
-                direction = reader.GetAttribute('direction')
-
-                if not direction or direction == 'in':
-                    current_sigstr = current_sigstr + reader.GetAttribute('type')
-
-        elif reader.NodeType() == XMLREADER_END_ELEMENT_NODE_TYPE:
-            if (current_iface and not current_method and name == 'interface'):
-                current_iface = None
-            if (current_iface and current_method and name == 'method'):
-                method_map[current_iface + '.' + current_method] = current_sigstr
-                current_method = None
-                current_sigstr = ''
-
-        ret = reader.Read()
-
-    if ret != 0:
-        raise exceptions.IntrospectionParserException(data)
-
-    return method_map
diff --git a/python/matchrules.py b/python/matchrules.py
deleted file mode 100644
index 023a5b76..00000000
--- a/python/matchrules.py
+++ /dev/null
@@ -1,232 +0,0 @@
-from exceptions import DBusException
-
-class SignalMatchNode:
-    def __init__(self):
-        self.wildcard = None
-        self.finite = {}
-        self.rules = []
-        
-    def add(self, key, leaf=None):
-        node = None
-        
-        if key:
-            if self.finite.has_key(key):
-                node = self.finite[key]
-            else:
-                node = SignalMatchNode()
-                self.finite[key]  = node
-        else:
-            if self.wildcard:
-                node = self.wildcard
-            else:
-                node = SignalMatchNode()
-                self.wildcard = node
-         
-        node.rules.append(leaf)
-        return node
-    
-    def get_matches(self, key):
-        result = []
-        if self.wildcard:
-            result.append(self.wildcard)
-        
-        if self.finite.has_key(key):
-            result.append(self.finite[key])
-            
-        return result
-        
-    def get_match(self, key):
-        if key:
-           if self.finite.has_key(key):
-               return self.finite[key]
-           else:
-               return None
-        
-        return self.wildcard
-        
-    def has_children(self):
-        if self.wildcard or len(self.finite.iterkeys()) > 0:
-            return True
-        return False
-
-    def remove_child(self, child, key=None):
-        if self.wildcard == child:
-            self.wildcard = None
-        elif self.finite.has_key(key):
-            del self.finite[key]
-
-class SignalMatchTree:
-    """This class creates an ordered tree of SignalMatchRules
-        to speed searchs.  Left branches are wildcard elements
-        and all other branches are concreet elements.
-    """
-    def __init__(self):
-        self._tree = SignalMatchNode()
-    
-    def add(self, rule):
-        interface = self._tree.add(rule.sender)
-        signal = interface.add(rule.dbus_interface)
-        path = signal.add(rule.signal_name)
-        path.add(rule.path, leaf=rule)
-       
-    def exec_matches(self, match_rule, message):
-        args = message.get_args_list()
-    
-        sender_matches = self._tree.get_matches(match_rule.sender)
-        for sender_node in sender_matches:
-            interface_matches = sender_node.get_matches(match_rule.dbus_interface)
-            for interface_node in interface_matches:
-                signal_matches = interface_node.get_matches(match_rule.signal_name)
-                for signal_node in signal_matches:
-                    path_matches = signal_node.get_matches(match_rule.path)
-                    for path_node in path_matches:
-                        if(path_node.rules):
-                            for rule in path_node.rules:
-                                if (rule.match_args_from_list(args)):
-                                    rule.execute(message, args)
-            
-    def remove(self, rule):
-        try:
-            sender = self._tree.get_match(rule.sender)
-            interface = sender.get_match(rule.dbus_interface)
-            signal = interface.get_match(rule.signal_name)
-            path = signal.get_match(rule.path)
-            
-            rule_matches = []
-            for _rule in path.rules:
-                if _rule.is_match(rule):
-                    rule_matches.append(_rule)
-                    
-            for _rule in rule_matches:
-                path.rules.remove(_rule)
-                
-            #clean up tree
-            if len(path.rules) == 0:
-                signal.remove_child(path, key = rule.path)
-                if not signal.has_children():
-                    interface.remove_child(signal, key = rule.signal_name)
-                    if not interface.has_children():
-                        sender.remove_child(interface, key = rule.dbus_interface)
-                        if not sender.has_children():
-                            self._tree.remove_child(sender, key = rule.sender)
-            
-        except:
-            raise DBusException ("Trying to remove unkown rule: %s"%str(rule))
-
-class SignalMatchRule:
-    """This class represents a dbus rule used to filter signals.
-        When a rule matches a filter, the signal is propagated to the handler_funtions
-    """
-    def __init__(self, signal_name, dbus_interface, sender, path):
-        self.handler_functions = []
-
-        self.signal_name = signal_name
-        self.dbus_interface = dbus_interface
-        self.sender = sender
-        self.path = path
-        self.args = None
-
-    def add_args_match(self, args):
-        self.args = args
-
-    def execute(self, message, args=None):
-        keywords = {}
-
-        if self.sender_keyword is not None:
-            keywords[self.sender_keyword] = message.get_sender()
-        if self.path_keyword is not None:
-            keywords[self.path_keyword] = message.get_path()
-
-        # optimization just in case we already extracted the args
-        if not args:
-           args = message.get_args_list()
-           
-        for handler in self.handler_functions:
-            if getattr(handler, "_dbus_pass_message", False):
-                keywords["dbus_message"] = message
-
-            if len(keywords) == 0:
-                handler(*args)
-            else:
-                handler(*args, **keywords)
-
-    def add_handler(self, handler):
-        self.handler_functions.append(handler)
-    
-    #matches only those arguments listed by self
-    def match_args_from_list(self, args_list):
-        if not self.args:
-            return True
-
-        last_index = len(args_list) - 1
-        for (index, value) in self.args.iteritems():
-            if index > last_index:
-                return False
-                
-            if not (args_list[index] == value):
-                return False
-
-        return True
-    
-    #does exact matching
-    def match_args_from_rule(self, rule):
-        if self.args == rule.args:
-            return True
-
-        if self.args == None or rule.args == None:
-            return False
-
-        my_args_list = self.args.items()
-        match_args_list = rule.args.iterms()
-
-        if len(my_args_list) != len(match_args_list):
-            return False
-
-        for (key, value) in my_args_list:
-            if rule.args.get(key) != value:
-                return False
-
-        return True
-
-    def is_match(self, rule):
-        if (self.signal_name == rule.signal_name and
-            self.dbus_interface == rule.dbus_interface and
-            self.sender == rule.sender and
-            self.path == rule.path and
-            self.match_args_from_rule(rule)):
-                if rule.handler_functions == []:
-                    return True
-            
-                _funcs_copy_a = self.handler_functions[0:]
-                _funcs_copy_b = rule.handler_functions[0:]
-                _funcs_copy_a.sort()
-                _funcs_copy_b.sort()
-
-                return _funcs_copy_a == _funcs_copy_b
- 
-        return False
-
-    def __repr__(self):
-        """Returns a custom representation of this DBusMatchRule that can
-            be used with dbus_bindings
-        """
-        repr = "type='signal'"
-        if (self.dbus_interface):
-            repr = repr + ",interface='%s'" % (self.dbus_interface)
-
-        if (self.sender):     
-            repr = repr + ",sender='%s'" % (self.sender)
-    
-        if (self.path):
-            repr = repr + ",path='%s'" % (self.path)
-            
-        if (self.signal_name):
-            repr = repr + ",member='%s'" % (self.signal_name)
-   
-        if (self.args):
-            my_args_list = self.args.items()
-            my_args_list.sort()
-            for (index, value) in my_args_list:
-                repr = repr + ",arg%i='%s'" % (index, value)
-
-        return repr
diff --git a/python/proxies.py b/python/proxies.py
deleted file mode 100644
index 80e9ac27..00000000
--- a/python/proxies.py
+++ /dev/null
@@ -1,222 +0,0 @@
-import dbus_bindings
-import introspect_parser
-import sys
-from exceptions import MissingReplyHandlerException, MissingErrorHandlerException, IntrospectionParserException
-
-class DeferedMethod:
-    """A DeferedMethod
-    
-    This is returned instead of ProxyMethod when we are defering DBus calls
-    while waiting for introspection data to be returned
-    """
-    def __init__(self, proxy_method):
-        self._proxy_method = proxy_method
-        self._method_name  = proxy_method._method_name
-    
-    def __call__(self, *args, **keywords):
-        reply_handler = None
-        if keywords.has_key('reply_handler'):
-            reply_handler = keywords['reply_handler']
-
-        #block for now even on async
-        # FIXME: put ret in async queue in future if we have a reply handler
-
-        self._proxy_method._proxy._pending_introspect.block()
-        ret = self._proxy_method (*args, **keywords)
-        
-        return ret
-
-class ProxyMethod:
-    """A proxy Method.
-
-    Typically a member of a ProxyObject. Calls to the
-    method produce messages that travel over the Bus and are routed
-    to a specific named Service.
-    """
-    def __init__(self, proxy, connection, named_service, object_path, method_name, iface):
-        self._proxy          = proxy
-        self._connection     = connection
-        self._named_service  = named_service
-        self._object_path    = object_path
-        self._method_name    = method_name
-        self._dbus_interface = iface
-
-    def __call__(self, *args, **keywords):
-        timeout = -1
-        if keywords.has_key('timeout'):
-            timeout = keywords['timeout']
-
-        reply_handler = None
-        if keywords.has_key('reply_handler'):
-            reply_handler = keywords['reply_handler']
-
-        error_handler = None
-        if keywords.has_key('error_handler'):
-            error_handler = keywords['error_handler']            
-
-        ignore_reply = False
-        if keywords.has_key('ignore_reply'):
-            ignore_reply = keywords['ignore_reply']
-
-
-        if not(reply_handler and error_handler):
-            if reply_handler:
-                raise MissingErrorHandlerException()
-            elif error_handler:
-                raise MissingReplyHandlerException()
-
-        dbus_interface = self._dbus_interface 
-        if keywords.has_key('dbus_interface'):
-            dbus_interface = keywords['dbus_interface']
-
-        tmp_iface = ''
-        if dbus_interface:
-	    tmp_iface = dbus_interface + '.'
-
-        key = tmp_iface + self._method_name
-
-        introspect_sig = None
-        if self._proxy._introspect_method_map.has_key (key):
-            introspect_sig = self._proxy._introspect_method_map[key]
-
-        message = dbus_bindings.MethodCall(self._object_path, dbus_interface, self._method_name)
-        message.set_destination(self._named_service)
-        
-        # Add the arguments to the function
-        iter = message.get_iter(True)
-
-        if introspect_sig:
-            for (arg, sig) in zip(args, dbus_bindings.Signature(introspect_sig)):
-                iter.append_strict(arg, sig)
-        else:
-            for arg in args:
-                iter.append(arg)
-
-        if ignore_reply:
-            result = self._connection.send(message)
-            args_tuple = (result,)
-        elif reply_handler:
-            result = self._connection.send_with_reply_handlers(message, timeout, reply_handler, error_handler)
-            args_tuple = result
-        else:
-            reply_message = self._connection.send_with_reply_and_block(message, timeout)
-            args_tuple = reply_message.get_args_list()
-
-        if len(args_tuple) == 0:
-            return
-        elif len(args_tuple) == 1:
-            return args_tuple[0]
-        else:
-            return args_tuple
-
-
-class ProxyObject:
-    """A proxy to the remote Object.
-
-    A ProxyObject is provided by the Bus. ProxyObjects
-    have member functions, and can be called like normal Python objects.
-    """
-    ProxyMethodClass = ProxyMethod
-    DeferedMethodClass = DeferedMethod
-
-    INTROSPECT_STATE_DONT_INTROSPECT = 0
-    INTROSPECT_STATE_INTROSPECT_IN_PROGRESS = 1
-    INTROSPECT_STATE_INTROSPECT_DONE = 2
-
-    def __init__(self, bus, named_service, object_path, introspect=True):
-        self._bus           = bus
-        self._named_service = named_service
-        self._object_path   = object_path
-
-        #PendingCall object for Introspect call
-        self._pending_introspect = None
-        #queue of async calls waiting on the Introspect to return 
-        self._pending_introspect_queue = []
-        #dictionary mapping method names to their input signatures
-        self._introspect_method_map = {}
-
-        if not introspect:
-            self._introspect_state = self.INTROSPECT_STATE_DONT_INTROSPECT
-        else:
-            self._introspect_state = self.INTROSPECT_STATE_INTROSPECT_IN_PROGRESS
-            
-            (result, self._pending_introspect) = self._Introspect()
-            
-
-    def connect_to_signal(self, signal_name, handler_function, dbus_interface=None, **keywords):
-        self._bus.add_signal_receiver(handler_function,
-                                      signal_name=signal_name,
-                                      dbus_interface=dbus_interface,
-                                      named_service=self._named_service,
-                                      path=self._object_path,
-                                      **keywords)
-
-    def _Introspect(self):
-        message = dbus_bindings.MethodCall(self._object_path, 'org.freedesktop.DBus.Introspectable', 'Introspect')
-        message.set_destination(self._named_service)
-        
-        result = self._bus.get_connection().send_with_reply_handlers(message, -1, 
-                                                                     self._introspect_reply_handler, 
-                                                                     self._introspect_error_handler)
-        return result   
-    
-    def _introspect_execute_queue(self): 
-        for call in self._pending_introspect_queue:
-            (member, iface, args, keywords) = call
-
-            introspect_sig = None
-
-            tmp_iface = ''
-            if iface:
-                tmp_iface = iface + '.'
-                    
-            key = tmp_iface + '.' + member
-            if self._introspect_method_map.has_key (key):
-                introspect_sig = self._introspect_method_map[key]
-
-            
-            call_object = self.ProxyMethodClass(self._bus.get_connection(),
-                                                self._named_service,
-                                                self._object_path, 
-                                                iface, 
-                                                member,
-                                                introspect_sig)
-                                                                       
-            call_object(args, keywords)
-
-    def _introspect_reply_handler(self, data):
-        try:
-            self._introspect_method_map = introspect_parser.process_introspection_data(data)
-        except IntrospectionParserException, e:
-            self._introspect_error_handler(e)
-            return
-        
-        self._introspect_state = self.INTROSPECT_STATE_INTROSPECT_DONE
-        #self._introspect_execute_queue()
-
-    def _introspect_error_handler(self, error):
-        self._introspect_state = self.INTROSPECT_STATE_DONT_INTROSPECT
-        self._introspect_execute_queue()
-        sys.stderr.write("Introspect error: " + str(error) + "\n")
-
-    def __getattr__(self, member, dbus_interface=None):
-        if member == '__call__':
-            return object.__call__
-        elif member.startswith('__') and member.endswith('__'):
-            raise AttributeError(member)
-        else:
-            ret = self.ProxyMethodClass(self, self._bus.get_connection(),
-                                        self._named_service,
-                                        self._object_path, member, 
-                                        dbus_interface)
-        
-            if self._introspect_state == self.INTROSPECT_STATE_INTROSPECT_IN_PROGRESS:
-                ret = self.DeferedMethodClass(ret)
-                    
-            return ret
-
-    def __repr__(self):
-        return '<ProxyObject wrapping %s %s %s at %#x>'%(
-            self._bus, self._named_service, self._object_path , id(self))
-    __str__ = __repr__
-
diff --git a/python/service.py b/python/service.py
deleted file mode 100644
index 9148a357..00000000
--- a/python/service.py
+++ /dev/null
@@ -1,370 +0,0 @@
-import dbus_bindings
-import _dbus
-import operator
-import traceback
-
-from exceptions import NameExistsException
-from exceptions import UnknownMethodException
-from decorators import method
-from decorators import signal
-
-class BusName(object):
-    """A base class for exporting your own Named Services across the Bus
-    """
-    def __new__(cls, name, bus=None):
-        # get default bus
-        if bus == None:
-            bus = _dbus.Bus()
-
-        # see if this name is already defined, return it if so
-        if name in bus._bus_names:
-            return bus._bus_names[name]
-
-        # otherwise register the name
-        retval = dbus_bindings.bus_request_name(bus.get_connection(), name)
-
-        # TODO: more intelligent tracking of bus name states?
-        if retval == dbus_bindings.REQUEST_NAME_REPLY_PRIMARY_OWNER:
-            pass
-        elif retval == dbus_bindings.REQUEST_NAME_REPLY_IN_QUEUE:
-            # queueing can happen by default, maybe we should
-            # track this better or let the user know if they're
-            # queued or not?
-            pass
-        elif retval == dbus_bindings.REQUEST_NAME_REPLY_EXISTS:
-            raise NameExistsException(name)
-        elif retval == dbus_bindings.REQUEST_NAME_REPLY_ALREADY_OWNER:
-            # if this is a shared bus which is being used by someone
-            # else in this process, this can happen legitimately
-            pass
-        else:
-            raise RuntimeError('requesting bus name %s returned unexpected value %s' % (name, retval))
-
-        # and create the object
-        bus_name = object.__new__(cls)
-        bus_name._bus = bus
-        bus_name._name = name
-
-        # cache instance
-        bus._bus_names[name] = bus_name
-
-        return bus_name
-
-    # do nothing because this is called whether or not the bus name
-    # object was retrieved from the cache or created new
-    def __init__(self, *args, **keywords):
-        pass
-
-    # we can delete the low-level name here because these objects
-    # are guaranteed to exist only once for each bus name
-    def __del__(self):
-        dbus_bindings.bus_release_name(self._bus.get_connection(), self._name)
-        pass
-
-    def get_bus(self):
-        """Get the Bus this Service is on"""
-        return self._bus
-
-    def get_name(self):
-        """Get the name of this service"""
-        return self._name
-
-    def __repr__(self):
-        return '<dbus.service.BusName %s on %r at %#x>' % (self._name, self._bus, id(self))
-    __str__ = __repr__
-
-
-def _method_lookup(self, method_name, dbus_interface):
-    """Walks the Python MRO of the given class to find the method to invoke.
-
-    Returns two methods, the one to call, and the one it inherits from which
-    defines its D-Bus interface name, signature, and attributes.
-    """
-    parent_method = None
-    candidate_class = None
-    successful = False
-
-    # split up the cases when we do and don't have an interface because the
-    # latter is much simpler
-    if dbus_interface:
-        # search through the class hierarchy in python MRO order
-        for cls in self.__class__.__mro__:
-            # if we haven't got a candidate class yet, and we find a class with a
-            # suitably named member, save this as a candidate class
-            if (not candidate_class and method_name in cls.__dict__):
-                if ("_dbus_is_method" in cls.__dict__[method_name].__dict__
-                    and "_dbus_interface" in cls.__dict__[method_name].__dict__):
-                    # however if it is annotated for a different interface
-                    # than we are looking for, it cannot be a candidate
-                    if cls.__dict__[method_name]._dbus_interface == dbus_interface:
-                        candidate_class = cls
-                        parent_method = cls.__dict__[method_name]
-                        successful = True
-                        break
-                    else:
-                        pass
-                else:
-                    candidate_class = cls
-
-            # if we have a candidate class, carry on checking this and all
-            # superclasses for a method annoated as a dbus method
-            # on the correct interface
-            if (candidate_class and method_name in cls.__dict__
-                and "_dbus_is_method" in cls.__dict__[method_name].__dict__
-                and "_dbus_interface" in cls.__dict__[method_name].__dict__
-                and cls.__dict__[method_name]._dbus_interface == dbus_interface):
-                # the candidate class has a dbus method on the correct interface,
-                # or overrides a method that is, success!
-                parent_method = cls.__dict__[method_name]
-                successful = True
-                break
-
-    else:
-        # simpler version of above
-        for cls in self.__class__.__mro__:
-            if (not candidate_class and method_name in cls.__dict__):
-                candidate_class = cls
-
-            if (candidate_class and method_name in cls.__dict__
-                and "_dbus_is_method" in cls.__dict__[method_name].__dict__):
-                parent_method = cls.__dict__[method_name]
-                successful = True
-                break
-
-    if successful:
-        return (candidate_class.__dict__[method_name], parent_method)
-    else:
-        if dbus_interface:
-            raise UnknownMethodException('%s is not a valid method of interface %s' % (method_name, dbus_interface))
-        else:
-            raise UnknownMethodException('%s is not a valid method' % method_name)
-
-
-def _method_reply_return(connection, message, method_name, signature, *retval):
-    reply = dbus_bindings.MethodReturn(message)
-    iter = reply.get_iter(append=True)
-
-    # do strict adding if an output signature was provided
-    if signature:
-        if len(signature) > len(retval):
-            raise TypeError('output signature %s is longer than the number of values returned by %s' %
-                (signature, method_name))
-        elif len(retval) > len(signature):
-            raise TypeError('output signature %s is shorter than the number of values returned by %s' %
-                (signature, method_name))
-        else:
-            for (value, sig) in zip(retval, signature):
-                iter.append_strict(value, sig)
-
-    # no signature, try and guess the return type by inspection
-    else:
-        for value in retval:
-            iter.append(value)
-
-    connection.send(reply)
-
-
-def _method_reply_error(connection, message, exception):
-    if '_dbus_error_name' in exception.__dict__:
-        name = exception._dbus_error_name
-    elif exception.__module__ == '__main__':
-        name = 'org.freedesktop.DBus.Python.%s' % exception.__class__.__name__
-    else:
-        name = 'org.freedesktop.DBus.Python.%s.%s' % (exception.__module__, exception.__class__.__name__)
-
-    contents = traceback.format_exc()
-    reply = dbus_bindings.Error(message, name, contents)
-
-    connection.send(reply)
-
-
-class InterfaceType(type):
-    def __init__(cls, name, bases, dct):
-        # these attributes are shared between all instances of the Interface
-        # object, so this has to be a dictionary that maps class names to
-        # the per-class introspection/interface data
-        class_table = getattr(cls, '_dbus_class_table', {})
-        cls._dbus_class_table = class_table
-        interface_table = class_table[cls.__module__ + '.' + name] = {}
-
-        # merge all the name -> method tables for all the interfaces
-        # implemented by our base classes into our own
-        for b in bases:
-            base_name = b.__module__ + '.' + b.__name__
-            if getattr(b, '_dbus_class_table', False):
-                for (interface, method_table) in class_table[base_name].iteritems():
-                    our_method_table = interface_table.setdefault(interface, {})
-                    our_method_table.update(method_table)
-
-        # add in all the name -> method entries for our own methods/signals
-        for func in dct.values():
-            if getattr(func, '_dbus_interface', False):
-                method_table = interface_table.setdefault(func._dbus_interface, {})
-                method_table[func.__name__] = func
-
-        super(InterfaceType, cls).__init__(name, bases, dct)
-
-    # methods are different to signals, so we have two functions... :)
-    def _reflect_on_method(cls, func):
-        args = func._dbus_args
-
-        if func._dbus_in_signature:
-            # convert signature into a tuple so length refers to number of
-            # types, not number of characters. the length is checked by
-            # the decorator to make sure it matches the length of args.
-            in_sig = tuple(dbus_bindings.Signature(func._dbus_in_signature))
-        else:
-            # magic iterator which returns as many v's as we need
-            in_sig = dbus_bindings.VariantSignature()
-
-        if func._dbus_out_signature:
-            out_sig = dbus_bindings.Signature(func._dbus_out_signature)
-        else:
-            # its tempting to default to dbus_bindings.Signature('v'), but
-            # for methods that return nothing, providing incorrect
-            # introspection data is worse than providing none at all
-            out_sig = []
-
-        reflection_data = '    <method name="%s">\n' % (func.__name__)
-        for pair in zip(in_sig, args):
-            reflection_data += '      <arg direction="in"  type="%s" name="%s" />\n' % pair
-        for type in out_sig:
-            reflection_data += '      <arg direction="out" type="%s" />\n' % type
-        reflection_data += '    </method>\n'
-
-        return reflection_data
-
-    def _reflect_on_signal(cls, func):
-        args = func._dbus_args
-
-        if func._dbus_signature:
-            # convert signature into a tuple so length refers to number of
-            # types, not number of characters
-            sig = tuple(dbus_bindings.Signature(func._dbus_signature))
-        else:
-            # magic iterator which returns as many v's as we need
-            sig = dbus_bindings.VariantSignature()
-
-        reflection_data = '    <signal name="%s">\n' % (func.__name__)
-        for pair in zip(sig, args):
-            reflection_data = reflection_data + '      <arg type="%s" name="%s" />\n' % pair
-        reflection_data = reflection_data + '    </signal>\n'
-
-        return reflection_data
-
-class Interface(object):
-    __metaclass__ = InterfaceType
-
-class Object(Interface):
-    """A base class for exporting your own Objects across the Bus.
-
-    Just inherit from Object and provide a list of methods to share
-    across the Bus
-    """
-    def __init__(self, bus_name, object_path):
-        self._object_path = object_path
-        self._name = bus_name 
-        self._bus = bus_name.get_bus()
-            
-        self._connection = self._bus.get_connection()
-
-        self._connection.register_object_path(object_path, self._unregister_cb, self._message_cb)
-
-    def _unregister_cb(self, connection):
-        print ("Unregister")
-
-    def _message_cb(self, connection, message):
-        try:
-            # lookup candidate method and parent method
-            method_name = message.get_member()
-            interface_name = message.get_interface()
-            (candidate_method, parent_method) = _method_lookup(self, method_name, interface_name)
-
-            # set up method call parameters
-            args = message.get_args_list()
-            keywords = {}
-
-            # iterate signature into list of complete types
-            if parent_method._dbus_out_signature:
-                signature = tuple(dbus_bindings.Signature(parent_method._dbus_out_signature))
-            else:
-                signature = None
-
-            # set up async callback functions
-            if parent_method._dbus_async_callbacks:
-                (return_callback, error_callback) = parent_method._dbus_async_callbacks
-                keywords[return_callback] = lambda *retval: _method_reply_return(connection, message, method_name, signature, *retval)
-                keywords[error_callback] = lambda exception: _method_reply_error(connection, message, exception)
-
-            # include the sender if desired
-            if parent_method._dbus_sender_keyword:
-                keywords[parent_method._dbus_sender_keyword] = message.get_sender()
-
-            # call method
-            retval = candidate_method(self, *args, **keywords)
-
-            # we're done - the method has got callback functions to reply with
-            if parent_method._dbus_async_callbacks:
-                return
-
-            # otherwise we send the return values in a reply. if we have a
-            # signature, use it to turn the return value into a tuple as
-            # appropriate
-            if parent_method._dbus_out_signature:
-                # if we have zero or one return values we want make a tuple
-                # for the _method_reply_return function, otherwise we need
-                # to check we're passing it a sequence
-                if len(signature) == 0:
-                    if retval == None:
-                        retval = ()
-                    else:
-                        raise TypeError('%s has an empty output signature but did not return None' %
-                            method_name)
-                elif len(signature) == 1:
-                    retval = (retval,)
-                else:
-                    if operator.isSequenceType(retval):
-                        # multi-value signature, multi-value return... proceed unchanged
-                        pass
-                    else:
-                        raise TypeError('%s has multiple output values in signature %s but did not return a sequence' %
-                            (method_name, signature))
-
-            # no signature, so just turn the return into a tuple and send it as normal
-            else:
-                signature = None
-                if retval == None:
-                    retval = ()
-                else:
-                    retval = (retval,)
-
-            _method_reply_return(connection, message, method_name, signature, *retval)
-        except Exception, exception:
-            # send error reply
-            _method_reply_error(connection, message, exception)
-
-    @method('org.freedesktop.DBus.Introspectable', in_signature='', out_signature='s')
-    def Introspect(self):
-        reflection_data = '<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">\n'
-        reflection_data += '<node name="%s">\n' % (self._object_path)
-
-        interfaces = self._dbus_class_table[self.__class__.__module__ + '.' + self.__class__.__name__]
-        for (name, funcs) in interfaces.iteritems():
-            reflection_data += '  <interface name="%s">\n' % (name)
-
-            for func in funcs.values():
-                if getattr(func, '_dbus_is_method', False):
-                    reflection_data += self.__class__._reflect_on_method(func)
-                elif getattr(func, '_dbus_is_signal', False):
-                    reflection_data += self.__class__._reflect_on_signal(func)
-
-            reflection_data += '  </interface>\n'
-
-        reflection_data += '</node>\n'
-
-        return reflection_data
-
-    def __repr__(self):
-        return '<dbus.service.Object %s on %r at %#x>' % (self._object_path, self._name, id(self))
-    __str__ = __repr__
-
diff --git a/python/types.py b/python/types.py
deleted file mode 100644
index f3d348c6..00000000
--- a/python/types.py
+++ /dev/null
@@ -1,19 +0,0 @@
-import dbus_bindings
-
-ObjectPath = dbus_bindings.ObjectPath
-ByteArray = dbus_bindings.ByteArray
-Signature = dbus_bindings.Signature
-Byte = dbus_bindings.Byte
-Boolean = dbus_bindings.Boolean
-Int16 = dbus_bindings.Int16
-UInt16 = dbus_bindings.UInt16
-Int32 = dbus_bindings.Int32
-UInt32 = dbus_bindings.UInt32
-Int64 = dbus_bindings.Int64
-UInt64 = dbus_bindings.UInt64
-Double = dbus_bindings.Double
-String = dbus_bindings.String
-Array = dbus_bindings.Array
-Struct = dbus_bindings.Struct
-Dictionary = dbus_bindings.Dictionary
-Variant = dbus_bindings.Variant