Support callable objects and functools.partial

In Python versions before 3.4, inspect.getargspec() doesn't support
objects that define a __call__() method, or functools.partial objects.
Add special handling to allow these to be used as callback functions.

Author: dsacre

src/liblo.pyx

@@ -23,6 +23,7 @@ from libc.stdint cimport int32_t, int64_t
 from liblo cimport *
 
 import inspect as _inspect
+import functools as _functools
 import weakref as _weakref
 
 
@@ -257,15 +258,29 @@ cdef int _msg_callback(const_char *path, const_char *types, lo_arg **argv,
                  src,
                  cb.user_data)
 
-    # call function
-    if _inspect.getargspec(func)[1] == None:
-        # determine number of arguments to call the function with
-        n = len(_inspect.getargspec(func)[0])
+    # determine the number of arguments to call the function with
+    if isinstance(func, _functools.partial):
+        # before Python 3.4, getargspec() did't work for functools.partial,
+        # so it needs to be handled separately
+        argspec = _inspect.getargspec(func.func)
+        nargs = len(argspec[0]) - len(func.args)
+        if func.keywords is not None:
+            nargs -= len(func.keywords)
+    else:
+        if (hasattr(func, '__call__') and
+                not (_inspect.ismethod(func) or _inspect.isfunction(func))):
+            func = func.__call__
+
+        argspec = _inspect.getargspec(func)
+        nargs = len(argspec[0])
+
         if _inspect.ismethod(func):
-            n -= 1  # self doesn't count
-        r = cb.func(*func_args[0:n])
+            nargs -= 1  # self doesn't count
+
+    if argspec[1] == None:
+        r = cb.func(*func_args[0:nargs])
     else:
-        # function has argument list, pass all arguments
+        # function has variable argument list, pass all arguments
         r = cb.func(*func_args)
 
     return r if r != None else 0

test/test_liblo.py

@@ -15,6 +15,7 @@
 import re
 import time
 import sys
+import functools
 import liblo
 
 
@@ -191,6 +192,37 @@ def foo(path, args, *varargs):
         self.assertIsInstance(self.cb_varargs[1], liblo.Address)
         self.assertEqual(self.cb_varargs[2], 'spam')
 
+    def testCallbackCallable(self):
+        class Foo:
+            def __init__(self):
+                self.a = None
+            def __call__(self, path, args):
+                self.a = args[0]
+        foo = Foo()
+        self.server.add_method('/foo', 'i', foo)
+        self.server.send(1234, '/foo', 23)
+        self.assertTrue(self.server.recv())
+        self.assertEqual(foo.a, 23)
+
+    def testCallbackPartial(self):
+        def foo(partarg, path, args, types, src, data):
+            self.cb = Arguments(path, args, types, src, data)
+            self.cb_partarg = partarg
+        self.server.add_method('/foo', 'i', functools.partial(foo, 'blubb'))
+        self.server.send(1234, '/foo', 23)
+        self.assertTrue(self.server.recv())
+        self.assertEqual(self.cb_partarg, 'blubb')
+        self.assertEqual(self.cb.path, '/foo')
+        self.assertEqual(self.cb.args[0], 23)
+
+        self.server.add_method('/foo2', 'i', functools.partial(foo, 'bla', data='blubb'))
+        self.server.send(1234, '/foo2', 42)
+        self.assertTrue(self.server.recv())
+        self.assertEqual(self.cb_partarg, 'bla')
+        self.assertEqual(self.cb.path, '/foo2')
+        self.assertEqual(self.cb.args[0], 42)
+        self.assertEqual(self.cb.data, 'blubb')
+
     def testBundleCallbacksFire(self):
         def bundle_start_cb(timestamp, user_data):
             self.assertIsInstance(timestamp, float)