dbus2mqtt 0.1.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

dbus2mqtt/event_broker.py

@@ -37,7 +37,7 @@ class FlowTriggerMessage:
     flow_config: FlowConfig
     flow_trigger_config: FlowTriggerConfig
     timestamp: datetime
-    context: dict[str, Any] | None = None
+    trigger_context: dict[str, Any] | None = None
 
 class EventBroker:
     def __init__(self):

dbus2mqtt/flow/__init__.py

@@ -6,15 +6,34 @@ class FlowExecutionContext:
 
     def __init__(self, name: str | None, global_flows_context: dict[str, Any], flow_context: dict[str, Any]):
         self.name = name
+
         self.global_flows_context = global_flows_context
+        """
+        Global flows context which is shared across all flows.
+        Modifiable by user.
+        **Not** cleaned up after flow execution.
+        """
+
         self.flow_context = flow_context
+        """
+        Flow context which contains flow specific context like 'subscription_bus_name'.
+        **Not** modifiable by user.
+        **Not** cleaned up after flow execution.
+        """
 
-        # per flow execution context
         self.context: dict[str, Any] = {}
+        """
+        Per flow execution context.
+        Modifiable by user.
+        Cleaned up after each flow execution
+        """
 
     def get_aggregated_context(self) -> dict[str, Any]:
-        """Get the aggregated context for the flow execution."""
-        # Merge global flows context, flow context, and local context
+        """
+        Get the aggregated context for the flow execution.
+        Merges global flows context, flow context, and local context
+        """
+
         context = {}
         if self.global_flows_context:
             context.update(self.global_flows_context)

dbus2mqtt/flow/actions/context_set.py

@@ -15,12 +15,14 @@ class ContextSetAction(FlowAction):
     async def execute(self, context: FlowExecutionContext):
 
         aggregated_context = context.get_aggregated_context()
+
         if self.config.global_context:
             context_new = await self.templating.async_render_template(self.config.global_context, dict, aggregated_context)
             logger.debug(f"Update global_context with: {context_new}")
             context.global_flows_context.update(context_new)
 
         if self.config.context:
+
             context_new = await self.templating.async_render_template(self.config.context, dict, aggregated_context)
             logger.debug(f"Update context with: {context_new}")
             context.context.update(context_new)

dbus2mqtt/flow/actions/mqtt_publish.py

@@ -1,7 +1,9 @@
 
 import logging
 
-from jinja2.exceptions import TemplateRuntimeError
+from urllib.parse import urlparse
+
+from jinja2.exceptions import TemplateError
 
 from dbus2mqtt import AppContext
 from dbus2mqtt.config import FlowActionMqttPublishConfig
@@ -24,14 +26,30 @@ class MqttPublishAction(FlowAction):
         try:
             mqtt_topic = await self.templating.async_render_template(self.config.topic, str, render_context)
 
-            payload_res_type = str if self.config.payload_type == "text" else dict
-            payload = await self.templating.async_render_template(self.config.payload_template, payload_res_type, render_context)
+            if self.config.payload_type == "text":
+                res_type = str
+            elif self.config.payload_type == "binary":
+                res_type = str
+            else:
+                res_type = dict
+
+            payload = await self.templating.async_render_template(self.config.payload_template, res_type, render_context)
+
+            # for binary payloads, payload contains the file to read binary data from
+            if isinstance(payload, str) and self.config.payload_type == "binary":
+                uri = payload
+                payload = urlparse(uri)
+                if not payload.scheme == "file":
+                    raise ValueError(f"Expected readable file, got: '{uri}'")
+
 
-        except TemplateRuntimeError as e:
-            logger.warning(f"Error rendering jinja template, flow: '{context.name}', error: {str(e)}. render_context={render_context}", exc_info=True)
+        except TemplateError as e:
+            logger.warning(f"Error rendering jinja template, flow: '{context.name or ''}', msg={e}, payload_template={self.config.payload_template}, render_context={render_context}", exc_info=True)
             return
         except Exception as e:
-            logger.warning(f"Error rendering jinja template, flow: '{context.name}', error: {str(e)}. render_context={render_context}", exc_info=False)
+            # Dont log full exception info to avoid log spamming on dbus errors
+            # due to clients disconnecting
+            logger.warning(f"Error rendering jinja template, flow: '{context.name or ''}', msg={e} payload_template={self.config.payload_template}, render_context={render_context}")
             return
 
         logger.debug(f"public_mqtt: flow={context.name}, payload={payload}")

dbus2mqtt/flow/flow_processor.py

@@ -7,7 +7,7 @@ from typing import Any
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 
 from dbus2mqtt import AppContext
-from dbus2mqtt.config import FlowConfig, FlowTriggerConfig
+from dbus2mqtt.config import FlowConfig, FlowTriggerConfig, FlowTriggerDbusSignalConfig
 from dbus2mqtt.event_broker import FlowTriggerMessage
 from dbus2mqtt.flow import FlowAction, FlowExecutionContext
 from dbus2mqtt.flow.actions.context_set import ContextSetAction
@@ -46,6 +46,7 @@ class FlowScheduler:
                     if not existing_job and trigger.type == "schedule":
                         logger.info(f"Starting scheduler[{trigger.id}] for flow {flow.id}")
                         if trigger.interval:
+                            trigger_args: dict[str, Any] = trigger.interval
                             # Each schedule gets its own job
                             self.scheduler.add_job(
                                 self._schedule_flow_strigger,
@@ -55,9 +56,10 @@ class FlowScheduler:
                                 misfire_grace_time=5,
                                 coalesce=True,
                                 args=[flow, trigger],
-                                **trigger.interval
+                                **trigger_args
                             )
                         elif trigger.cron:
+                            trigger_args: dict[str, Any] = trigger.cron
                             # Each schedule gets its own job
                             self.scheduler.add_job(
                                 self._schedule_flow_strigger,
@@ -67,7 +69,7 @@ class FlowScheduler:
                                 misfire_grace_time=5,
                                 coalesce=True,
                                 args=[flow, trigger],
-                                **trigger.cron
+                                **trigger_args
                             )
 
     def stop_flow_set(self, flows):
@@ -160,38 +162,38 @@ class FlowProcessor:
                 await self._process_flow_trigger(flow_trigger_message)
 
             except Exception as e:
-                logger.warning(f"flow_processor_task: Exception {e}", exc_info=True)
+                # exc_info is only set when running in verbose mode to avoid lots of stack traces being printed
+                # while flows are still running and the DBus object was just removed. Some examples:
+
+                log_level = logging.WARN
+
+                # 1: error during context_set
+                # WARNING:dbus2mqtt.flow.flow_processor:flow_processor_task: Exception The name org.mpris.MediaPlayer2.firefox.instance_1_672 was not provided by any .service files
+                if "was not provided by any .service files" in str(e):
+                    log_level = logging.DEBUG
+
+                logger.log(log_level, f"flow_processor_task: Exception {e}", exc_info=logger.isEnabledFor(logging.DEBUG))
             finally:
                 self.event_broker.flow_trigger_queue.async_q.task_done()
 
+    def _trigger_config_to_str(self, config: FlowTriggerConfig) -> str:
+        if isinstance(config, FlowTriggerDbusSignalConfig):
+            return f"{config.type}({config.signal})"
+        return config.type
+
     async def _process_flow_trigger(self, flow_trigger_message: FlowTriggerMessage):
-        log_message = f"on_trigger: {flow_trigger_message.flow_trigger_config.type}, time={flow_trigger_message.timestamp.isoformat()}"
+
+        trigger_str = self._trigger_config_to_str(flow_trigger_message.flow_trigger_config)
+        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()}"
+
         if flow_trigger_message.flow_trigger_config.type != "schedule":
             logger.info(log_message)
         else:
             logger.debug(log_message)
 
         flow_id = flow_trigger_message.flow_config.id
-        # flow_name = flow_trigger_message.flow_config.name
 
         flow = self._flows[flow_id]
-        await flow.execute_actions(trigger_context=flow_trigger_message.context)
-
-# # Create a flow from the YAML configuration
-# for flow_config in config['flows']:
-#     flow_name = flow_config['name']
-#     triggers = flow_config.get('triggers', [])
-#     actions = flow_config.get('actions', [])
-
-#     with Flow(flow_name) as flow:
-#         data = "sensor_data"
-#         for action in actions:
-#             if action['type'] == 'python_script':
-#                 process_data(data)
-#             elif action['type'] == 'mqtt_publish':
-#                 mqtt_publish(action['topic'], action['message_template'], data)
-
-#         # Add scheduling trigger if defined
-#         for trigger in triggers:
-#             if trigger['type'] == 'schedule' and 'cron' in trigger:
-#                 flow.schedule = CronSchedule(cron=trigger['cron'])
+        await flow.execute_actions(trigger_context=flow_trigger_message.trigger_context)

dbus2mqtt/main.py

@@ -5,12 +5,12 @@ import sys
 from typing import cast
 
 import colorlog
-import dbus_next.aio as dbus_aio
+import dbus_fast.aio as dbus_aio
 import dotenv
-import jsonargparse
 
 from dbus2mqtt import AppContext
 from dbus2mqtt.config import Config
+from dbus2mqtt.config.jsonarparse import new_argument_parser
 from dbus2mqtt.dbus.dbus_client import DbusClient
 from dbus2mqtt.event_broker import EventBroker
 from dbus2mqtt.flow.flow_processor import FlowProcessor, FlowScheduler
@@ -41,14 +41,14 @@ async def dbus_processor_task(app_context: AppContext, flow_scheduler: FlowSched
 
 async def mqtt_processor_task(app_context: AppContext):
 
-    mqtt_client = MqttClient(app_context)
+    loop = asyncio.get_running_loop()
+    mqtt_client_run_future = loop.create_future()
+
+    mqtt_client = MqttClient(app_context, loop)
 
     mqtt_client.connect()
     mqtt_client.client.loop_start()
 
-    loop = asyncio.get_running_loop()
-    mqtt_client_run_future = loop.create_future()
-
     try:
         await asyncio.gather(
             mqtt_client_run_future,
@@ -84,6 +84,7 @@ async def run(config: Config):
     except asyncio.CancelledError:
         pass
 
+
 def main():
 
     # load environment from .env if it exists
@@ -92,8 +93,7 @@ def main():
         logger.info(f"Loaded environment variables from {dotenv_file}")
         dotenv.load_dotenv(dotenv_path=dotenv_file)
 
-    # unless specified otherwise, load config from config.yaml
-    parser = jsonargparse.ArgumentParser(default_config_files=["config.yaml"], default_env=True, env_prefix=False)
+    parser = new_argument_parser()
 
     parser.add_argument("--verbose", "-v", nargs="?", const=True, help="Enable verbose logging")
     parser.add_argument("--config", action="config")
@@ -121,15 +121,9 @@ def main():
         apscheduler_logger = logging.getLogger("apscheduler")
         apscheduler_logger.setLevel(logging.WARNING)
 
-
-    # handler.setFormatter(colorlog.ColoredFormatter('%(log_color)s%(levelname)s:%(name)s:%(message)s'))
-
-    # logger = colorlog.getLogger('')
-    # for handler in logger.handlers:
-    #     print(handler.st)
-    #     if isinstance(handler, colorlog.StreamHandler):
-    #         handler.setFormatter(colorlog.ColoredFormatter('%(log_color)s%(levelname)s:%(name)s:%(message)s'))
-
     logger.debug(f"config: {config}")
 
-    asyncio.run(run(config))
+    try:
+        asyncio.run(run(config))
+    except KeyboardInterrupt:
+        return 0

dbus2mqtt/mqtt/mqtt_client.py

@@ -4,6 +4,8 @@ import json
 import logging
 
 from typing import Any
+from urllib.parse import ParseResult
+from urllib.request import urlopen
 
 import paho.mqtt.client as mqtt
 import yaml
@@ -18,7 +20,7 @@ logger = logging.getLogger(__name__)
 
 class MqttClient:
 
-    def __init__(self, app_context: AppContext):
+    def __init__(self, app_context: AppContext, loop):
         self.config = app_context.config.mqtt
         self.event_broker = app_context.event_broker
 
@@ -35,6 +37,9 @@ class MqttClient:
         self.client.on_connect = self.on_connect
         self.client.on_message = self.on_message
 
+        self.loop = loop
+        self.connected_event = asyncio.Event()
+
     def connect(self):
 
         # mqtt_client.on_message = lambda client, userdata, message: asyncio.create_task(mqtt_on_message(client, userdata, message))
@@ -43,39 +48,48 @@ class MqttClient:
             port=self.config.port
         )
 
-    # def on_dbus_signal(self, bus_name: str, path: str, interface: str, signal: str, topic, msg: dict[str, Any]):
-    #     payload = json.dumps(msg)
-    #     logger.debug(f"on_dbus_signal: payload={payload}")
-    #     self.client.publish(topic=topic, payload=payload)
-
     async def mqtt_publish_queue_processor_task(self):
+
+        first_message = True
+
         """Continuously processes messages from the async queue."""
         while True:
             msg = await self.event_broker.mqtt_publish_queue.async_q.get()  # Wait for a message
+
             try:
-                payload = msg.payload
+                payload: str | bytes | None = msg.payload
                 type = msg.payload_serialization_type
-                if isinstance(msg.payload, dict):
-                    if type == "json":
-                        payload = json.dumps(msg.payload)
-                    elif type == "yaml":
-                        payload = yaml.dump(msg.payload)
-                elif type == "text":
-                    payload = str(payload)
-
-                logger.debug(f"mqtt_publish_queue_processor_task: payload={payload}")
-                self.client.publish(topic=msg.topic, payload=payload)
+                if type == "text":
+                    payload = str(msg.payload)
+                if isinstance(msg.payload, dict) and type == "json":
+                    payload = json.dumps(msg.payload)
+                elif isinstance(msg.payload, dict) and type == "yaml":
+                    payload = yaml.dump(msg.payload)
+                elif isinstance(msg.payload, ParseResult) and type == "binary":
+                    try:
+                        with urlopen(msg.payload.geturl()) as response:
+                            payload = response.read()
+                    except Exception as e:
+                        # In case failing uri reads, we still publish an empty msg to avoid stale data
+                        payload = None
+                        logger.warning(f"mqtt_publish_queue_processor_task: Exception {e}", exc_info=logger.isEnabledFor(logging.DEBUG))
+
+                payload_log_msg = payload if isinstance(payload, str) else msg.payload
+                logger.debug(f"mqtt_publish_queue_processor_task: topic={msg.topic}, type={payload.__class__}, payload={payload_log_msg}")
+
+                if first_message:
+                    await asyncio.wait_for(self.connected_event.wait(), timeout=5)
+
+                self.client.publish(topic=msg.topic, payload=payload or "").wait_for_publish(timeout=1000)
+                if first_message:
+                    logger.info(f"First message published: topic={msg.topic}, payload={payload_log_msg}")
+                    first_message = False
+
             except Exception as e:
-                logger.warning(f"mqtt_publish_queue_processor_task: Exception {e}", exc_info=True)
+                logger.warning(f"mqtt_publish_queue_processor_task: Exception {e}", exc_info=logger.isEnabledFor(logging.DEBUG))
             finally:
                 self.event_broker.mqtt_publish_queue.async_q.task_done()
 
-
-    async def run(self):
-        """Runs the MQTT loop in a non-blocking way with asyncio."""
-        self.client.loop_start()  # Runs Paho's loop in a background thread
-        await asyncio.Event().wait()  # Keeps the coroutine alive
-
     # The callback for when the client receives a CONNACK response from the server.
     def on_connect(self, client: mqtt.Client, userdata, flags, reason_code, properties):
         if reason_code.is_failure:
@@ -86,6 +100,8 @@ class MqttClient:
             # reconnect then subscriptions will be renewed.
             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):
 
         payload = msg.payload.decode()

dbus2mqtt/template/dbus_template_functions.py

@@ -3,8 +3,8 @@ import logging
 
 from typing import Any
 
-from dbus_next.constants import ErrorType
-from dbus_next.errors import DBusError
+from dbus_fast.constants import ErrorType
+from dbus_fast.errors import DBusError
 
 from dbus2mqtt.dbus.dbus_client import DbusClient
 

dbus2mqtt/template/templating.py

@@ -1,49 +1,11 @@
 
 from datetime import datetime
-from typing import Any
-
-import yaml
-
-from jinja2 import (
-    BaseLoader,
-    Environment,
-    StrictUndefined,
-)
-from yaml import SafeDumper, SafeLoader
-
-
-def _represent_template_str(dumper: SafeDumper, data: str):
-    data = data.replace("{{", "template:{{", 1)
-    data = data.replace("}}", "}}:template", 1)
-    # return dumper.represent_str(f"template:{data}:template")
-    return dumper.represent_str(data)
-
-class _CustomSafeLoader(SafeLoader):
-    def __init__(self, stream):
-        super().__init__(stream)
-
-        # Disable parsing ISO date strings
-        self.add_constructor('tag:yaml.org,2002:timestamp', lambda _l, n: n.value)
-
-class _CustomSafeDumper(SafeDumper):
-    def __init__(self, stream, **kwargs):
-        super().__init__(stream, **kwargs)
-        self.add_representer(_TemplatedStr, _represent_template_str)
-
-class _TemplatedStr(str):
-    """A marker class to force template string formatting in YAML."""
-    pass
-
-def _mark_templates(obj):
-    if isinstance(obj, dict):
-        return {k: _mark_templates(v) for k, v in obj.items()}
-    elif isinstance(obj, list):
-        return [_mark_templates(v) for v in obj]
-    elif isinstance(obj, str):
-        s = obj.strip()
-        if s.startswith("{{") and s.endswith("}}"):
-            return _TemplatedStr(obj)
-    return obj
+from typing import Any, TypeVar
+
+from jinja2 import BaseLoader, StrictUndefined, TemplateError
+from jinja2.nativetypes import NativeEnvironment
+
+TemplateResultType = TypeVar('TemplateResultType')
 
 class TemplateEngine:
     def __init__(self):
@@ -51,14 +13,14 @@ class TemplateEngine:
         engine_globals = {}
         engine_globals['now'] = datetime.now
 
-        self.jinja2_env = Environment(
+        self.jinja2_env = NativeEnvironment(
             loader=BaseLoader(),
             extensions=['jinja2_ansible_filters.AnsibleCoreFiltersExtension'],
             undefined=StrictUndefined,
             keep_trailing_newline=False
         )
 
-        self.jinja2_async_env = Environment(
+        self.jinja2_async_env = NativeEnvironment(
             loader=BaseLoader(),
             extensions=['jinja2_ansible_filters.AnsibleCoreFiltersExtension'],
             undefined=StrictUndefined,
@@ -66,7 +28,6 @@ class TemplateEngine:
         )
 
         self.app_context: dict[str, Any] = {}
-        # self.dbus_context: dict[str, Any] = {}
 
         self.jinja2_env.globals.update(engine_globals)
         self.jinja2_async_env.globals.update(engine_globals)
@@ -78,52 +39,68 @@ class TemplateEngine:
     def update_app_context(self, context: dict[str, Any]):
         self.app_context.update(context)
 
-    def _dict_to_templatable_str(self, value: dict[str, Any]) -> str:
-        template_str = _mark_templates(value)
-        template_str = yaml.dump(template_str, Dumper=_CustomSafeDumper)
-        # value= yaml.safe_dump(value, default_style=None)
-        # print(f"_dict_to_templatable_str: {value}")
-        template_str = template_str.replace("template:{{", "{{").replace("}}:template", "}}")
-        # print(value)
-        return template_str
+    def _convert_value(self, res: Any, res_type: type[TemplateResultType]) -> TemplateResultType:
 
-    def _render_result_to_dict(self, value: str) -> dict[str, Any]:
-        return yaml.load(value, _CustomSafeLoader)
+        if res is None:
+            return res
 
-    def render_template(self, template: str | dict | None, res_type: type, context: dict[str, Any] = {}) -> Any:
+        if isinstance(res, res_type):
+            return res
 
-        if not template:
-            return None
+        try:
+            return res_type(res) # type: ignore
 
-        if res_type not in [dict, str]:
-            raise ValueError(f"Unsupported result type: {res_type}")
+        except Exception as e:
+            raise ValueError(f"Error converting rendered template result from '{type(res).__name__}' to '{res_type.__name__}'") from e
 
-        dict_template = isinstance(template, dict)
-        if dict_template:
-            template = self._dict_to_templatable_str(template)
+    def _render_template_nested(self, templatable: str | dict[str, Any], context: dict[str, Any] = {}) -> Any:
 
-        res = self.jinja2_env.from_string(template).render(**context)
+        if isinstance(templatable, str):
+            try:
+                return self.jinja2_env.from_string(templatable).render(**context)
+            except TemplateError as e:
+                raise TemplateError(f"Error compiling template, template={templatable}: {e}") from e
 
-        if res_type is dict:
-            res = self._render_result_to_dict(res)
+        elif isinstance(templatable, dict):
+            res = {}
+            for k, v in templatable.items():
+                if isinstance(v, dict) or isinstance(v, str):
+                    res[k] = self._render_template_nested(v, context)
+                else:
+                    res[k] = v
+            return res
 
-        return res
+    def render_template(self, templatable: str | dict[str, Any], res_type: type[TemplateResultType], context: dict[str, Any] = {}) -> TemplateResultType:
 
-    async def async_render_template(self, template: str | dict | None, res_type: type, context: dict[str, Any] = {}) -> Any:
+        if isinstance(templatable, dict) and res_type is not dict:
+            raise ValueError(f"res_type should dict for dictionary templates, templatable={templatable}")
+
+        res = self._render_template_nested(templatable, context)
+        res = self._convert_value(res, res_type)
+        return res
 
-        if not template:
-            return None
+    async def _async_render_template_nested(self, templatable: str | dict[str, Any], context: dict[str, Any] = {}) -> Any:
 
-        if res_type not in [dict, str]:
-            raise ValueError(f"Unsupported result type: {res_type}")
+        if isinstance(templatable, str):
+            try:
+                return await self.jinja2_async_env.from_string(templatable).render_async(**context)
+            except TemplateError as e:
+                raise TemplateError(f"Error compiling template, template={templatable}: {e}") from e
 
-        dict_template = isinstance(template, dict)
-        if dict_template:
-            template = self._dict_to_templatable_str(template)
+        elif isinstance(templatable, dict):
+            res = {}
+            for k, v in templatable.items():
+                if isinstance(v, dict) or isinstance(v, str):
+                    res[k] = await self._async_render_template_nested(v, context)
+                else:
+                    res[k] = v
+            return res
 
-        res = await self.jinja2_async_env.from_string(template).render_async(**context)
+    async def async_render_template(self, templatable: str | dict[str, Any], res_type: type[TemplateResultType], context: dict[str, Any] = {}) -> TemplateResultType:
 
-        if res_type is dict:
-            res = self._render_result_to_dict(res)
+        if isinstance(templatable, dict) and res_type is not dict:
+            raise ValueError(f"res_type should be dict for dictionary templates, templatable={templatable}")
 
+        res = await self._async_render_template_nested(templatable, context)
+        res = self._convert_value(res, res_type)
         return res

{dbus2mqtt-0.1.2.dist-info → dbus2mqtt-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbus2mqtt
-Version: 0.1.2
+Version: 0.3.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
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: apscheduler>=3.11.0
 Requires-Dist: colorlog>=6.9.0
-Requires-Dist: dbus-next>=0.2.3
+Requires-Dist: dbus-fast>=2.44.1
 Requires-Dist: janus>=2.0.0
 Requires-Dist: jinja2-ansible-filters>=1.3.2
 Requires-Dist: jinja2>=3.1.6
@@ -51,12 +51,6 @@ This makes it easy to integrate Linux desktop services or system signals into MQ
 
 Initial testing has focused on MPRIS integration. A table of tested MPRIS players and their supported methods can be found here: [home_assistant_media_player.md](https://github.com/jwnmulder/dbus2mqtt/blob/main/docs/examples/home_assistant_media_player.md)
 
-
-TODO list
-
-* Improve error handling when deleting message with 'retain' set. WARNING:dbus2mqtt.mqtt_client:on_message: Unexpected payload, expecting json, topic=dbus2mqtt/org.mpris.MediaPlayer2/command, payload=, error=Expecting value: line 1 column 1 (char 0)
-* Property set only works the first time, need to restart after which the first set will work again
-
 ## 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
@@ -86,7 +80,7 @@ dbus:
               topic: dbus2mqtt/org.mpris.MediaPlayer2/state
               payload_type: json
               payload_template: |
-                {{ dbus_call(mpris_bus_name, path, 'org.freedesktop.DBus.Properties', 'GetAll', ['org.mpris.MediaPlayer2.Player']) | to_yaml }}
+                {{ dbus_call(mpris_bus_name, path, 'org.freedesktop.DBus.Properties', 'GetAll', ['org.mpris.MediaPlayer2.Player']) }}
 ```
 
 MQTT connection details can be configured in that same `config.yaml` file or via environment variables. For now create a `.env` file with the following contents.
@@ -117,6 +111,7 @@ 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 \
   --volume "$HOME"/.config/dbus2mqtt:"$HOME"/.config/dbus2mqtt \
   --volume /run/user:/run/user \
@@ -143,7 +138,7 @@ dbus2mqtt leverages [jsonargparse](https://jsonargparse.readthedocs.io/en/stable
 ### MQTT and D-Bus connection details
 
 ```bash
-# dbus_next configuration
+# dbus_fast configuration
 export DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus
 
 # dbus2mqtt configuration
@@ -170,13 +165,15 @@ dbus:
       path: /org/mpris/MediaPlayer2
       interfaces:
         - interface: org.mpris.MediaPlayer2.Player
-          mqtt_call_method_topic: dbus2mqtt/org.mpris.MediaPlayer2/command
+          mqtt_command_topic: dbus2mqtt/org.mpris.MediaPlayer2/command
           methods:
             - method: Pause
             - method: Play
 ```
 
-This configuration will expose 2 methods. Triggering methods can be done by publishing json messages to the `dbus2mqtt/org.mpris.MediaPlayer2/command` MQTT topic. Arguments can be passed along in `args`
+This configuration will expose 2 methods. Triggering methods can be done by publishing json messages to the `dbus2mqtt/org.mpris.MediaPlayer2/command` MQTT topic. Arguments can be passed along in `args`.
+
+Note that methods are called on **all** bus_names matching the configured pattern
 
 ```json
 {