dbus2mqtt 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

dbus2mqtt/config/__init__.py

@@ -1,5 +1,6 @@
 import fnmatch
 import uuid
+import warnings
 
 from dataclasses import dataclass, field
 from typing import Annotated, Any, Literal
@@ -65,15 +66,29 @@ class FlowTriggerDbusSignalConfig:
 @dataclass
 class FlowTriggerBusNameAddedConfig:
     type: Literal["bus_name_added"] = "bus_name_added"
-    # filter: str | None = None
+
+    def __post_init__(self):
+        warnings.warn(f"{self.type} flow trigger may be removed in a future version.", DeprecationWarning, stacklevel=2)
 
 @dataclass
 class FlowTriggerBusNameRemovedConfig:
     type: Literal["bus_name_removed"] = "bus_name_removed"
+
+    def __post_init__(self):
+        warnings.warn(f"{self.type} flow trigger may be removed in a future version.", DeprecationWarning, stacklevel=2)
+
+@dataclass
+class FlowTriggerObjectAddedConfig:
+    type: Literal["object_added"] = "object_added"
+    # filter: str | None = None
+
+@dataclass
+class FlowTriggerObjectRemovedConfig:
+    type: Literal["object_removed"] = "object_removed"
     # filter: str | None = None
 
 FlowTriggerConfig = Annotated[
-    FlowTriggerMqttConfig | FlowTriggerScheduleConfig | FlowTriggerDbusSignalConfig | FlowTriggerBusNameAddedConfig | FlowTriggerBusNameRemovedConfig,
+    FlowTriggerMqttConfig | FlowTriggerScheduleConfig | FlowTriggerDbusSignalConfig | FlowTriggerBusNameAddedConfig | FlowTriggerBusNameRemovedConfig | FlowTriggerObjectAddedConfig | FlowTriggerObjectRemovedConfig,
     Field(discriminator="type")
 ]
 
@@ -117,6 +132,7 @@ class SubscriptionConfig:
 @dataclass
 class DbusConfig:
     subscriptions: list[SubscriptionConfig]
+    bus_type: Literal["SESSION", "SYSTEM"] = "SESSION"
 
     def is_bus_name_configured(self, bus_name: str) -> bool:
 
@@ -125,11 +141,14 @@ class DbusConfig:
                 return True
         return False
 
-    def get_subscription_configs(self, bus_name: str, path: str) -> list[SubscriptionConfig]:
+    def get_subscription_configs(self, bus_name: str, path: str|None = None) -> list[SubscriptionConfig]:
         res: list[SubscriptionConfig] = []
         for subscription in self.subscriptions:
-            if fnmatch.fnmatchcase(bus_name, subscription.bus_name) and path == subscription.path:
-                res.append(subscription)
+            if fnmatch.fnmatchcase(bus_name, subscription.bus_name):
+                if not path or path == subscription.path:
+                    res.append(subscription)
+                elif fnmatch.fnmatchcase(path, subscription.path):
+                    res.append(subscription)
         return res
 
 @dataclass

dbus2mqtt/dbus/dbus_client.py

@@ -1,3 +1,4 @@
+import fnmatch
 import json
 import logging
 
@@ -5,11 +6,19 @@ from datetime import datetime
 from typing import Any
 
 import dbus_fast.aio as dbus_aio
+import dbus_fast.constants as dbus_constants
+import dbus_fast.errors as dbus_errors
 import dbus_fast.introspection as dbus_introspection
+import dbus_fast.message as dbus_message
+import janus
 
 from dbus2mqtt import AppContext
-from dbus2mqtt.config import InterfaceConfig, SubscriptionConfig
-from dbus2mqtt.dbus.dbus_types import BusNameSubscriptions, SubscribedInterface
+from dbus2mqtt.config import SubscriptionConfig
+from dbus2mqtt.dbus.dbus_types import (
+    BusNameSubscriptions,
+    DbusSignalWithState,
+    SubscribedInterface,
+)
 from dbus2mqtt.dbus.dbus_util import (
     camel_to_snake,
     unwrap_dbus_object,
@@ -19,11 +28,13 @@ from dbus2mqtt.dbus.introspection_patches.mpris_playerctl import (
     mpris_introspection_playerctl,
 )
 from dbus2mqtt.dbus.introspection_patches.mpris_vlc import mpris_introspection_vlc
-from dbus2mqtt.event_broker import DbusSignalWithState, MqttMessage
+from dbus2mqtt.event_broker import MqttMessage
 from dbus2mqtt.flow.flow_processor import FlowScheduler, FlowTriggerMessage
 
 logger = logging.getLogger(__name__)
 
+# TODO: Redo flow registration in _handle_bus_name_added, might want to move that to a separate file
+# TODO: deregister signal watcher on shutdown
 
 class DbusClient:
 
@@ -36,6 +47,13 @@ class DbusClient:
         self.flow_scheduler = flow_scheduler
         self.subscriptions: dict[str, BusNameSubscriptions] = {}
 
+        self._dbus_signal_queue = janus.Queue[DbusSignalWithState]()
+        self._dbus_object_lifecycle_signal_queue = janus.Queue[dbus_message.Message]()
+
+        self._name_owner_match_rule = "sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',path='/org/freedesktop/DBus',member='NameOwnerChanged'"
+        self._interfaces_added_match_rule = "interface='org.freedesktop.DBus.ObjectManager',type='signal',member='InterfacesAdded'"
+        self._interfaces_removed_match_rule = "interface='org.freedesktop.DBus.ObjectManager',type='signal',member='InterfacesRemoved'"
+
     async def connect(self):
 
         if not self.bus.connected:
@@ -46,37 +64,124 @@ class DbusClient:
             else:
                 logger.warning(f"Failed to connect to {self.bus._bus_address}")
 
+            self.bus.add_message_handler(self.object_lifecycle_signal_handler)
+
+            # Add dbus match rules to get notified of new bus_names or interfaces
+            await self._add_match_rule(self._name_owner_match_rule)
+            await self._add_match_rule(self._interfaces_added_match_rule)
+            await self._add_match_rule(self._interfaces_removed_match_rule)
+
             introspection = await self.bus.introspect('org.freedesktop.DBus', '/org/freedesktop/DBus')
             obj = self.bus.get_proxy_object('org.freedesktop.DBus', '/org/freedesktop/DBus', introspection)
             dbus_interface = obj.get_interface('org.freedesktop.DBus')
 
-            # subscribe to NameOwnerChanged which allows us to detect new bus_names
-            dbus_interface.__getattribute__("on_name_owner_changed")(self._dbus_name_owner_changed_callback)
-
             # subscribe to existing registered bus_names we are interested in
             connected_bus_names = await dbus_interface.__getattribute__("call_list_names")()
 
-            new_subscriped_interfaces: list[SubscribedInterface] = []
+            new_subscribed_interfaces: list[SubscribedInterface] = []
             for bus_name in connected_bus_names:
-                new_subscriped_interfaces.extend(await self._handle_bus_name_added(bus_name))
+                new_subscribed_interfaces.extend(await self._handle_bus_name_added(bus_name))
+
+            logger.info(f"subscriptions on startup: {list(set([si.bus_name for si in new_subscribed_interfaces]))}")
+
+    async def _add_match_rule(self, match_rule: str):
+        reply = await self.bus.call(dbus_message.Message(
+            destination='org.freedesktop.DBus',
+            path='/org/freedesktop/DBus',
+            interface='org.freedesktop.DBus',
+            member='AddMatch',
+            signature='s',
+            body=[(match_rule)]
+        ))
+        assert reply and reply.message_type == dbus_constants.MessageType.METHOD_RETURN
+
+    async def _remove_match_rule(self, match_rule: str):
+        reply = await self.bus.call(dbus_message.Message(
+            destination='org.freedesktop.DBus',
+            path='/org/freedesktop/DBus',
+            interface='org.freedesktop.DBus',
+            member='RemoveMatch',
+            signature='s',
+            body=[(match_rule)]
+        ))
+        assert reply and reply.message_type == dbus_constants.MessageType.METHOD_RETURN
+
+    def get_well_known_bus_name(self, unique_bus_name: str) -> str:
+
+        for bns in self.subscriptions.values():
+            if unique_bus_name == bns.unique_name:
+                return bns.bus_name
+
+        # # dbus_fast keeps track of well known bus_names for the high-level API.
+        # # We can use this to find the bus_name for the sender.
+        # for k, v in self.bus._name_owners.items():
+        #     if v == unique_bus_name:
+        #         return v
+
+        return unique_bus_name
+
+    async def get_unique_name(self, name) -> str | None:
+
+        if name.startswith(":"):
+            return name
+
+        introspect = await self.bus.introspect("org.freedesktop.DBus", "/org/freedesktop/DBus")
+        proxy = self.bus.get_proxy_object("org.freedesktop.DBus", "/org/freedesktop/DBus", introspect)
+        dbus_interface = proxy.get_interface("org.freedesktop.DBus")
+
+        return await dbus_interface.call_get_name_owner(name) # type: ignore
+
+    def object_lifecycle_signal_handler(self, message: dbus_message.Message) -> None:
+
+        if not message.message_type == dbus_constants.MessageType.SIGNAL:
+            return
 
-            logger.info(f"subscriptions on startup: {list(set([si.bus_name for si in new_subscriped_interfaces]))}")
+        logger.debug(f'object_lifecycle_signal_handler: interface={message.interface}, member={message.member}, body={message.body}')
 
-    def get_proxy_object(self, bus_name: str, path: str) -> dbus_aio.proxy_object.ProxyObject | None:
+        if message.interface in ['org.freedesktop.DBus', 'org.freedesktop.DBus.ObjectManager']:
+            self._dbus_object_lifecycle_signal_queue.sync_q.put(message)
 
-        bus_name_subscriptions = self.subscriptions.get(bus_name)
+    def get_bus_name_subscriptions(self, bus_name: str) -> BusNameSubscriptions | None:
+
+        return self.subscriptions.get(bus_name)
+
+    def get_subscribed_proxy_object(self, bus_name: str, path: str) -> dbus_aio.proxy_object.ProxyObject | None:
+
+        bus_name_subscriptions = self.get_bus_name_subscriptions(bus_name)
         if bus_name_subscriptions:
             proxy_object = bus_name_subscriptions.path_objects.get(path)
             if proxy_object:
                 return proxy_object
 
+    async def get_subscribed_or_new_proxy_object(self, bus_name: str, path: str) -> dbus_aio.proxy_object.ProxyObject | None:
+
+        proxy_object = self.get_subscribed_proxy_object(bus_name, path)
+        if proxy_object:
+            return proxy_object
+
+        # No existing subscription that contains the requested proxy_object
+        logger.warning(f"Returning temporary proxy_object with an additional introspection call, bus_name={bus_name}, path={path}")
+        introspection = await self.bus.introspect(bus_name=bus_name, path=path)
+        proxy_object = self.bus.get_proxy_object(bus_name, path, introspection)
+        if proxy_object:
+            return proxy_object
+
         return None
 
-    def _ensure_proxy_object_subscription(self, bus_name: str, path: str, introspection: dbus_introspection.Node):
+    async def _create_proxy_object_subscription(self, bus_name: str, path: str, introspection: dbus_introspection.Node):
 
-        bus_name_subscriptions = self.subscriptions.get(bus_name)
+        bus_name_subscriptions = self.get_bus_name_subscriptions(bus_name)
         if not bus_name_subscriptions:
-            bus_name_subscriptions = BusNameSubscriptions(bus_name)
+
+            if bus_name.startswith(":"):
+                unique_name = bus_name
+            else:
+                # make sure we have both the well known and unique bus_name
+                unique_name = await self.get_unique_name(bus_name)
+
+            assert unique_name is not None
+
+            bus_name_subscriptions = BusNameSubscriptions(bus_name, unique_name)
             self.subscriptions[bus_name] = bus_name_subscriptions
 
         proxy_object = bus_name_subscriptions.path_objects.get(path)
@@ -87,10 +192,25 @@ class DbusClient:
         return proxy_object, bus_name_subscriptions
 
     def _dbus_fast_signal_publisher(self, dbus_signal_state: dict[str, Any], *args):
+        """publish a dbus signal to the event broker, one for each subscription_config"""
+
         unwrapped_args = unwrap_dbus_objects(args)
-        self.event_broker.on_dbus_signal(
-            DbusSignalWithState(**dbus_signal_state, args=unwrapped_args)
-        )
+
+        signal_subscriptions = dbus_signal_state["signal_subscriptions"]
+        for signal_subscription in signal_subscriptions:
+            subscription_config = signal_subscription["subscription_config"]
+            signal_config = signal_subscription["signal_config"]
+
+            self._dbus_signal_queue.sync_q.put(
+                DbusSignalWithState(
+                    bus_name=dbus_signal_state["bus_name"],
+                    path=dbus_signal_state["path"],
+                    interface_name=dbus_signal_state["interface_name"],
+                    subscription_config=subscription_config,
+                    signal_config=signal_config,
+                    args=unwrapped_args
+                )
+            )
 
     def _dbus_fast_signal_handler(self, signal: dbus_introspection.Signal, state: dict[str, Any]) -> Any:
         expected_args = len(signal.args)
@@ -105,58 +225,81 @@ class DbusClient:
             return lambda a, b, c, d: self._dbus_fast_signal_publisher(state, a, b, c, d)
         raise ValueError("Unsupported nr of arguments")
 
-    async def _subscribe_interface(self, bus_name: str, path: str, introspection: dbus_introspection.Node, interface: dbus_introspection.Interface, subscription_config: SubscriptionConfig, si: InterfaceConfig) -> SubscribedInterface:
+    async def _subscribe_interface_signals(self, bus_name: str, path: str, interface: dbus_introspection.Interface, configured_signals: dict[str, list[dict]]) -> int:
+
+        proxy_object = self.get_subscribed_proxy_object(bus_name, path)
+        assert proxy_object is not None
 
-        proxy_object, bus_name_subscriptions = self._ensure_proxy_object_subscription(bus_name, path, introspection)
         obj_interface = proxy_object.get_interface(interface.name)
 
         interface_signals = dict((s.name, s) for s in interface.signals)
 
         logger.debug(f"subscribe: bus_name={bus_name}, path={path}, interface={interface.name}, proxy_interface: signals={list(interface_signals.keys())}")
+        signal_subscription_count = 0
 
-        for signal_config in si.signals:
-            interface_signal = interface_signals.get(signal_config.signal)
+        for signal, signal_subscriptions in configured_signals.items():
+            interface_signal = interface_signals.get(signal)
             if interface_signal:
 
-                on_signal_method_name = "on_" + camel_to_snake(signal_config.signal)
+                on_signal_method_name = "on_" + camel_to_snake(signal)
                 dbus_signal_state = {
                     "bus_name": bus_name,
                     "path": path,
                     "interface_name": interface.name,
-                    "subscription_config": subscription_config,
-                    "signal_config": signal_config,
+                    "signal_subscriptions": signal_subscriptions
                 }
 
                 handler = self._dbus_fast_signal_handler(interface_signal, dbus_signal_state)
                 obj_interface.__getattribute__(on_signal_method_name)(handler)
-                logger.info(f"subscribed with signal_handler: signal={signal_config.signal}, bus_name={bus_name}, path={path}, interface={interface.name}")
+                logger.info(f"subscribed with signal_handler: signal={signal}, bus_name={bus_name}, path={path}, interface={interface.name}")
+
+                signal_subscription_count += 1
 
             else:
-                logger.warning(f"Invalid signal: signal={signal_config.signal}, bus_name={bus_name}, path={path}, interface={interface.name}")
+                logger.warning(f"Invalid signal: signal={signal}, bus_name={bus_name}, path={path}, interface={interface.name}")
 
-        return SubscribedInterface(
-            bus_name=bus_name,
-            path=path,
-            interface_name=interface.name,
-            subscription_config=subscription_config,
-            interface_config=si
-        )
+        return signal_subscription_count
 
     async def _process_interface(self, bus_name: str, path: str, introspection: dbus_introspection.Node, interface: dbus_introspection.Interface) -> list[SubscribedInterface]:
 
         logger.debug(f"process_interface: {bus_name}, {path}, {interface.name}")
-        subscription_configs = self.config.get_subscription_configs(bus_name, path)
+
         new_subscriptions: list[SubscribedInterface] = []
+        configured_signals: dict[str, list[dict[str, Any]]] = {}
+
+        subscription_configs = self.config.get_subscription_configs(bus_name, path)
         for subscription in subscription_configs:
             logger.debug(f"processing subscription config: {subscription.bus_name}, {subscription.path}")
             for subscription_interface in subscription.interfaces:
                 if subscription_interface.interface == interface.name:
                     logger.debug(f"matching config found for bus_name={bus_name}, path={path}, interface={interface.name}")
-                    subscribed_iterface = await self._subscribe_interface(bus_name, path, introspection, interface, subscription, subscription_interface)
 
-                    new_subscriptions.append(subscribed_iterface)
+                    # Determine signals we need to subscribe to
+                    for signal_config in subscription_interface.signals:
+                        signal_subscriptions = configured_signals.get(signal_config.signal, [])
+                        signal_subscriptions.append({
+                            "signal_config": signal_config,
+                            "subscription_config": subscription
+                        })
+                        configured_signals[signal_config.signal] = signal_subscriptions
+
+                    if subscription_interface.signals:
+                        new_subscriptions.append(SubscribedInterface(
+                            bus_name=bus_name,
+                            path=path,
+                            interface_name=interface.name,
+                            subscription_config=subscription
+                        ))
+
+        if len(configured_signals) > 0:
+
+            signal_subscription_count = await self._subscribe_interface_signals(
+                bus_name, path, interface, configured_signals
+            )
+            if signal_subscription_count > 0:
+                return new_subscriptions
 
-        return new_subscriptions
+        return []
 
     async def _introspect(self, bus_name: str, path: str) -> dbus_introspection.Node:
 
@@ -174,93 +317,107 @@ class DbusClient:
 
         return introspection
 
-    async def _visit_bus_name_path(self, bus_name: str, path: str) -> list[SubscribedInterface]:
+    async def _list_bus_name_paths(self, bus_name: str, path: str) -> list[str]:
+        """list all nested paths. Only paths that have interfaces are returned"""
 
-        new_subscriptions: list[SubscribedInterface] = []
+        paths: list[str] = []
 
         try:
             introspection = await self._introspect(bus_name, path)
         except TypeError as e:
             logger.warning(f"bus.introspect failed, bus_name={bus_name}, path={path}: {e}")
-            return new_subscriptions
+            return paths
 
         if len(introspection.nodes) == 0:
             logger.debug(f"leaf node: bus_name={bus_name}, path={path}, is_root={introspection.is_root}, interfaces={[i.name for i in introspection.interfaces]}")
 
-        for interface in introspection.interfaces:
-            new_subscriptions.extend(
-                await self._process_interface(bus_name, path, introspection, interface)
-            )
+        if len(introspection.interfaces) > 0:
+            paths.append(path)
 
         for node in introspection.nodes:
             path_seperator = "" if path.endswith('/') else "/"
-            new_subscriptions.extend(
-                await self._visit_bus_name_path(bus_name, f"{path}{path_seperator}{node.name}")
+            paths.extend(
+                await self._list_bus_name_paths(bus_name, f"{path}{path_seperator}{node.name}")
             )
 
-        return new_subscriptions
-
-    async def _handle_bus_name_added(self, bus_name: str) -> list[SubscribedInterface]:
+        return paths
 
+    async def _subscribe_dbus_object(self, bus_name: str, path: str) -> list[SubscribedInterface]:
+        """Subscribes to a dbus object at the given bus_name and path.
+        For each matching subscription config, subscribe to all configured interfaces,
+        start listening to signals and start/register flows if configured.
+        """
         if not self.config.is_bus_name_configured(bus_name):
             return []
 
-        # sanity checks
-        for umh in self.bus._user_message_handlers:
-            umh_bus_name = umh.__self__.bus_name
-            if umh_bus_name == bus_name:
-                logger.warning(f"handle_bus_name_added: {umh_bus_name} already added")
+        new_subscriptions: list[SubscribedInterface] = []
 
-        new_subscriped_interfaces = await self._visit_bus_name_path(bus_name, "/")
+        try:
+            introspection = await self._introspect(bus_name, path)
+        except TypeError as e:
+            logger.warning(f"bus.introspect failed, bus_name={bus_name}, path={path}: {e}")
+            return new_subscriptions
 
-        logger.info(f"new_subscriptions: {list(set([si.bus_name for si in new_subscriped_interfaces]))}")
+        if len(introspection.interfaces) == 0:
+            logger.warning(f"Skipping dbus_object subscription, no interfaces found for bus_name={bus_name}, path={path}")
+            return new_subscriptions
 
-        # setup and process triggers for each flow in each subscription
-        processed_new_subscriptions: set[str] = set()
+        interfaces_names = [i.name for i in introspection.interfaces]
+        logger.info(f"subscribe_dbus_object: bus_name={bus_name}, path={path}, interfaces={interfaces_names}")
 
-        # With all subscriptions in place, we can now ensure schedulers are created
-        # create a FlowProcessor per bus_name/path subscription?
-        # One global or a per subscription FlowProcessor.flow_processor_task?
-        # Start a new timer job, but leverage existing FlowScheduler
-        # How does the FlowScheduler now it should invoke the local FlowPocessor?
-        # Maybe use queues to communicate from here with the FlowProcessor?
-        # e.g.: StartFlows, StopFlows,
+        await self._create_proxy_object_subscription(bus_name, path, introspection)
 
-        for subscribed_interface in new_subscriped_interfaces:
+        for interface in introspection.interfaces:
+            new_subscriptions.extend(
+                await self._process_interface(bus_name, path, introspection, interface)
+            )
 
-            subscription_config = subscribed_interface.subscription_config
-            if subscription_config.id not in processed_new_subscriptions:
+        return new_subscriptions
 
-                # Ensure all schedulers are started
-                self.flow_scheduler.start_flow_set(subscription_config.flows)
+    async def _handle_bus_name_added(self, bus_name: str) -> list[SubscribedInterface]:
 
-                # Trigger flows that have a bus_name_added trigger configured
-                await self._trigger_bus_name_added(subscription_config, subscribed_interface.bus_name, subscribed_interface.path)
+        logger.debug(f"_handle_bus_name_added: bus_name={bus_name}")
 
-                processed_new_subscriptions.add(subscription_config.id)
+        if not self.config.is_bus_name_configured(bus_name):
+            return []
 
-        return new_subscriped_interfaces
+        object_paths = []
+        subscription_configs = self.config.get_subscription_configs(bus_name=bus_name)
+        for subscription_config in subscription_configs:
 
-    async def _trigger_bus_name_added(self, subscription_config: SubscriptionConfig, bus_name: str, path: str):
+            # if configured path is not a wildcard, use it
+            if "*" not in subscription_config.path:
+                object_paths.append(subscription_config.path)
+            else:
+                # if configured path is a wildcard, use introspection to find all paths
+                # and filter by subscription_config.path
+                introspected_paths = await self._list_bus_name_paths(bus_name, "/")
+                logger.debug(f"introspected paths for bus_name: {bus_name}, paths: {introspected_paths}")
+                for path in introspected_paths:
+                    if fnmatch.fnmatchcase(path, subscription_config.path):
+                        object_paths.append(path)
 
-        for flow in subscription_config.flows:
-            for trigger in flow.triggers:
-                if trigger.type == "bus_name_added":
-                    trigger_context = {
-                        "bus_name": bus_name,
-                        "path": path
-                    }
-                    trigger_message = FlowTriggerMessage(
-                        flow,
-                        trigger,
-                        datetime.now(),
-                        trigger_context=trigger_context
-                    )
-                    await self.event_broker.flow_trigger_queue.async_q.put(trigger_message)
+        # dedupe
+        object_paths = list(set(object_paths))
+
+        new_subscribed_interfaces = []
+
+        # for each object path, call _subscribe_dbus_object
+        for object_path in object_paths:
+            subscribed_object_interfaces = await self._subscribe_dbus_object(bus_name, object_path)
+            new_subscribed_interfaces.extend(subscribed_object_interfaces)
+
+        # start all flows for the new subscriptions
+        if len(new_subscribed_interfaces) > 0:
+            await self._start_subscription_flows(bus_name, new_subscribed_interfaces)
+
+        return new_subscribed_interfaces
 
     async def _handle_bus_name_removed(self, bus_name: str):
 
-        bus_name_subscriptions = self.subscriptions.get(bus_name)
+        logger.debug(f"_handle_bus_name_removed: bus_name={bus_name}")
+
+        bus_name_subscriptions = self.get_bus_name_subscriptions(bus_name)
 
         if bus_name_subscriptions:
             for path, proxy_object in bus_name_subscriptions.path_objects.items():
@@ -268,11 +425,16 @@ class DbusClient:
                 subscription_configs = self.config.get_subscription_configs(bus_name=bus_name, path=path)
                 for subscription_config in subscription_configs:
 
-                    # Trigger flows that have a bus_name_added trigger configured
+                    # Stop schedule triggers. Only done once per subscription_config
+                    # TODO: Dont stop when other bus_names are using the same flowset
+                    self.flow_scheduler.stop_flow_set(subscription_config.flows)
+
+                    # Trigger flows that have a bus_name_removed trigger configured
                     await self._trigger_bus_name_removed(subscription_config, bus_name, path)
 
-                    # Stop schedule triggers
-                    self.flow_scheduler.stop_flow_set(subscription_config.flows)
+                    # Trigger flows that have an object_removed trigger configured
+                    await self._trigger_object_removed(subscription_config, bus_name, path)
+
 
                 # Wait for completion
                 await self.event_broker.flow_trigger_queue.async_q.join()
@@ -293,39 +455,193 @@ class DbusClient:
 
             del self.subscriptions[bus_name]
 
-    async def _trigger_bus_name_removed(self, subscription_config: SubscriptionConfig, bus_name: str, path: str):
+    async def _handle_interfaces_added(self, bus_name: str, path: str) -> None:
+        """
+        Handles the addition of new D-Bus interfaces for a given bus name and object path.
+
+        This method checks if there are subscription configurations for the specified bus name and path.
+        If so, it subscribes to the D-Bus object and starts the necessary subscription flows for any new interfaces.
+
+        Args:
+            bus_name (str): The well-known name of the D-Bus service where the interface was added.
+            path (str): The object path on the D-Bus where the interface was added.
+        """
+
+        logger.debug(f"_handle_interfaces_added: bus_name={bus_name}, path={path}")
+
+        if not self.config.get_subscription_configs(bus_name=bus_name, path=path):
+            return
+
+        new_subscribed_interfaces = await self._subscribe_dbus_object(bus_name, path)
+
+        # start all flows for the new subscriptions
+        if len(new_subscribed_interfaces) > 0:
+            await self._start_subscription_flows(bus_name, new_subscribed_interfaces)
+
+    async def _handle_interfaces_removed(self, bus_name: str, path: str) -> None:
+
+        logger.debug(f"_handle_interfaces_removed: bus_name={bus_name}, path={path}")
+
+        subscription_configs = self.config.get_subscription_configs(bus_name=bus_name, path=path)
+        for subscription_config in subscription_configs:
+
+            # Stop schedule triggers. Only done once per subscription_config and not per path
+            # TODO, only stop if this subscription is not used for any other objects / paths
+            self.flow_scheduler.stop_flow_set(subscription_config.flows)
+
+            # Trigger flows that have an object_removed trigger configured
+            await self._trigger_object_removed(subscription_config, bus_name, path)
+
+        proxy_object = self.get_subscribed_proxy_object(bus_name, path)
+        if proxy_object is not None:
+
+            # Wait for completion
+            await self.event_broker.flow_trigger_queue.async_q.join()
+
+            # clean up all dbus matchrules
+            for interface in proxy_object._interfaces.values():
+                proxy_interface: dbus_aio.proxy_object.ProxyInterface = interface
+
+                # officially you should do 'off_...' but the below is easier
+                # proxy_interface.off_properties_changed(self.on_properties_changed)
+
+                # clean lingering interface matchrule from bus
+                if proxy_interface._signal_match_rule in self.bus._match_rules.keys():
+                    self.bus._remove_match_rule(proxy_interface._signal_match_rule)
+
+                # clean lingering interface messgage handler from bus
+                self.bus.remove_message_handler(proxy_interface._message_handler)
+
+            # For now that InterfacesRemoved signal means the entire object is removed form D-Bus
+            del self.subscriptions[bus_name].path_objects[path]
+
+        # cleanup the entire BusNameSubscriptions if no more objects are subscribed
+        bus_name_subscriptions = self.get_bus_name_subscriptions(bus_name)
+        if bus_name_subscriptions and len(bus_name_subscriptions.path_objects) == 0:
+            del self.subscriptions[bus_name]
+
+    async def _start_subscription_flows(self, bus_name: str, subscribed_interfaces: list[SubscribedInterface]):
+        """Start all flows for the new subscriptions.
+        For each matching bus_name-path subscription_config, the following is done:
+        1. Ensure the scheduler is started, at most one scheduler will be active for a subscription_config
+        2. Trigger flows that have a bus_name_added trigger configured (only once per bus_name)
+        3. Trigger flows that have a interfaces_added trigger configured (once for each bus_name-path pair)
+        """
+
+        bus_name_object_paths = {}
+        bus_name_object_path_interfaces = {}
+        for si in subscribed_interfaces:
+            bus_name_object_paths.setdefault(si.bus_name, [])
+            bus_name_object_path_interfaces.setdefault(si.bus_name, {}).setdefault(si.path, [])
+
+            if si.path not in bus_name_object_paths[si.bus_name]:
+                bus_name_object_paths[si.bus_name].append(si.path)
+
+            bus_name_object_path_interfaces[si.bus_name][si.path].append(si.interface_name)
+
+
+        # new_subscribed_bus_names = list(set([si.bus_name for si in subscribed_interfaces]))
+        # new_subscribed_bus_names_paths = {
+        #     bus_name: list(set([si.path for si in subscribed_interfaces if si.bus_name == bus_name]))
+        #     for bus_name in new_subscribed_bus_names
+        # }
+
+        logger.debug(f"_start_subscription_flows: ew_subscriptions: {list(bus_name_object_paths.keys())}")
+        logger.debug(f"_start_subscription_flows: new_bus_name_object_paths: {bus_name_object_paths}")
+
+        # setup and process triggers for each flow in each subscription
+        # just once per subscription_config
+        processed_new_subscriptions: set[str] = set()
+
+        # With all subscriptions in place, we can now ensure schedulers are created
+        # create a FlowProcessor per bus_name/path subscription?
+        # One global or a per subscription FlowProcessor.flow_processor_task?
+        # Start a new timer job, but leverage existing FlowScheduler
+        # How does the FlowScheduler now it should invoke the local FlowPocessor?
+        # Maybe use queues to communicate from here with the FlowProcessor?
+        # e.g.: StartFlows, StopFlows,
+
+        # for each bus_name
+        for bus_name, path_interfaces_map in bus_name_object_path_interfaces.items():
+
+            paths = list(path_interfaces_map.keys())
+
+            # for each path in the bus_name
+            for object_path in paths:
+
+                object_interfaces = path_interfaces_map[object_path]
+
+                # For each subscription_config that matches the bus_name and object_path
+                subscription_configs = self.config.get_subscription_configs(bus_name, object_path)
+                for subscription_config in subscription_configs:
+
+                    # Only process subscription_config once, no matter how many paths it matches
+                    if subscription_config.id not in processed_new_subscriptions:
+
+                        # Ensure all schedulers are started
+                        # If a scheduler is already active for this subscription flow, it will be reused
+                        self.flow_scheduler.start_flow_set(subscription_config.flows)
+
+                        # Trigger flows that have a bus_name_added trigger configured
+
+                        # TODO: path arg doesn't make sense here, it did work for mpris however where there is only one path
+                        # leaving it now for backwards compatibility
+                        await self._trigger_bus_name_added(subscription_config, bus_name, object_path)
+
+                        processed_new_subscriptions.add(subscription_config.id)
+
+                    # Trigger flows that have a object_added trigger configured
+                    await self._trigger_object_added(subscription_config, bus_name, object_path, object_interfaces)
+
+    async def _trigger_flows(self, subscription_config: SubscriptionConfig, type: str, context: dict):
 
-        # Trigger flows that have a bus_name_removed trigger configured
         for flow in subscription_config.flows:
             for trigger in flow.triggers:
-                if trigger.type == "bus_name_removed":
-                    trigger_context = {
-                        "bus_name": bus_name,
-                        "path": path
-                    }
-                    trigger_message = FlowTriggerMessage(
-                        flow,
-                        trigger,
-                        datetime.now(),
-                        trigger_context=trigger_context
-                    )
+                if trigger.type == type:
+                    trigger_message = FlowTriggerMessage(flow, trigger, datetime.now(), context)
                     await self.event_broker.flow_trigger_queue.async_q.put(trigger_message)
 
-    async def _dbus_name_owner_changed_callback(self, name, old_owner, new_owner):
+    async def _trigger_bus_name_added(self, subscription_config: SubscriptionConfig, bus_name: str, path: str):
+
+        # Trigger flows that have a bus_name_added trigger configured
+        await self._trigger_flows(subscription_config, "bus_name_added", {
+            "bus_name": bus_name,
+            "path": path
+        })
+
+    async def _trigger_bus_name_removed(self, subscription_config: SubscriptionConfig, bus_name: str, path: str):
+
+        # Trigger flows that have a bus_name_removed trigger configured
+        await self._trigger_flows(subscription_config, "bus_name_removed", {
+            "bus_name": bus_name,
+            "path": path
+        })
+
+    async def _trigger_object_added(self, subscription_config: SubscriptionConfig, bus_name: str, object_path: str, object_interfaces: list[str]):
 
-        logger.debug(f'NameOwnerChanged: name=q{name}, old_owner={old_owner}, new_owner={new_owner}')
+        # Trigger flows that have a object_added trigger configured
+        await self._trigger_flows(subscription_config, "object_added", {
+            "bus_name": bus_name,
+            "path": object_path
+            # "interfaces": object_interfaces
+        })
 
-        if new_owner and not old_owner:
-            logger.debug(f'NameOwnerChanged.new: name={name}')
-            await self._handle_bus_name_added(name)
-        if old_owner and not new_owner:
-            logger.debug(f'NameOwnerChanged.old: name={name}')
-            await self._handle_bus_name_removed(name)
+    async def _trigger_object_removed(self, subscription_config: SubscriptionConfig, bus_name: str, path: str):
+
+        # Trigger flows that have a object_removed trigger configured
+        await self._trigger_flows(subscription_config, "object_removed", {
+            "bus_name": bus_name,
+            "path": path
+        })
 
     async def call_dbus_interface_method(self, interface: dbus_aio.proxy_object.ProxyInterface, method: str, method_args: list[Any]):
 
         call_method_name = "call_" + camel_to_snake(method)
-        res = await interface.__getattribute__(call_method_name)(*method_args)
+        try:
+            res = await interface.__getattribute__(call_method_name)(*method_args)
+        except dbus_errors.DBusError as e:
+            logger.warning(f"Error while calling dbus object, bus_name={interface.bus_name}, interface={interface.introspection.name}, method={method}")
+            raise e
 
         if res:
             res = unwrap_dbus_object(res)
@@ -367,9 +683,16 @@ class DbusClient:
     async def dbus_signal_queue_processor_task(self):
         """Continuously processes messages from the async queue."""
         while True:
-            signal = await self.event_broker.dbus_signal_queue.async_q.get()  # Wait for a message
+            signal = await self._dbus_signal_queue.async_q.get()
             await self._handle_on_dbus_signal(signal)
-            self.event_broker.dbus_signal_queue.async_q.task_done()
+            self._dbus_signal_queue.async_q.task_done()
+
+    async def dbus_object_lifecycle_signal_processor_task(self):
+        """Continuously processes messages from the async queue."""
+        while True:
+            message = await self._dbus_object_lifecycle_signal_queue.async_q.get()
+            await self._handle_dbus_object_lifecycle_signal(message)
+            self._dbus_object_lifecycle_signal_queue.async_q.task_done()
 
     async def _handle_on_dbus_signal(self, signal: DbusSignalWithState):
 
@@ -390,6 +713,7 @@ class DbusClient:
                                 "bus_name": signal.bus_name,
                                 "path": signal.path,
                                 "interface": signal.interface_name,
+                                "signal": signal.signal_config.signal,
                                 "args": signal.args
                             }
                             trigger_message = FlowTriggerMessage(
@@ -403,6 +727,25 @@ class DbusClient:
                     except Exception as e:
                         logger.warning(f"dbus_signal_queue_processor_task: Exception {e}", exc_info=True)
 
+    async def _handle_dbus_object_lifecycle_signal(self, message: dbus_message.Message):
+
+        if message.member == 'NameOwnerChanged':
+            name, old_owner, new_owner = message.body
+            if new_owner != '' and old_owner == '':
+                await self._handle_bus_name_added(name)
+            if old_owner != '' and new_owner == '':
+                await self._handle_bus_name_removed(name)
+
+        if message.interface == 'org.freedesktop.DBus.ObjectManager':
+            bus_name = self.get_well_known_bus_name(message.sender)
+            if message.member == 'InterfacesAdded':
+                path = message.body[0]
+                await self._handle_interfaces_added(bus_name, path)
+            elif message.member == 'InterfacesRemoved':
+                path = message.body[0]
+                await self._handle_interfaces_removed(bus_name, path)
+
+
     async def _on_mqtt_msg(self, msg: MqttMessage):
         # self.queue.put({
         #     "topic": topic,

dbus2mqtt/dbus/dbus_types.py

@@ -1,23 +1,37 @@
 
 
 from dataclasses import dataclass
+from typing import Any
 
 import dbus_fast.aio as dbus_aio
 
-from dbus2mqtt.config import InterfaceConfig, SubscriptionConfig
+from dbus2mqtt.config import (
+    SignalConfig,
+    SubscriptionConfig,
+)
 
 
 class BusNameSubscriptions:
 
-    def __init__(self, bus_name: str):
+    def __init__(self, bus_name: str, unique_name: str):
         self.bus_name = bus_name
+        self.unique_name = unique_name
         self.path_objects: dict[str, dbus_aio.proxy_object.ProxyObject] = {}
 
 @dataclass
 class SubscribedInterface:
 
-    interface_config: InterfaceConfig
+    # interface_config: InterfaceConfig
     subscription_config: SubscriptionConfig
     bus_name: str
     path: str
     interface_name: str
+
+@dataclass
+class DbusSignalWithState:
+    bus_name: str
+    path: str
+    interface_name: str
+    subscription_config: SubscriptionConfig
+    signal_config: SignalConfig
+    args: list[Any]

dbus2mqtt/dbus/dbus_util.py

@@ -1,19 +1,20 @@
-import json
+import base64
 import re
 
 import dbus_fast.signature as dbus_signature
 
 
-def _variant_serializer(obj):
-    if isinstance(obj, dbus_signature.Variant):
-        return obj.value
-    return obj
-
-def unwrap_dbus_object(o):
-    # an easy way to get rid of dbus_fast.signature.Variant types
-    res = json.dumps(o, default=_variant_serializer)
-    json_obj = json.loads(res)
-    return json_obj
+def unwrap_dbus_object(obj):
+    if isinstance(obj, dict):
+        return {k: unwrap_dbus_object(v) for k, v in obj.items()}
+    elif isinstance(obj, list | tuple | set):
+        return type(obj)(unwrap_dbus_object(i) for i in obj)
+    elif isinstance(obj, dbus_signature.Variant):
+        return unwrap_dbus_object(obj.value)
+    elif isinstance(obj, bytes):
+        return base64.b64encode(obj).decode('utf-8')
+    else:
+        return obj
 
 def unwrap_dbus_objects(args):
     res = [unwrap_dbus_object(o) for o in args]

dbus2mqtt/event_broker.py

@@ -7,12 +7,7 @@ from typing import Any
 
 import janus
 
-from dbus2mqtt.config import (
-    FlowConfig,
-    FlowTriggerConfig,
-    SignalConfig,
-    SubscriptionConfig,
-)
+from dbus2mqtt.config import FlowConfig, FlowTriggerConfig
 
 logger = logging.getLogger(__name__)
 
@@ -23,15 +18,6 @@ class MqttMessage:
     payload: Any
     payload_serialization_type: str = "json"
 
-@dataclass
-class DbusSignalWithState:
-    bus_name: str
-    path: str
-    interface_name: str
-    subscription_config: SubscriptionConfig
-    signal_config: SignalConfig
-    args: list[Any]
-
 @dataclass
 class FlowTriggerMessage:
     flow_config: FlowConfig
@@ -43,7 +29,6 @@ class EventBroker:
     def __init__(self):
         self.mqtt_receive_queue = janus.Queue[MqttMessage]()
         self.mqtt_publish_queue = janus.Queue[MqttMessage]()
-        self.dbus_signal_queue = janus.Queue[DbusSignalWithState]()
         self.flow_trigger_queue = janus.Queue[FlowTriggerMessage]()
         # self.dbus_send_queue: janus.Queue
 
@@ -51,7 +36,6 @@ class EventBroker:
         await asyncio.gather(
             self.mqtt_receive_queue.aclose(),
             self.mqtt_publish_queue.aclose(),
-            self.dbus_signal_queue.aclose(),
             self.flow_trigger_queue.aclose(),
             return_exceptions=True
         )
@@ -63,7 +47,3 @@ class EventBroker:
     async def publish_to_mqtt(self, msg: MqttMessage):
         # logger.debug("publish_to_mqtt")
         await self.mqtt_publish_queue.async_q.put(msg)
-
-    def on_dbus_signal(self, signal: DbusSignalWithState):
-        # logger.debug("on_dbus_signal")
-        self.dbus_signal_queue.sync_q.put(signal)

dbus2mqtt/flow/flow_processor.py

@@ -7,7 +7,13 @@ from typing import Any
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 
 from dbus2mqtt import AppContext
-from dbus2mqtt.config import FlowConfig, FlowTriggerConfig, FlowTriggerDbusSignalConfig
+from dbus2mqtt.config import (
+    FlowConfig,
+    FlowTriggerConfig,
+    FlowTriggerDbusSignalConfig,
+    FlowTriggerObjectAddedConfig,
+    FlowTriggerObjectRemovedConfig,
+)
 from dbus2mqtt.event_broker import FlowTriggerMessage
 from dbus2mqtt.flow import FlowAction, FlowExecutionContext
 from dbus2mqtt.flow.actions.context_set import ContextSetAction
@@ -103,7 +109,7 @@ class FlowActionContext:
 
         return res
 
-    async def execute_actions(self, trigger_context: dict[str, Any] | None):
+    async def execute_actions(self, trigger_type: str, trigger_context: dict[str, Any] | None):
 
         # per flow execution context
         context = FlowExecutionContext(
@@ -111,6 +117,8 @@ class FlowActionContext:
             global_flows_context=self.global_flows_context,
             flow_context=self.flow_context)
 
+        context.context["trigger_type"] = trigger_type
+
         if trigger_context:
             context.context.update(trigger_context)
 
@@ -176,14 +184,20 @@ class FlowProcessor:
             finally:
                 self.event_broker.flow_trigger_queue.async_q.task_done()
 
-    def _trigger_config_to_str(self, config: FlowTriggerConfig) -> str:
+    def _trigger_config_to_str(self, msg: FlowTriggerMessage) -> str:
+        config = msg.flow_trigger_config
         if isinstance(config, FlowTriggerDbusSignalConfig):
             return f"{config.type}({config.signal})"
+        elif isinstance(config, FlowTriggerObjectAddedConfig) or isinstance(config, FlowTriggerObjectRemovedConfig):
+            path = msg.trigger_context.get('path') if msg.trigger_context else None
+            if path:
+                return f"{config.type}({path})"
         return config.type
 
     async def _process_flow_trigger(self, flow_trigger_message: FlowTriggerMessage):
 
-        trigger_str = self._trigger_config_to_str(flow_trigger_message.flow_trigger_config)
+        trigger_type = flow_trigger_message.flow_trigger_config.type
+        trigger_str = self._trigger_config_to_str(flow_trigger_message)
         flow_str = flow_trigger_message.flow_config.name or flow_trigger_message.flow_config.id
 
         log_message = f"on_trigger: {trigger_str}, flow={flow_str}, time={flow_trigger_message.timestamp.isoformat()}"
@@ -196,4 +210,4 @@ class FlowProcessor:
         flow_id = flow_trigger_message.flow_config.id
 
         flow = self._flows[flow_id]
-        await flow.execute_actions(trigger_context=flow_trigger_message.trigger_context)
+        await flow.execute_actions(trigger_type, trigger_context=flow_trigger_message.trigger_context)

dbus2mqtt/main.py

@@ -8,6 +8,8 @@ import colorlog
 import dbus_fast.aio as dbus_aio
 import dotenv
 
+from dbus_fast import BusType
+
 from dbus2mqtt import AppContext
 from dbus2mqtt.config import Config
 from dbus2mqtt.config.jsonarparse import new_argument_parser
@@ -23,7 +25,8 @@ logger = logging.getLogger(__name__)
 
 async def dbus_processor_task(app_context: AppContext, flow_scheduler: FlowScheduler):
 
-    bus = dbus_aio.message_bus.MessageBus()
+    bus_type = BusType.SYSTEM if app_context.config.dbus.bus_type == "SYSTEM" else BusType.SESSION
+    bus = dbus_aio.message_bus.MessageBus(bus_type=bus_type)
 
     dbus_client = DbusClient(app_context, bus, flow_scheduler)
     app_context.templating.add_functions(jinja_custom_dbus_functions(dbus_client))
@@ -36,7 +39,8 @@ async def dbus_processor_task(app_context: AppContext, flow_scheduler: FlowSched
     await asyncio.gather(
         dbus_client_run_future,
         asyncio.create_task(dbus_client.dbus_signal_queue_processor_task()),
-        asyncio.create_task(dbus_client.mqtt_receive_queue_processor_task())
+        asyncio.create_task(dbus_client.mqtt_receive_queue_processor_task()),
+        asyncio.create_task(dbus_client.dbus_object_lifecycle_signal_processor_task())
     )
 
 async def mqtt_processor_task(app_context: AppContext):
@@ -103,9 +107,19 @@ def main():
 
     config: Config = cast(Config, parser.instantiate_classes(cfg))
 
+    class NamePartsFilter(logging.Filter):
+        def filter(self, record):
+            record.name_last = record.name.rsplit('.', 1)[-1]
+            # record.name_first = record.name.split('.', 1)[0]
+            # record.name_short = record.name
+            # if record.name.startswith("dbus2mqtt"):
+            #     record.name_short = record.name.split('.', 1)[-1]
+            return True
+
     handler = colorlog.StreamHandler(stream=sys.stdout)
+    handler.addFilter(NamePartsFilter())
     handler.setFormatter(colorlog.ColoredFormatter(
-        '%(log_color)s%(levelname)s:%(name)s:%(message)s',
+        '%(log_color)s%(levelname)s:%(name_last)s:%(message)s',
         log_colors={
             "DEBUG": "light_black",
             "WARNING": "yellow",

dbus2mqtt/mqtt/mqtt_client.py

@@ -2,6 +2,8 @@
 import asyncio
 import json
 import logging
+import random
+import string
 
 from typing import Any
 from urllib.parse import ParseResult
@@ -24,7 +26,9 @@ class MqttClient:
         self.config = app_context.config.mqtt
         self.event_broker = app_context.event_broker
 
+        unique_client_id_postfix = ''.join(random.choices(string.ascii_lowercase + string.digits, k=6))
         self.client = mqtt.Client(
+            client_id=f"dbus2mqtt-client-{unique_client_id_postfix}",
             protocol=mqtt.MQTTv5,
             callback_api_version=CallbackAPIVersion.VERSION2
         )
@@ -42,10 +46,10 @@ class MqttClient:
 
     def connect(self):
 
-        # mqtt_client.on_message = lambda client, userdata, message: asyncio.create_task(mqtt_on_message(client, userdata, message))
         self.client.connect_async(
             host=self.config.host,
-            port=self.config.port
+            port=self.config.port,
+            clean_start=mqtt.MQTT_CLEAN_START_FIRST_ONLY
         )
 
     async def mqtt_publish_queue_processor_task(self):
@@ -98,12 +102,15 @@ class MqttClient:
             logger.info(f"on_connect: Connected to {self.config.host}:{self.config.port}")
             # Subscribing in on_connect() means that if we lose the connection and
             # reconnect then subscriptions will be renewed.
+            # TODO: Determine topics based on config
             client.subscribe("dbus2mqtt/#", options=SubscribeOptions(noLocal=True))
 
             self.loop.call_soon_threadsafe(self.connected_event.set)
 
     def on_message(self, client: mqtt.Client, userdata: Any, msg: mqtt.MQTTMessage):
 
+        # TODO: Skip messages being sent by other dbus2mqtt clients
+
         payload = msg.payload.decode()
         if msg.retain:
             logger.info(f"on_message: skipping msg with retain=True, topic={msg.topic}, payload={payload}")

dbus2mqtt/template/dbus_template_functions.py

@@ -32,7 +32,7 @@ class DbusContext:
             # Pylance will mentiod this line is unreachable. It is not as jinja2 can pass in any type
             raise ValueError("method_args must be a list")
 
-        proxy_object = self.dbus_client.get_proxy_object(bus_name, path)
+        proxy_object = self.dbus_client.get_subscribed_proxy_object(bus_name, path)
         if not proxy_object:
             raise ValueError(f"No matching subscription found for bus_name: {bus_name}, path: {path}")
 
@@ -42,7 +42,7 @@ class DbusContext:
 
     async def async_dbus_property_get_fn(self, bus_name: str, path: str, interface: str, property:str, default_unsupported: Any = None):
 
-        proxy_object = self.dbus_client.get_proxy_object(bus_name, path)
+        proxy_object = self.dbus_client.get_subscribed_proxy_object(bus_name, path)
         if not proxy_object:
             raise ValueError(f"No matching subscription found for bus_name: {bus_name}, path: {path}")
 

{dbus2mqtt-0.3.1.dist-info → dbus2mqtt-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbus2mqtt
-Version: 0.3.1
+Version: 0.4.0
 Summary: A Python tool to expose Linux D-Bus signals, methods and properties over MQTT - featuring templating, payload enrichment and Home Assistant-ready examples 
 Project-URL: Repository, https://github.com/jwnmulder/dbus2mqtt.git
 Project-URL: Issues, https://github.com/jwnmulder/dbus2mqtt/issues
@@ -53,7 +53,7 @@ Initial testing has focused on MPRIS integration. A table of tested MPRIS player
 
 ## Getting started with dbus2mqtt
 
-Create a `config.yaml` file with the contents shown below. This configuration will expose all bus properties from the `org.mpris.MediaPlayer2.Player` interface to MQTT on the `dbus2mqtt/org.mpris.MediaPlayer2/state` topic. Have a look at [docs/examples](docs/examples.md) for more examples
+Create a `config.yaml` file with the contents shown below. This configuration will expose all bus properties from the `org.mpris.MediaPlayer2.Player` interface to MQTT on the `dbus2mqtt/org.mpris.MediaPlayer2/state` topic. Have a look at [docs/examples](https://github.com/jwnmulder/dbus2mqtt/blob/main/docs/examples.md) for more examples
 
 ```yaml
 dbus:
@@ -68,7 +68,7 @@ dbus:
       flows:
         - name: "Publish MPRIS state"
           triggers:
-            - type: bus_name_added
+            - type: object_added
             - type: schedule
               interval: {seconds: 5}
           actions:
@@ -111,8 +111,8 @@ cp docs/examples/home_assistant_media_player.yaml $HOME/.config/dbus2mqtt/config
 cp .env.example $HOME/.config/dbus2mqtt/.env
 
 # run image and automatically start on reboot
-docker pull jwnmulder/dbus2mqtt
-docker run --detach --name dbus2mqtt \
+sudo docker pull jwnmulder/dbus2mqtt
+sudo docker run --detach --name dbus2mqtt \
   --volume "$HOME"/.config/dbus2mqtt:"$HOME"/.config/dbus2mqtt \
   --volume /run/user:/run/user \
   --env DBUS_SESSION_BUS_ADDRESS="$DBUS_SESSION_BUS_ADDRESS" \

dbus2mqtt-0.4.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+dbus2mqtt/__init__.py,sha256=VunubKEH4_lne9Ttd2YRpyXjZMIAzyD2eiJ2sfvvTFU,362
+dbus2mqtt/__main__.py,sha256=NAoa3nwgBSQI22eWzzRx61SIDThDwXmUofWWZU3_4-Q,71
+dbus2mqtt/event_broker.py,sha256=Hp5yurhP8FkAO-y0l2grygHxR2e37ZQ7QScjcQDA2UU,1334
+dbus2mqtt/main.py,sha256=Kr2LRVxWcPDtNwCj8Eqz9TxtGLAVrV4q0nizKh1pLXc,4539
+dbus2mqtt/config/__init__.py,sha256=LXQg2cZ_vMvhAl7_cC6G3gxCaLCq9uaTfZqw7OEXkPQ,5104
+dbus2mqtt/config/jsonarparse.py,sha256=VJGFeyQJcOE6bRXlSRr3FClvN_HnmiIlEGmOgNM0oCc,1214
+dbus2mqtt/dbus/dbus_client.py,sha256=0XneV3wulj6d_l4Jq9KIwROC19DLF853u6weCdyxpwA,39222
+dbus2mqtt/dbus/dbus_types.py,sha256=NmPD9um499e49Pk8DWH4IrIPQh1BinHYQgoXllCNiDw,777
+dbus2mqtt/dbus/dbus_util.py,sha256=h-1Y8Mvz9bj9X7mPZ8LghkvXDrujdJHK0__AOW373hE,697
+dbus2mqtt/dbus/introspection_patches/mpris_playerctl.py,sha256=q93d_Yp93u3Y-9q0dRdKW5hrij9GK3CFqKhUWVE8uw4,5883
+dbus2mqtt/dbus/introspection_patches/mpris_vlc.py,sha256=Cf-o-05W6gUoKpcYR7n0dRi-CrbeASPTwkyEzZGnU3Y,4241
+dbus2mqtt/flow/__init__.py,sha256=tAL-CjXQHq_tGTKctIdOZ5teVKBtcJs6Astq_RdruV8,1540
+dbus2mqtt/flow/flow_processor.py,sha256=-fJ5JPFcFqz1RokKaqjdHoU-EPg5McAERKYFwIkMzgU,8749
+dbus2mqtt/flow/actions/context_set.py,sha256=dIT39MJJVb0wuRI_ZM3ssnXYfa-iyB4o_UZD-1BZL2g,1087
+dbus2mqtt/flow/actions/mqtt_publish.py,sha256=psNkTvaR3JZwAwpM4AqiZTDnA5UQX9r4CUZ1LA7iRW4,2366
+dbus2mqtt/mqtt/mqtt_client.py,sha256=0d8XSe4-WxrUBxcUprukwxgzIhnCn1G0fCPnLqPp9ko,5148
+dbus2mqtt/template/dbus_template_functions.py,sha256=UEoXK2PqDKF6jR4vTFHQwq58f5APnOJr7B1_I1zW8yM,2449
+dbus2mqtt/template/templating.py,sha256=ZLp1A8PFAs_-Bndx4yGqyppaDfh8marHlK7P3bFInu4,4144
+dbus2mqtt-0.4.0.dist-info/METADATA,sha256=enb7xSlQVzVTVxCLshavr5HoV8tNamfd2AOJzgel_Sg,7887
+dbus2mqtt-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dbus2mqtt-0.4.0.dist-info/entry_points.txt,sha256=pmmacoHCsvTTUB5dIPaY4i0H9gX7BQlpd3rBU-Jbv3A,50
+dbus2mqtt-0.4.0.dist-info/licenses/LICENSE,sha256=a4bIEgyA9rrnAfUN90CgbgZ6BQIFHeABkk0JihiBaxM,1074
+dbus2mqtt-0.4.0.dist-info/RECORD,,

dbus2mqtt-0.3.1.dist-info/RECORD

@@ -1,23 +0,0 @@
-dbus2mqtt/__init__.py,sha256=VunubKEH4_lne9Ttd2YRpyXjZMIAzyD2eiJ2sfvvTFU,362
-dbus2mqtt/__main__.py,sha256=NAoa3nwgBSQI22eWzzRx61SIDThDwXmUofWWZU3_4-Q,71
-dbus2mqtt/event_broker.py,sha256=WNup2Xywt2MYs1yDyKAytApJn_YOPnxQag3kOkOajX0,1844
-dbus2mqtt/main.py,sha256=pHsRbjjvQSAOWhmfazixKteAdfrB-YnC4LQAZovdkEQ,3863
-dbus2mqtt/config/__init__.py,sha256=lx94zQsejGMRf90h594jId_CKXY0CyL7n6hk3lwAVvE,4307
-dbus2mqtt/config/jsonarparse.py,sha256=VJGFeyQJcOE6bRXlSRr3FClvN_HnmiIlEGmOgNM0oCc,1214
-dbus2mqtt/dbus/dbus_client.py,sha256=LAP6QkjPvDHIXOKncHiNYrTnVEV2NRYc1Mymzp-miMY,23217
-dbus2mqtt/dbus/dbus_types.py,sha256=EejiLlh3ALAnB4OFvNRL4ILBbxSKgFNNwifBrfap1Gc,494
-dbus2mqtt/dbus/dbus_util.py,sha256=Q50Tr1qjqZHpVirzvT9gXYwiCLwPe6BpgVmAcrqdHKE,569
-dbus2mqtt/dbus/introspection_patches/mpris_playerctl.py,sha256=q93d_Yp93u3Y-9q0dRdKW5hrij9GK3CFqKhUWVE8uw4,5883
-dbus2mqtt/dbus/introspection_patches/mpris_vlc.py,sha256=Cf-o-05W6gUoKpcYR7n0dRi-CrbeASPTwkyEzZGnU3Y,4241
-dbus2mqtt/flow/__init__.py,sha256=tAL-CjXQHq_tGTKctIdOZ5teVKBtcJs6Astq_RdruV8,1540
-dbus2mqtt/flow/flow_processor.py,sha256=TR30RpN0DoKWgx3Il-wyIzGwRqTjXyEUlqar3S3E3SI,8215
-dbus2mqtt/flow/actions/context_set.py,sha256=dIT39MJJVb0wuRI_ZM3ssnXYfa-iyB4o_UZD-1BZL2g,1087
-dbus2mqtt/flow/actions/mqtt_publish.py,sha256=psNkTvaR3JZwAwpM4AqiZTDnA5UQX9r4CUZ1LA7iRW4,2366
-dbus2mqtt/mqtt/mqtt_client.py,sha256=9Y0AEuquq4gEQ8j9JD1wauU22wSHZFSyQBNr905lwxA,4899
-dbus2mqtt/template/dbus_template_functions.py,sha256=0WXH-X3Si5D8iKP1WrSK9XmbKcaTGQo92SJsfHG0JEE,2427
-dbus2mqtt/template/templating.py,sha256=ZLp1A8PFAs_-Bndx4yGqyppaDfh8marHlK7P3bFInu4,4144
-dbus2mqtt-0.3.1.dist-info/METADATA,sha256=5xbhQusP8EUrvvMuN6rK2MUWBNKMgWOu1XkfADaGSd8,7830
-dbus2mqtt-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dbus2mqtt-0.3.1.dist-info/entry_points.txt,sha256=pmmacoHCsvTTUB5dIPaY4i0H9gX7BQlpd3rBU-Jbv3A,50
-dbus2mqtt-0.3.1.dist-info/licenses/LICENSE,sha256=a4bIEgyA9rrnAfUN90CgbgZ6BQIFHeABkk0JihiBaxM,1074
-dbus2mqtt-0.3.1.dist-info/RECORD,,