+2005-11-04 Robert McQueen <robot101@debian.org>
+
+ * python/dbus_bindings.pyx, test/python/test-client.py: Fix
+ marshalling of boolean values. Add some booleans to the values in
+ the test client.
+
+ * python/decorators.py, python/service.py: Add an 'async_callbacks'
+ argument to the dbus.service.method decorator, which allows you to
+ name arguments to take two callback functions for replying with
+ return values or an exception.
+
+ * test/python/test-client.py, test/python/test-service.py: Add test
+ case using asynchronous method reply functions, both return values and
+ errors, and from within both the function itself and from a mainloop
+ callback.
+
+ * python/decorators.py, python/service.py: Perform checking that the
+ number of method/signal arguments matches the number of types in the
+ signature at class loading time, not when you first introspect the
+ class.
+
+ * python/service.py: Remove debug print left by the last commit.
+
2005-11-03 Robert McQueen <robot101@debian.org>
* python/service.py: Heavy refactoring of method invocation, with
ptype = type(value)
ret = ""
if ptype == bool:
- ret = TYPE_BOOL
+ ret = TYPE_BOOLEAN
ret = str(chr(ret))
elif ptype == int:
ret = TYPE_INT32
ret = TYPE_BYTE
ret = str(chr(ret))
elif isinstance(value, Boolean) or value == Boolean:
- ret = TYPE_BOOL
+ ret = TYPE_BOOLEAN
ret = str(chr(ret))
elif isinstance(value, Int16) or value == Int16:
ret = TYPE_INT16
import inspect
import dbus_bindings
-def method(dbus_interface, in_signature=None, out_signature=None):
+def method(dbus_interface, in_signature=None, out_signature=None, async_callbacks=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 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_args = inspect.getargspec(func)[0]
- func._dbus_args.pop(0)
+ func._dbus_args = args
return func
return decorator
self._connection.send(message)
+ args = inspect.getargspec(func)[0]
+ args.pop(0)
+
+ if signature:
+ sig = tuple(dbus_bindings.Signature(func._dbus_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 = inspect.getargspec(func)[0]
- emit_signal._dbus_args.pop(0)
+ emit_signal._dbus_args = args
return emit_signal
return decorator
if func._dbus_in_signature:
# convert signature into a tuple so length refers to number of
- # types, not number of characters
+ # 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))
-
- 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'
else:
# magic iterator which returns as many v's as we need
in_sig = dbus_bindings.VariantSignature()
# convert signature into a tuple so length refers to number of
# types, not number of characters
sig = tuple(dbus_bindings.Signature(func._dbus_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'
else:
# magic iterator which returns as many v's as we need
sig = dbus_bindings.VariantSignature()
interface_name = message.get_interface()
(candidate_method, parent_method) = _method_lookup(self, method_name, interface_name)
- # call method
+ # set up method call parameters
args = message.get_args_list()
- retval = candidate_method(self, *args)
+ keywords = {}
- # send return reply if it's not an asynchronous function
- # if we have a signature, use it to turn the return value into a tuple as appropriate
+ # iterate signature into list of complete types
if parent_method._dbus_out_signature:
- # iterate signature into list of complete types
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)
+
+ # 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
else:
retval = (retval,)
- print retval, signature
_method_reply_return(connection, message, method_name, signature, *retval)
except Exception, exception:
# send error reply
(1,2,3), (1,), (1,"2",3), ("2", "what"), ("you", 1.2),
{1:"a", 2:"b"}, {"a":1, "b":2}, #{"a":(1,"B")},
{1:1.1, 2:2.2}, [[1,2,3],[2,3,4]], [["a","b"],["c","d"]],
+ True, False,
#([1,2,3],"c", 1.2, ["a","b","c"], {"a": (1,"v"), "b": (2,"d")})
]
print "CheckInheritance returned %s" % ret
self.assert_(ret, "overriding CheckInheritance from TestInterface failed")
+ def testAsyncMethods(self):
+ print "\n********* Testing asynchronous method implementation *******"
+ for (async, fail) in ((False, False), (False, True), (True, False), (True, True)):
+ try:
+ val = ('a', 1, False, [1,2], {1:2})
+ print "calling AsynchronousMethod with %s %s %s" % (async, fail, val)
+ ret = self.iface.AsynchronousMethod(async, fail, val)
+ except Exception, e:
+ print "%s:\n%s" % (e.__class__, e)
+ self.assert_(fail)
+ else:
+ self.assert_(not fail)
+ print val, ret
+ self.assert_(val == ret)
+
class TestDBusPythonToGLibBindings(unittest.TestCase):
def setUp(self):
self.bus = dbus.SessionBus()
def CheckInheritance(self):
return True
+ @dbus.service.method('org.freedesktop.DBus.TestSuiteInterface', in_signature='bbv', out_signature='v', async_callbacks=('return_cb', 'error_cb'))
+ def AsynchronousMethod(self, async, fail, variant, return_cb, error_cb):
+ try:
+ if async:
+ gobject.timeout_add(500, self.AsynchronousMethod, False, fail, variant, return_cb, error_cb)
+ return
+ else:
+ if fail:
+ raise RuntimeError
+ else:
+ return_cb(variant)
+
+ return False # do not run again
+ except Exception, e:
+ error_cb(e)
+
session_bus = dbus.SessionBus()
name = dbus.service.BusName("org.freedesktop.DBus.TestSuitePythonService", bus=session_bus)
object = TestObject(name)
projects / thirdparty / dbus.git / commitdiff
