def __signature__(self):
try:
return self._value.__signature__
except AttributeError:
pass
try:
return Signature.from_function(self._value)
except TypeError:
pass
try:
return Signature.from_buultin(self._value)
except TypeError:
pass
return None
def __signature__(self):
return Signature.from_function(self._compiled_fn)
def translate(cls, func):
"""
Decorator for Wrapper methods.
The decorated method does not need to manually lookup objects when the
caller (across DBus) passes an object path. Type information is
provided using parameter annotations.
The annotation accepts DBus type expressions (but in practice it is
very limited). For the moment it cannot infer the argument types from
the decorator for dbus.service.method.
"""
sig = Signature.from_function(func)
def translate_o(object_path):
try:
obj = cls.find_object_by_path(object_path)
except KeyError as exc:
raise dbus.exceptions.DBusException((
"object path {} does not designate an existing"
" object").format(exc))
else:
return obj.native
def translate_ao(object_path_list):
try:
obj_list = [cls.find_object_by_path(object_path)
for object_path in object_path_list]
except KeyError as exc:
raise dbus.exceptions.DBusException((
"object path {} does not designate an existing"
" object").format(exc))
else:
return [obj.native for obj in obj_list]
def translate_return_o(obj):
try:
return cls.find_wrapper_by_native(obj)
except KeyError:
raise dbus.exceptions.DBusException(
"(o) internal error, unable to lookup object wrapper")
def translate_return_ao(object_list):
try:
return dbus.types.Array([
cls.find_wrapper_by_native(obj)
for obj in object_list
], signature='o')
except KeyError:
raise dbus.exceptions.DBusException(
"(ao) internal error, unable to lookup object wrapper")
def translate_return_a_brace_so_brace(mapping):
try:
return dbus.types.Dictionary({
key: cls.find_wrapper_by_native(value)
for key, value in mapping.items()
}, signature='so')
except KeyError:
raise dbus.exceptions.DBusException(
"(a{so}) internal error, unable to lookup object wrapper")
@functools.wraps(func)
def wrapper(*args, **kwargs):
bound = sig.bind(*args, **kwargs)
cls._logger.debug(
"wrapped %s called with %s", func, bound.arguments)
for param in sig.parameters.values():
if param.annotation is Signature.empty:
pass
elif param.annotation == 'o':
object_path = bound.arguments[param.name]
bound.arguments[param.name] = translate_o(object_path)
elif param.annotation == 'ao':
object_path_list = bound.arguments[param.name]
bound.arguments[param.name] = translate_ao(
object_path_list)
elif param.annotation in ('s', 'as'):
strings = bound.arguments[param.name]
bound.arguments[param.name] = strings
else:
raise ValueError(
"unsupported translation {!r}".format(
param.annotation))
cls._logger.debug(
"unwrapped %s called with %s", func, bound.arguments)
retval = func(**bound.arguments)
cls._logger.debug("unwrapped %s returned %r", func, retval)
if sig.return_annotation is Signature.empty:
pass
elif sig.return_annotation == 'o':
retval = translate_return_o(retval)
elif sig.return_annotation == 'ao':
retval = translate_return_ao(retval)
elif sig.return_annotation == 'a{so}':
retval = translate_return_a_brace_so_brace(retval)
else:
raise ValueError(
"unsupported translation {!r}".format(
sig.return_annotation))
cls._logger.debug("wrapped %s returned %r", func, retval)
return retval
return wrapper