diff options
Diffstat (limited to 'python')
| -rw-r--r-- | python/.cvsignore | 8 | ||||
| -rw-r--r-- | python/Makefile.am | 28 | ||||
| -rw-r--r-- | python/dbus.py | 267 | ||||
| -rw-r--r-- | python/dbus_bindings.pyx.in | 917 | ||||
| -rw-r--r-- | python/dbus_h_wrapper.h | 3 | ||||
| -rw-r--r-- | python/examples/example-client.py | 12 | ||||
| -rw-r--r-- | python/examples/example-service.py | 18 | ||||
| -rw-r--r-- | python/examples/example-signals.py | 27 | ||||
| -rw-r--r-- | python/extract.py | 237 |
9 files changed, 0 insertions, 1517 deletions
diff --git a/python/.cvsignore b/python/.cvsignore deleted file mode 100644 index 8902bbe5..00000000 --- a/python/.cvsignore +++ /dev/null @@ -1,8 +0,0 @@ -*.pyc -*.pyo -Makefile -Makefile.in -build -*.la -*.lo -*.o
\ No newline at end of file diff --git a/python/Makefile.am b/python/Makefile.am deleted file mode 100644 index 792dc477..00000000 --- a/python/Makefile.am +++ /dev/null @@ -1,28 +0,0 @@ -INCLUDES=-I$(top_builddir) -I$(top_builddir)/glib $(DBUS_CLIENT_CFLAGS) $(DBUS_GLIB_CFLAGS) $(DBUS_GLIB_TOOL_CFLAGS) $(PYTHON_INCLUDES) - -dbusdir = $(pythondir) -dbus_PYTHON = dbus.py - -dbusbindingsdir = $(pythondir) -dbusbindings_LTLIBRARIES = dbus_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 $(top_builddir)/glib/libdbus-glib-1.la -dbus_bindings_la_SOURCES = dbus_bindings.c - -EXTRA_DIST = \ - dbus_bindings.pyx.in \ - extract.py \ - setup.py \ - test.py - -CLEANFILES = \ - dbus_bindings.pyx \ - dbus_bindings.c - - -dbus_bindings.pyx: dbus_bindings.pyx.in extract.py - -$(PYTHON) extract.py dbus_bindings.pyx.in -I$(top_builddir) > dbus_bindings.pyx - -dbus_bindings.c: dbus_bindings.pyx - -pyrexc dbus_bindings.pyx diff --git a/python/dbus.py b/python/dbus.py deleted file mode 100644 index c7ab5dd3..00000000 --- a/python/dbus.py +++ /dev/null @@ -1,267 +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_bindings - -class Bus: - """A connection to a DBus daemon. - - One of three possible standard buses, the SESSION, SYSTEM, - or ACTIVATION bus - """ - TYPE_SESSION = dbus_bindings.BUS_SESSION - TYPE_SYSTEM = dbus_bindings.BUS_SYSTEM - TYPE_ACTIVATION = dbus_bindings.BUS_ACTIVATION - - def __init__(self, bus_type=TYPE_SESSION, glib_mainloop=True): - self._connection = dbus_bindings.bus_get(bus_type) - - self._connection.add_filter(self._signal_func) - self._match_rule_to_receivers = { } - if (glib_mainloop): - self._connection.setup_with_g_main() - - def get_service(self, service_name="org.freedesktop.Broadcast"): - """Get one of the RemoteServices connected to this Bus. service_name - is just a string of the form 'com.widgetcorp.MyService' - """ - return RemoteService(self._connection, service_name) - - def add_signal_receiver(self, receiver, interface=None, service=None, path=None): - match_rule = self._get_match_rule(interface, service, path) - - if (not self._match_rule_to_receivers.has_key(match_rule)): - self._match_rule_to_receivers[match_rule] = [ ] - self._match_rule_to_receivers[match_rule].append(receiver) - - dbus_bindings.bus_add_match(self._connection, match_rule) - - def get_connection(self): - """Get the dbus_bindings.Connection object associated with this Bus""" - return self._connection - - def _get_match_rule(self, interface, service, path): -## if (interface): -## match_rule = match_rule + ",interface='%s'" % (interface) -## if (service): -## match_rule = match_rule + ",service='%s'" % (service) -## if (path): -## match_rule = match_rule + ",path='%s'" % (path) - # FIXME: use the service here too!!! - return "type='signal',interface='%s',path='%s'" % (interface, path) - - def _signal_func(self, connection, message): - if (message.get_type() != dbus_bindings.MESSAGE_TYPE_SIGNAL): - return - - interface = message.get_interface() - service = message.get_sender() - path = message.get_path() - member = message.get_member() - - match_rule = self._get_match_rule(interface, service, path) - - if (self._match_rule_to_receivers.has_key(match_rule)): - receivers = self._match_rule_to_receivers[match_rule] - args = [interface, member, service, path] - for receiver in receivers: - receiver(*args) - - -class RemoteObject: - """A remote Object. - - A RemoteObject is provided by a RemoteService on a particular Bus. RemoteObjects - have member functions, and can be called like normal Python objects. - """ - def __init__(self, connection, service_name, object_path, interface): - self._connection = connection - self._service_name = service_name - self._object_path = object_path - self._interface = interface - - def __getattr__(self, member): - if member == '__call__': - return object.__call__ - else: - return RemoteMethod(self._connection, self._service_name, - self._object_path, self._interface, member) - - -class RemoteMethod: - """A remote Method. - - Typically a member of a RemoteObject. Calls to the - method produce messages that travel over the Bus and are routed - to a specific Service. - """ - def __init__(self, connection, service_name, object_path, interface, method_name): - self._connection = connection - self._service_name = service_name - self._object_path = object_path - self._interface = interface - self._method_name = method_name - - def __call__(self, *args): - message = dbus_bindings.MethodCall(self._object_path, self._interface, self._method_name) - message.set_destination(self._service_name) - - # Add the arguments to the function - iter = message.get_iter() - for arg in args: - iter.append(arg) - - reply_message = self._connection.send_with_reply_and_block(message, 5000) - - 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 Service: - """A base class for exporting your own Services across the Bus - - Just inherit from Service, providing the name of your service - (e.g. org.designfu.SampleService). - """ - def __init__(self, service_name, bus=None): - self._service_name = service_name - - if bus == None: - # Get the default bus - self._bus = Bus() - else: - self._bus = bus - - dbus_bindings.bus_acquire_service(self._bus.get_connection(), service_name) - - def get_bus(self): - """Get the Bus this Service is on""" - return self._bus - - def get_service_name(self): - """Get the name of this service""" - return self._service_name - -class Object: - """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. These will appear as member functions of your - ServiceObject. - """ - def __init__(self, object_path, methods_to_share, service): - self._object_path = object_path - self._service = service - self._bus = service.get_bus() - self._connection = self._bus.get_connection() - - self._method_name_to_method = self._build_method_dictionary(methods_to_share) - - self._connection.register_object_path(object_path, self._unregister_cb, self._message_cb) - - def broadcast_signal(self, interface, signal_name): - message = dbus_bindings.Signal(self._object_path, interface, signal_name) - #FIXME: need to set_sender, but it always disconnects when we do this - #message.set_sender(self._service.get_service_name()) - self._connection.send(message) - - def _unregister_cb(self, connection): - print ("Unregister") - - def _message_cb(self, connection, message): - target_method_name = message.get_member() - target_method = self._method_name_to_method[target_method_name] - args = message.get_args_list() - - try: - retval = target_method(*args) - except Exception, e: - if e.__module__ == '__main__': - # FIXME: is it right to use .__name__ here? - error_name = e.__class__.__name__ - else: - error_name = e.__module__ + '.' + str(e.__class__.__name__) - error_contents = str(e) - reply = dbus_bindings.Error(message, error_name, error_contents) - else: - reply = dbus_bindings.MethodReturn(message) - if retval != None: - iter = reply.get_iter() - iter.append(retval) - - self._connection.send(reply) - - def _build_method_dictionary(self, methods): - method_dict = {} - for method in methods: - if method_dict.has_key(method.__name__): - print ('WARNING: registering DBus Object methods, already have a method named %s' % (method.__name__)) - method_dict[method.__name__] = method - return method_dict - -class RemoteService: - """A remote service providing objects. - - A service is typically a process or application that provides - remote objects, but can also be the broadcast service that - receives signals from all applications on the Bus. - """ - - def __init__(self, connection, service_name): - self._connection = connection - self._service_name = service_name - - def get_object(self, object_path, interface): - """Get an object provided by this Service that implements a - particular interface. object_path is a string of the form - '/com/widgetcorp/MyService/MyObject1'. interface looks a lot - like a service_name (they're often the same) and is of the form, - 'com.widgetcorp.MyInterface', and mostly just defines the - set of member functions that will be present in the object. - """ - return RemoteObject(self._connection, self._service_name, object_path, interface) - diff --git a/python/dbus_bindings.pyx.in b/python/dbus_bindings.pyx.in deleted file mode 100644 index 4ae056c5..00000000 --- a/python/dbus_bindings.pyx.in +++ /dev/null @@ -1,917 +0,0 @@ -# -*- Mode: Python -*- - -#include "dbus_h_wrapper.h" - -cdef extern from "stdlib.h": - cdef void *malloc(size_t size) - cdef void free(void *ptr) - -cdef extern from "dbus-glib.h": - ctypedef struct GMainContext - cdef void dbus_connection_setup_with_g_main (DBusConnection *connection, - GMainContext *context) - cdef void dbus_server_setup_with_g_main (DBusServer *server, - GMainContext *context) - -cdef extern from "Python.h": - void Py_XINCREF (object) - void Py_XDECREF (object) - - -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 *) - - -_user_data_references = [ ] - -class DBusException(Exception): - pass - -class ConnectionError(Exception): - pass - -cdef void cunregister_function_handler (DBusConnection *connection, - void *user_data): - tup = <object>user_data - assert (type(tup) == list) - function = tup[1] - args = [Connection(_conn=<object>connection)] - function(*args) - -cdef DBusHandlerResult cmessage_function_handler (DBusConnection *connection, - DBusMessage *msg, - void *user_data): - tup = <object>user_data - assert (type(tup) == list) - function = tup[0] - message = Message(_create=0) - message._set_msg(<object>msg) - args = [Connection(_conn=<object>connection), - message] - retval = function(*args) - if (retval == None): - retval = DBUS_HANDLER_RESULT_HANDLED - return retval - -cdef class Connection: - cdef DBusConnection *conn - - # FIXME: this is a major major hack. We use this because casting values to - # python objects and returning seemed to be corrupting them. This is a "global variable" :-( - cdef char **_parsed_path - - def __init__(self, address=None, _conn=None): - cdef DBusError error - dbus_error_init(&error) - if <DBusConnection*>_conn != NULL: - self.conn = <DBusConnection*>_conn - dbus_connection_ref(self.conn) - else: - self.conn = dbus_connection_open(address, - &error) - if dbus_error_is_set(&error): - raise DBusException, error.message - - dbus_connection_ref(self.conn) - - def _set_conn(self, conn): - self.conn = <DBusConnection*>conn - - def _get_conn(self): - return <object>self.conn - - #FIXME: this is totally busted, don't use a class shared member like parsed_path - def _build_parsed_path(self, path_element_list): - cdef char **cpatharray - size = len(path_element_list) - cpatharray = <char **>malloc(sizeof(char*) * (size + 1)) - - for i in range(size): - path_element = path_element_list[i] - cpatharray[i] = path_element - - cpatharray[size] = NULL - - self._parsed_path = cpatharray - - def get_base_service(self): - return bus_get_base_service(self) - - def setup_with_g_main(self): - dbus_connection_setup_with_g_main(self.conn, NULL) - - def disconnect(self): - dbus_connection_disconnect(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): - m = Message(_create=0) - m._set_msg(<object>dbus_connection_borrow_message(self.conn)) - return m - - def return_message(self, message): - msg = message._get_msg() - dbus_connection_return_message(self.conn, <DBusMessage*>msg) - - def steal_borrowed_message(self, message): - msg = message._get_msg() - dbus_connection_steal_borrowed_message(self.conn, - <DBusMessage*>msg) - - def pop_message(self): - cdef DBusMessage *msg - msg = dbus_connection_pop_message(self.conn) - if msg != NULL: - m = Message(_create=0) - m._set_msg(<object>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): - #cdef dbus_uint32_t client_serial - #if type(message) != Message: - # raise TypeError - - msg = message._get_msg() - retval = dbus_connection_send(self.conn, - <DBusMessage*>msg, - NULL) - return retval - - def send_with_reply(self, message, timeout_milliseconds): - cdef dbus_bool_t retval - cdef DBusPendingCall *cpending_call - cdef DBusError error - dbus_error_init(&error) - - cpending_call = NULL - - msg = message._get_msg() - - retval = dbus_connection_send_with_reply(self.conn, - <DBusMessage*>msg, - &cpending_call, - timeout_milliseconds) - - if dbus_error_is_set(&error): - raise DBusException, error.message - - if (cpending_call != NULL): - pending_call = PendingCall(<object>cpending_call) - else: - pending_call = None - - return (retval, pending_call) - - def send_with_reply_and_block(self, message, - timeout_milliseconds=0): - cdef DBusMessage * retval - cdef DBusError error - dbus_error_init(&error) - - msg = message._get_msg() - - retval = dbus_connection_send_with_reply_and_block( - <DBusConnection*>self.conn, - <DBusMessage*>msg, - <int>timeout_milliseconds, - &error) - - if dbus_error_is_set(&error): - raise DBusException, error.message - - if retval == NULL: - raise AssertionError - - m = Message(_create=0) - m._set_msg(<object>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 ] - global _user_data_references - _user_data_references.append(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] - global _user_data_references - _user_data_references.append(user_data) - - path_element_list = path[1:].split('/') - self._build_parsed_path(path_element_list) - - return dbus_connection_register_object_path(self.conn, self._parsed_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] - global _user_data_references - _user_data_references.append(user_data) - - path_element_list = path[1:].split('/') - self._build_parsed_path(path_element_list) - - return dbus_connection_register_fallback(self.conn, self._parsed_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 - - path_element_list = parent_path[1:].split('/') - self._build_parsed_path(path_element_list) - - retval = dbus_connection_list_registered(self.conn, self._parsed_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 class PendingCall: - cdef DBusPendingCall *pending_call - - def __init__(self, _pending_call): - self.pending_call = <DBusPendingCall*>_pending_call - dbus_pending_call_ref(self.pending_call) - - def _get_pending_call(self): - return <object>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): - message = Message(_create=0) - message._set_msg(<object>dbus_pending_call_get_reply(self.pending_call)) - return message - - def block(self): - dbus_pending_call_block(self.pending_call) - -cdef class Watch: - cdef DBusWatch* watch - def __init__(self, cwatch): - self.watch = <DBusWatch*>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 - - - def __init__(self, message): - self.iter = &self.real_iter - msg = message._get_msg() - dbus_message_iter_init(<DBusMessage*>msg, self.iter) - - def get_iter(self): - return <object>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 = 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_INT32: - retval = self.get_int32() - elif arg_type == TYPE_UINT32: - retval = self.get_uint32() - 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_ARRAY: - array_type = self.get_array_type() - - if array_type == TYPE_STRING: - retval = self.get_string_array() - elif array_type == TYPE_BOOLEAN: - retval = self.get_boolean_array() - else: - raise TypeError, "Unknown array type %d in MessageIter" % (array_type) - else: - raise TypeError, 'Unknown arg type %d in MessageIter' % (argtype) - - return retval - - def get_arg_type(self): - return dbus_message_iter_get_arg_type(self.iter) - - def get_array_type(self): - return dbus_message_iter_get_array_type(self.iter) - - #FIXME: implement get_byte - #def get_byte(self): - # return dbus_message_iter_get_byte(self.iter) - - def get_boolean(self): - return dbus_message_iter_get_boolean(self.iter) - - def get_int32(self): - return dbus_message_iter_get_int32(self.iter) - - def get_uint32(self): - return dbus_message_iter_get_uint32(self.iter) - - def get_double(self): - return dbus_message_iter_get_double(self.iter) - - def get_string(self): - return dbus_message_iter_get_string(self.iter) - - def get_dict_key(self): - return dbus_message_iter_get_dict_key(self.iter) - - # FIXME: implement dbus_message_iter_get_named - # dbus_message_iter_init_array_iterator - - def get_byte_array(self): - cdef int len - cdef unsigned char *retval - dbus_message_iter_get_byte_array(self.iter, &retval, <int*>&len) - list = [] - for i from 0 <= i < len: - list.append(chr(retval[i])) - return list - - # FIXME: implement dbus_message_iter_get_boolean_array - # dbus_message_iter_get_int32_array - # dbus_message_iter_get_uint32_array - # dbus_message_iter_get_double_array - - def get_string_array(self): - cdef int len - cdef char **retval - - dbus_message_iter_get_string_array(self.iter, &retval, <int*>&len) - list = [] - for i from 0 <= i < len: - list.append(retval[i]) - return list - - # dbus_message_append_iter_init included in class Message - - #FIXME: handle all the different types? - 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 == float: - retval = self.append_double(value) - elif value_type == str: - retval = self.append_string(value) - elif value_type == list: - if (len(list) == 1): - raise TypeError, "Empty list" - list_type = type(list[0]) - if list_type == str: - self.append_string_array(list) - else: - raise TypeError, "List of unknown type '%s'" % (list_type) - else: - raise TypeError, "Argument of unknown type '%s'" % (value_type) - - return retval - - def append_nil(self): - return dbus_message_iter_append_nil(self.iter) - - def append_boolean(self, value): - return dbus_message_iter_append_boolean(self.iter, value) - - def append_byte(self, value): - return dbus_message_iter_append_byte(self.iter, value) - - def append_int32(self, value): - return dbus_message_iter_append_int32(self.iter, value) - - def append_uint32(self, value): - return dbus_message_iter_append_uint32(self.iter, value) - - def append_double(self, value): - return dbus_message_iter_append_double(self.iter, value) - - def append_string(self, value): - return dbus_message_iter_append_string(self.iter, value) - - # FIXME: dbus_message_iter_append_named - - def append_dict_key(self, value): - return dbus_message_iter_append_dict_key(self.iter, value) - - # FIXME: append_array, append_dict_array, append_boolean_array, append_int32_array, append_uint32_array, append_double_array - - def append_byte_array(self, list): - cdef unsigned char * value - cdef int length - length = len(list) - value = <unsigned char*>malloc(length) - for i from 0 <= i < length: - item = list[i] - if type(item) != str or len(item) != 1: - raise TypeError - value[i] = ord(item) - return dbus_message_iter_append_byte_array(self.iter, value, length) - - def append_string_array(self, list): - cdef char **value - cdef int length - length = len(list) - value = <char**>malloc(length) - for i from 0 <= i < length: - item = list[i] - if type(item) != str: - raise TypeError - value[i] = item - return dbus_message_iter_append_string_array(self.iter, value, length) - - -(MESSAGE_TYPE_INVALID, MESSAGE_TYPE_METHOD_CALL, MESSAGE_TYPE_METHOD_RETURN, MESSAGE_TYPE_ERROR, MESSAGE_TYPE_SIGNAL) = range(5) -(TYPE_INVALID, TYPE_NIL, TYPE_BYTE, TYPE_BOOLEAN, TYPE_INT32, TYPE_UINT32, TYPE_INT64, TYPE_UINT64, TYPE_DOUBLE, TYPE_STRING, TYPE_NAMED, TYPE_ARRAY, TYPE_DICT, TYPE_OBJECT_PATH) = range(14) - -cdef class Message: - cdef DBusMessage *msg - - def __init__(self, message_type=MESSAGE_TYPE_INVALID, - service=None, path=None, interface=None, method=None, - method_call=None, - name=None, - reply_to=None, error_name=None, error_message=None, - _create=1): - cdef char *cservice - if (service == None): - cservice = NULL - else: - cservice = service - - if not _create: - return - - if message_type == MESSAGE_TYPE_METHOD_CALL: - self.msg = dbus_message_new_method_call(cservice, path, interface, method) - elif message_type == MESSAGE_TYPE_METHOD_RETURN: - cmsg = method_call._get_msg() - self.msg = dbus_message_new_method_return(<DBusMessage*>cmsg) - elif message_type == MESSAGE_TYPE_SIGNAL: - self.msg = dbus_message_new_signal(path, interface, name) - elif message_type == MESSAGE_TYPE_ERROR: - cmsg = reply_to._get_msg() - self.msg = dbus_message_new_error(<DBusMessage*>cmsg, error_name, error_message) - - 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() - value_at_iter = True - - while (value_at_iter): - type = iter.get_arg_type() - - if type == TYPE_INVALID: - break - elif type == TYPE_STRING: - str = iter.get_string() - arg = 'string:%s\n' % (str) - 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_DOUBLE: - num = iter.get_double() - arg = 'double:%f\n' % (num) - elif type == TYPE_BYTE: - num = iter.get_byte() - arg = 'byte:%d\n' % (num) - elif type == TYPE_BOOLEAN: - bool = iter.get_boolean() - if (bool): - str = "true" - else: - str = "false" - arg = 'boolean:%s\n' % (str) - else: - arg = '(unknown arg type %d)\n' % type - - retval = retval + arg - value_at_iter = iter.next() - - return retval - - def _set_msg(self, msg): - self.msg = <DBusMessage*>msg - - def _get_msg(self): - return <object>self.msg - - def get_iter(self): - return MessageIter(self) - - 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, interface=sinterface, name=sname) - -class MethodCall(Message): - def __init__(self, mpath, minterface, mmethod): - Message.__init__(self, MESSAGE_TYPE_METHOD_CALL, path=mpath, 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): - raise DBusException, error.message - - def setup_with_g_main (self): - dbus_server_setup_with_g_main(self.server, NULL) - - 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_ACTIVATION = DBUS_BUS_ACTIVATION - -def bus_get (bus_type): - cdef DBusError error - dbus_error_init(&error) - cdef DBusConnection *connection - - connection = dbus_bus_get(bus_type, - &error) - - if dbus_error_is_set(&error): - raise DBusException, error.message - - return Connection(_conn=<object>connection) - -def bus_get_base_service(connection): - conn = connection._get_conn() - return dbus_bus_get_base_service(<DBusConnection*>conn) - -def bus_register(connection): - cdef DBusError error - dbus_error_init(&error) - cdef dbus_bool_t retval - - conn = connection._get_conn() - retval = dbus_bus_register(<DBusConnection*>conn, - &error) - if dbus_error_is_set(&error): - raise DBusException, error.message - - return retval - -SERVICE_FLAG_PROHIBIT_REPLACEMENT = 0x1 -SERVICE_FLAG_REPLACE_EXISTING = 0x2 - -def bus_acquire_service(connection, service_name, flags=0): - cdef DBusError error - dbus_error_init(&error) - cdef int retval - - conn = connection._get_conn() - retval = dbus_bus_acquire_service(<DBusConnection*>conn, - service_name, - flags, - &error) - if dbus_error_is_set(&error): - raise DBusException, error.message - return retval - -def bus_service_exists(connection, service_name): - cdef DBusError error - dbus_error_init(&error) - cdef dbus_bool_t retval - - conn = connection._get_conn() - retval = dbus_bus_service_exists(<DBusConnection*>conn, - service_name, - &error) - if dbus_error_is_set(&error): - raise DBusException, error.message - return retval - -def bus_add_match(connection, rule): - cdef DBusError error - dbus_error_init(&error) - - conn = connection._get_conn() - dbus_bus_add_match (<DBusConnection*>conn, rule, &error) - - if dbus_error_is_set(&error): - raise DBusException, error.message - -def bus_remove_match(connection, rule): - cdef DBusError error - dbus_error_init(&error) - - conn = connection._get_conn() - dbus_bus_remove_match (<DBusConnection*>conn, rule, &error) - - if dbus_error_is_set(&error): - raise DBusException, error.message 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/examples/example-client.py b/python/examples/example-client.py deleted file mode 100644 index 0038b2db..00000000 --- a/python/examples/example-client.py +++ /dev/null @@ -1,12 +0,0 @@ -#!/usr/bin/env python - -import dbus - -bus = dbus.Bus() -remote_service = bus.get_service("org.designfu.SampleService") -remote_object = remote_service.get_object("/SomeObject", - "org.designfu.SampleInterface") - -hello_reply = remote_object.HelloWorld("Hello from example-client.py!") - -print (hello_reply) diff --git a/python/examples/example-service.py b/python/examples/example-service.py deleted file mode 100644 index 79fb009d..00000000 --- a/python/examples/example-service.py +++ /dev/null @@ -1,18 +0,0 @@ -import dbus - -import pygtk -import gtk - -class SomeObject(dbus.Object): - def __init__(self, service): - dbus.Object.__init__(self, "/SomeObject", [self.HelloWorld], service) - - def HelloWorld(self, hello_message): - print (hello_message) - return "Hello from example-service.py" - - -service = dbus.Service("org.designfu.SampleService") -object = SomeObject(service) - -gtk.main() diff --git a/python/examples/example-signals.py b/python/examples/example-signals.py deleted file mode 100644 index 8e319569..00000000 --- a/python/examples/example-signals.py +++ /dev/null @@ -1,27 +0,0 @@ -import pygtk -import gtk - -import dbus - -class SignalFrom(dbus.Object): - def __init__(self, service): - dbus.Object.__init__(self, "/", [], service) - -def signal_to(interface, signal_name, service, path): - print ("Received signal '%s.%s' from '%s%s'" % (interface, signal_name, service, path)) - -bus = dbus.Bus() -bus.add_signal_receiver(signal_to, - "org.designfu.SignalInterface", - "org.designfu.SignalService", - "/") - - -service = dbus.Service("org.designfu.SignalService", bus) -signal_from = SignalFrom(service) - -signal_from.broadcast_signal("org.designfu.SignalInterface", "HelloWorld") - -gtk.main() - - diff --git a/python/extract.py b/python/extract.py deleted file mode 100644 index 460af5ab..00000000 --- a/python/extract.py +++ /dev/null @@ -1,237 +0,0 @@ -import commands -import glob -import re -import os -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*) # 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] |