New export_to_dbus algorithm using metadata

igo95862 · igo95862 · commit b44d56519f96 · 2025-03-30T15:51:24.000+01:00
Instead of iterating over all members to find D-Bus elements
use the `_dbus_iter_interfaces_meta` to iterate over the metadata
and then `getattr` the exact Python attributes containing the
D-Bus elements.

This makes the algorithm faster as it won't have to go through
all members as well as allows for D-Bus interfaces without any
members to be exported.

Raise an error if no interfaces got exported to prevent unexpected
errors except for ObjectManager where libsystemd allow exporting
without any extra interfaces.
diff --git a/src/sdbus/dbus_proxy_async_interface_base.py b/src/sdbus/dbus_proxy_async_interface_base.py
@@ -21,7 +21,6 @@
 
 from collections.abc import Callable
 from copy import copy
-from inspect import getmembers
 from itertools import chain
 from types import MethodType
 from typing import TYPE_CHECKING, Any, cast
@@ -52,7 +51,6 @@
     from collections.abc import Iterable, Iterator
     from typing import Optional, TypeVar, Union
 
-    from .dbus_common_elements import DbusBoundAsync
     from .sd_bus_internals import SdBus, SdBusSlot
 
     T = TypeVar('T')
@@ -312,12 +310,14 @@ async def start_serving(self,
              DeprecationWarning)
         self.export_to_dbus(object_path, bus)
 
+    def _dbus_on_no_members_exported(self) -> None:
+        raise ValueError("No D-Bus interfaces were exported")
+
     def export_to_dbus(
         self,
         object_path: str,
         bus: Optional[SdBus] = None,
     ) -> DbusExportHandle:
-
         local_object_meta = self._dbus
         if isinstance(local_object_meta, DbusRemoteObjectMeta):
             raise RuntimeError("Cannot export D-Bus proxies.")
@@ -334,38 +334,17 @@ def export_to_dbus(
 
         local_object_meta.attached_bus = bus
         local_object_meta.serving_object_path = object_path
-        # TODO: can be optimized with a single loop
-        interface_map: dict[str, list[DbusBoundAsync]] = {}
-
-        for key, value in getmembers(self):
-            assert not isinstance(value, DbusMemberAsync)
-
-            if isinstance(value, DbusLocalMethodAsync):
-                interface_name = value.dbus_method.interface_name
-                if not value.dbus_method.serving_enabled:
-                    continue
-            elif isinstance(value, DbusLocalPropertyAsync):
-                interface_name = value.dbus_property.interface_name
-                if not value.dbus_property.serving_enabled:
-                    continue
-            elif isinstance(value, DbusLocalSignalAsync):
-                interface_name = value.dbus_signal.interface_name
-                if not value.dbus_signal.serving_enabled:
-                    continue
-            else:
-                continue
-
-            try:
-                interface_member_list = interface_map[interface_name]
-            except KeyError:
-                interface_member_list = []
-                interface_map[interface_name] = interface_member_list
 
-            interface_member_list.append(value)
+        for interface_name, meta in self._dbus_iter_interfaces_meta():
+            if not meta.serving_enabled:
+                continue
 
-        for interface_name, member_list in interface_map.items():
             new_interface = SdBusInterface()
-            for dbus_something in member_list:
+
+            for python_attr, dbus_member in (
+                meta.python_attr_to_dbus_member.items()
+            ):
+                dbus_something = getattr(self, python_attr)
                 if isinstance(dbus_something, DbusLocalMethodAsync):
                     new_interface.add_method(
                         dbus_something.dbus_method.method_name,
@@ -404,12 +383,16 @@ def export_to_dbus(
                         dbus_something.dbus_signal.flags,
                     )
                 else:
-                    raise TypeError
+                    raise TypeError(
+                        "Expected D-Bus element, got: {dbus_something!r}"
+                    )
 
-            bus.add_interface(new_interface, object_path,
-                              interface_name)
+            bus.add_interface(new_interface, object_path, interface_name)
             local_object_meta.activated_interfaces.append(new_interface)
 
+        if not local_object_meta.activated_interfaces:
+            self._dbus_on_no_members_exported()
+
         return DbusExportHandle(local_object_meta)
 
     def _connect(
diff --git a/src/sdbus/dbus_proxy_async_object_manager.py b/src/sdbus/dbus_proxy_async_object_manager.py
@@ -76,6 +76,9 @@ def interfaces_added(self) -> tuple[str, dict[str, dict[str, Any]]]:
     def interfaces_removed(self) -> tuple[str, list[str]]:
         raise NotImplementedError
 
+    def _dbus_on_no_members_exported(self) -> None:
+        ...  # Object manager is allowed to be exported empty
+
     def export_to_dbus(
         self,
         object_path: str,
diff --git a/test/test_sdbus_async.py b/test/test_sdbus_async.py
@@ -1017,3 +1017,17 @@ async def test_python_exc(self) -> None:
 
         with self.assertRaisesRegex(ValueError, "Test!"):
             await test_object_connection.raise_python_exc()
+
+    async def test_empty_dbus_interface(self) -> None:
+        class Empty(
+            DbusInterfaceCommonAsync,
+            interface_name="org.empty",
+        ):
+            ...
+
+        empty_local = Empty()
+        empty_local.export_to_dbus("/")
+        empty_proxy = Empty.new_proxy(TEST_SERVICE_NAME, "/")
+
+        intro = await empty_proxy.dbus_introspect()
+        self.assertIn('<interface name="org.empty">', intro)
diff --git a/test/test_sdbus_utils.py b/test/test_sdbus_utils.py
@@ -212,7 +212,7 @@ def test_inspect_dbus_path_async_proxy(self) -> None:
             inspect_dbus_path(proxy, new_bus)
 
     def test_inspect_dbus_path_async_local(self) -> None:
-        local_obj = DbusInterfaceCommonAsync()
+        local_obj = FooBarAsync()
 
         with self.assertRaisesRegex(
             LookupError, "is not exported to any D-Bus",
