Hi,

I am still in a process of integrating this library into one of my new projects and I have reached a few limitations of the API. There might be a common solution to all of them, so I will not spread them in multiple discussions :)

Knowing about errors

The first – and the smallest one – is not knowing when some error happens in a method/property handler. It is minor, but if I implement some Dbus service, a common need is to print errors that happen within that service to stderr, for example. But it seems to me that is not possible with the current implementation. As there is no way to "intercept the error and do something about it".

My current solution is super simple – I just added logging to the library (dragomirecky@93929ae) as that solves the primary issue for me. But that is not a general solution I believe.

Translating Python Errors

I need to translate Python exceptions to Dbus errors and on the other side back to Python exceptions.
So for example, with code like this

class MyInterface(DbusInterfaceCommonAsync, interface_name=...):
    @dbus_method_async(input_signature="s", result_signature="s")
    async def some_method(self, arg: str) -> str:
        raise MyDomainError(message="something went wrong", code=4, reason="it broke")

I would like to be able to choose how the exception is going to be translated to DBus error message.

• There already exist some API for specifying how exceptions should be translated, but unfortunately it provides a little control over it.
• My goal would be to allow it to translate to a Dbus error utilizing the DBus error message, for example like this:
  • error name: my.domain.Error
  • error message: { "message": "something went wrong", "code": 4, "reason": "it broke" }

Second feature regarding this is that when the error gets serialized like above, I would like to be able to make the interface such that it automatically translates the error back to the native MyDomainError.

So that when user calls

my_interface = MyInterface.new_proxy(...)
await my_interface.some_method() # would throw MyDomainError(message=...) 

Translating Python Values

Last thing – relevant to the other two – is missing a possibility to map object to DBus values and back. I believe this is a common need for properties. To solve this temporarily I have created a custom decorator for this:

class SomeEnum(IntEnum):
    VALUE_A = 3
    VALUE_B = 4

class MyInterface(DbusInterfaceCommonAsync, interface_name=...):
    @dbus_property_mapped_async(property_signature="i", from_dbus=SomeEnum, to_dbus=lambda x.value)
    def my_property(self):
        return SomeEnum.VALUE_B


# allows
my_interface = MyInterface.new_proxy(...)
await my_interface.my_property.get() # returns `SomeEnum`; not `int` which the user would have to always map
await my_interface.my_property.set(SomeEnum.VALUE_A) # takes `SomeEnum`

I believe all those three issues can be solved with a single feature – something like the middleware pattern which is common in http servers. Ideally composable using decorators.

class MyInterface(DbusInterfaceCommonAsync, interface_name=...):
    
    @my_domain_handle_errors()
    @my_domain_log_errors()
    @dbus_mapped(from_dbus=..., to_dbus=...)
    @dbus_property_async(property_signature="i")
    def my_property(self):
        return SomeEnum.VALUE_B

I am aware it is not trivial to do this nicely composable in a fully type-safe manner. But I think if made right, it would allow whole set of new uses while keeping the library nicely clean and simple.

What are your thoughts? I would be happy to invest some time into this if we find a way forward on this