dbus2mqtt 0.4.4__py3-none-any.whl → 0.5.1__py3-none-any.whl

dbus2mqtt/config/__init__.py

@@ -3,9 +3,9 @@ import uuid
 import warnings
 
 from dataclasses import dataclass, field
-from typing import Annotated, Any, Literal
+from typing import Any, Literal
 
-from pydantic import Field, SecretStr
+from jsonargparse.typing import SecretStr
 
 from dbus2mqtt.template.templating import TemplateEngine
 
@@ -32,6 +32,7 @@ class PropertyConfig:
 class InterfaceConfig:
     interface: str
     mqtt_command_topic: str | None = None
+    mqtt_response_topic: str | None = None
     signals: list[SignalConfig] = field(default_factory=list)
     methods: list[MethodConfig] = field(default_factory=list)
     properties: list[PropertyConfig] = field(default_factory=list)
@@ -41,11 +42,10 @@ class InterfaceConfig:
             return template_engine.render_template(self.mqtt_command_topic, str, context)
         return None
 
-@dataclass
-class FlowTriggerMqttConfig:
-    type: Literal["mqtt"]
-    topic: str
-    filter: str | None = None
+    def render_mqtt_response_topic(self, template_engine: TemplateEngine, context: dict[str, Any]) -> str | None:
+        if self.mqtt_response_topic:
+            return template_engine.render_template(self.mqtt_response_topic, str, context)
+        return None
 
 @dataclass
 class FlowTriggerScheduleConfig:
@@ -87,10 +87,26 @@ class FlowTriggerObjectRemovedConfig:
     type: Literal["object_removed"] = "object_removed"
     # filter: str | None = None
 
-FlowTriggerConfig = Annotated[
-    FlowTriggerMqttConfig | FlowTriggerScheduleConfig | FlowTriggerDbusSignalConfig | FlowTriggerBusNameAddedConfig | FlowTriggerBusNameRemovedConfig | FlowTriggerObjectAddedConfig | FlowTriggerObjectRemovedConfig,
-    Field(discriminator="type")
-]
+@dataclass
+class FlowTriggerMqttMessageConfig:
+    topic: str
+    type: Literal["mqtt_message"] = "mqtt_message"
+    filter: str | None = None
+
+    def matches_filter(self, template_engine: TemplateEngine, trigger_context: dict[str, Any]) -> bool:
+        if self.filter:
+            return template_engine.render_template(self.filter, bool, trigger_context)
+        return True
+
+FlowTriggerConfig = (
+    FlowTriggerScheduleConfig
+    | FlowTriggerDbusSignalConfig
+    | FlowTriggerBusNameAddedConfig
+    | FlowTriggerBusNameRemovedConfig
+    | FlowTriggerObjectAddedConfig
+    | FlowTriggerObjectRemovedConfig
+    | FlowTriggerMqttMessageConfig
+)
 
 @dataclass
 class FlowActionContextSetConfig:
@@ -113,10 +129,11 @@ class FlowActionLogConfig:
     type: Literal["log"] = "log"
     level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
 
-FlowActionConfig = Annotated[
-    FlowActionMqttPublishConfig | FlowActionContextSetConfig | FlowActionLogConfig,
-    Field(discriminator="type")
-]
+FlowActionConfig = (
+    FlowActionMqttPublishConfig
+    | FlowActionContextSetConfig
+    | FlowActionLogConfig
+)
 
 @dataclass
 class FlowConfig:

dbus2mqtt/config/jsonarparse.py

@@ -1,32 +1,38 @@
+from typing import Any
+
 import jsonargparse
 
+from yaml import YAMLError
 
-def _custom_yaml_load(stream):
-    if isinstance(stream, str):
-        v = stream.strip()
+default_yaml_loader = jsonargparse.get_loader("yaml")
+def _custom_yaml_load(stream: str) -> Any:
 
-        # jsonargparse tries to parse yaml 1.1 boolean like values
-        # Without this, str:"{'PlaybackStatus': 'Off'}" would become dict:{'PlaybackStatus': False}
-        if v in ['on', 'On', 'off', 'Off', 'TRUE', 'FALSE', 'True', 'False']:
-            return stream
+    v = stream.strip()
 
-        # Anoyingly, values starting with {{ and ending with }} are working with the default yaml_loader
-        # from jsonargparse. Somehow its not when we use the custom yaml loader.
-        # This fixes it
-        first_line = v.splitlines()[0].strip()
-        if "#" not in first_line and ("{{" in first_line or first_line.startswith("{%")):
-            return stream
+    # jsonargparse tries to parse yaml 1.1 boolean like values
+    # Without this, str:"{'PlaybackStatus': 'Off'}" would become dict:{'PlaybackStatus': False}
+    if v in ['on', 'On', 'off', 'Off', 'TRUE', 'FALSE', 'True', 'False']:
+        return stream
 
     # Delegate to default yaml loader from jsonargparse
-    yaml_loader = jsonargparse.get_loader("yaml")
-    return yaml_loader(stream)
+    return default_yaml_loader(stream)
 
 def new_argument_parser() -> jsonargparse.ArgumentParser:
 
     # register out custom yaml loader for jsonargparse
-    jsonargparse.set_loader("yaml_custom", _custom_yaml_load)
+    jsonargparse.set_loader(
+        mode="yaml_custom",
+        loader_fn=_custom_yaml_load,
+        exceptions=(YAMLError,),
+        json_superset=True
+    )
 
     # unless specified otherwise, load config from config.yaml
-    parser = jsonargparse.ArgumentParser(default_config_files=["config.yaml"], default_env=True, env_prefix=False, parser_mode="yaml_custom")
+    parser = jsonargparse.ArgumentParser(
+        default_config_files=["config.yaml"],
+        default_env=True,
+        env_prefix=False,
+        parser_mode="yaml_custom"
+    )
 
     return parser

dbus2mqtt/dbus/dbus_client.py

@@ -7,11 +7,12 @@ 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 dbus_fast import SignatureTree
+
 from dbus2mqtt import AppContext
 from dbus2mqtt.config import SubscriptionConfig
 from dbus2mqtt.dbus.dbus_types import (
@@ -21,6 +22,7 @@ from dbus2mqtt.dbus.dbus_types import (
 )
 from dbus2mqtt.dbus.dbus_util import (
     camel_to_snake,
+    convert_mqtt_args_to_dbus,
     unwrap_dbus_object,
     unwrap_dbus_objects,
 )
@@ -28,7 +30,7 @@ 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 MqttMessage
+from dbus2mqtt.event_broker import MqttMessage, MqttReceiveHints
 from dbus2mqtt.flow.flow_processor import FlowScheduler, FlowTriggerMessage
 
 logger = logging.getLogger(__name__)
@@ -636,11 +638,19 @@ class DbusClient:
 
     async def call_dbus_interface_method(self, interface: dbus_aio.proxy_object.ProxyInterface, method: str, method_args: list[Any]):
 
+        converted_args = convert_mqtt_args_to_dbus(method_args)
         call_method_name = "call_" + camel_to_snake(method)
+
+        # In case of a payload that doesn't match the dbus signature type, this prints a better error message
+        interface_method = next((m for m in interface.introspection.methods if m.name == method), None)
+        if interface_method:
+            in_signature_tree = SignatureTree(interface_method.in_signature)
+            in_signature_tree.verify(converted_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}")
+            res = await interface.__getattribute__(call_method_name)(*converted_args)
+        except Exception as e:
+            logger.debug(f"Error while calling dbus object, bus_name={interface.bus_name}, interface={interface.introspection.name}, method={method}, converted_args={converted_args}", exc_info=True)
             raise e
 
         if res:
@@ -672,9 +682,9 @@ class DbusClient:
     async def mqtt_receive_queue_processor_task(self):
         """Continuously processes messages from the async queue."""
         while True:
-            msg = await self.event_broker.mqtt_receive_queue.async_q.get()  # Wait for a message
+            msg, hints = await self.event_broker.mqtt_receive_queue.async_q.get()  # Wait for a message
             try:
-                await self._on_mqtt_msg(msg)
+                await self._on_mqtt_msg(msg, hints)
             except Exception as e:
                 logger.warning(f"mqtt_receive_queue_processor_task: Exception {e}", exc_info=True)
             finally:
@@ -745,7 +755,7 @@ class DbusClient:
                 path = message.body[0]
                 await self._handle_interfaces_removed(bus_name, path)
 
-    async def _on_mqtt_msg(self, msg: MqttMessage):
+    async def _on_mqtt_msg(self, msg: MqttMessage, hints: MqttReceiveHints):
         """Executes dbus method calls or property updates on objects when messages have
         1. a matching subscription configured
         2. a matching method
@@ -756,7 +766,6 @@ class DbusClient:
         found_matching_topic = False
         for subscription_configs in self.config.subscriptions:
             for interface_config in subscription_configs.interfaces:
-                # TODO, performance improvement
                 mqtt_topic = interface_config.render_mqtt_command_topic(self.templating, {})
                 found_matching_topic |= mqtt_topic == msg.topic
 
@@ -777,7 +786,7 @@ class DbusClient:
         payload_value = msg.payload.get("value")
 
         if payload_method is None and (payload_property is None or payload_value is None):
-            if msg.payload:
+            if msg.payload and hints.log_unmatched_message:
                 logger.info(f"on_mqtt_msg: Unsupported payload, missing 'method' or 'property/value', got method={payload_method}, property={payload_property}, value={payload_value} from {msg.payload}")
             return
 
@@ -789,17 +798,32 @@ class DbusClient:
                             for interface_config in subscription_configs.interfaces:
 
                                 for method in interface_config.methods:
-
                                     # filter configured method, configured topic, ...
                                     if method.method == payload_method:
                                         interface = proxy_object.get_interface(name=interface_config.interface)
                                         matched_method = True
 
+                                        result = None
+                                        error = None
                                         try:
                                             logger.info(f"on_mqtt_msg: method={method.method}, args={payload_method_args}, bus_name={bus_name}, path={path}, interface={interface_config.interface}")
-                                            await self.call_dbus_interface_method(interface, method.method, payload_method_args)
+                                            result = await self.call_dbus_interface_method(interface, method.method, payload_method_args)
+
+                                            # Send response if configured
+                                            await self._send_mqtt_response(
+                                                interface_config, result, None, bus_name, path,
+                                                method=method.method, args=payload_method_args
+                                            )
+
                                         except Exception as e:
-                                            logger.warning(f"on_mqtt_msg: method={method.method}, args={payload_method_args}, bus_name={bus_name} failed, exception={e}")
+                                            error = e
+                                            logger.warning(f"on_mqtt_msg: Failed calling method={method.method}, args={payload_method_args}, bus_name={bus_name}, exception={e}")
+
+                                            # Send error response if configured
+                                            await self._send_mqtt_response(
+                                                interface_config, None, error, bus_name, path,
+                                                method=method.method, args=payload_method_args
+                                            )
 
                                 for property in interface_config.properties:
                                     # filter configured property, configured topic, ...
@@ -810,11 +834,97 @@ class DbusClient:
                                         try:
                                             logger.info(f"on_mqtt_msg: property={property.property}, value={payload_value}, bus_name={bus_name}, path={path}, interface={interface_config.interface}")
                                             await self.set_dbus_interface_property(interface, property.property, payload_value)
+
+                                            # Send property set response if configured
+                                            await self._send_mqtt_response(
+                                                interface_config, payload_value, None, bus_name, path,
+                                                property=property.property, value=[payload_value]
+                                            )
+
                                         except Exception as e:
                                             logger.warning(f"on_mqtt_msg: property={property.property}, value={payload_value}, bus_name={bus_name} failed, exception={e}")
 
-        if not matched_method and not matched_property:
+                                            # Send property set error response if configured
+                                            await self._send_mqtt_response(
+                                                interface_config, None, e, bus_name, path,
+                                                property=property.property, value=[payload_value],
+                                            )
+
+        if not matched_method and not matched_property and hints.log_unmatched_message:
             if payload_method:
-                logger.info(f"No configured or active dbus subscriptions for topic={msg.topic}, method={payload_method}, bus_name={payload_bus_name}, path={payload_path or '*'}, active bus_names={list(self.subscriptions.keys())}")
+                logger.info(f"No configured or active dbus subscriptions for topic={msg.topic}, method={payload_method}, bus_name={payload_bus_name}, path={payload_path}, active bus_names={list(self.subscriptions.keys())}")
             if payload_property:
-                logger.info(f"No configured or active dbus subscriptions for topic={msg.topic}, property={payload_property}, bus_name={payload_bus_name}, path={payload_path or '*'}, active bus_names={list(self.subscriptions.keys())}")
+                logger.info(f"No configured or active dbus subscriptions for topic={msg.topic}, property={payload_property}, bus_name={payload_bus_name}, path={payload_path}, active bus_names={list(self.subscriptions.keys())}")
+
+    async def _send_mqtt_response(self, interface_config, result: Any, error: Exception | None, bus_name: str, path: str, *args, **kwargs):
+        """Send MQTT response for a method call if response topic is configured
+
+        Args:
+            method (str, optional): The method to execute
+            args (list, optional): Arguments for the method
+            property (str, optional): The property to set
+            value (any, optional): The value to set for the property
+        """
+
+        if not interface_config.mqtt_response_topic:
+            return
+
+        try:
+            # Build response context
+            response_context = {
+                "bus_name": bus_name,
+                "path": path,
+                "interface": interface_config.interface,
+                "timestamp": datetime.now().isoformat()
+            }
+
+            # Check if 'method' and 'args' are provided
+            if 'method' in kwargs and 'args' in kwargs:
+                method = kwargs['method']
+                args = kwargs['args']
+                response_context.update({
+                    "method": method,
+                    "args": args,
+                })
+            # Check if 'property' and 'value' are provided
+            elif 'property' in kwargs and 'value' in kwargs:
+                property = kwargs['property']
+                value = kwargs['value']
+                response_context.update({
+                    "property": property,
+                    "value": value,
+                })
+            else:
+                return "Invalid arguments: Please provide either 'method' and 'args' or 'property' and 'value'"
+
+            # Add result or error to context
+            if error:
+                response_context.update({
+                    "success": False,
+                    "error": str(error),
+                    "error_type": error.__class__.__name__
+                })
+            else:
+                response_context.update({
+                    "success": True,
+                    "result": result
+                })
+
+            # Render response topic
+            response_topic = interface_config.render_mqtt_response_topic(
+                self.templating, response_context
+            )
+
+            if response_topic:
+                # Send response via MQTT
+                response_msg = MqttMessage(
+                    topic=response_topic,
+                    payload=response_context,
+                    payload_serialization_type="json"
+                )
+                await self.event_broker.publish_to_mqtt(response_msg)
+
+                logger.debug(f"Sent MQTT response: topic={response_topic}, success={response_context['success']}")
+
+        except Exception as e:
+            logger.warning(f"Failed to send MQTT response: {e}")

dbus2mqtt/dbus/dbus_util.py

@@ -1,8 +1,14 @@
 import base64
+import logging
 import re
 
+from typing import Any
+
 import dbus_fast.signature as dbus_signature
 
+from dbus_fast import Variant
+
+logger = logging.getLogger(__name__)
 
 def unwrap_dbus_object(obj):
     if isinstance(obj, dict):
@@ -22,3 +28,155 @@ def unwrap_dbus_objects(args):
 
 def camel_to_snake(name):
     return re.sub(r'([a-z])([A-Z])', r'\1_\2', name).lower()
+
+def _convert_value_to_dbus(value: Any) -> Any:
+    """
+    Recursively convert a single value to D-Bus compatible type.
+
+    Args:
+        value: The value to convert (can be dict, list, primitive, etc.)
+
+    Returns:
+        D-Bus compatible value
+    """
+    if value is None:
+        return value
+
+    elif isinstance(value, dict):
+        # Convert dict to D-Bus dictionary (a{sv} - dictionary of string to variant)
+        dbus_dict = {}
+        for k, v in value.items():
+            # Keys are typically strings in D-Bus dictionaries
+            key = str(k)
+            # Recursively convert the value first, then wrap in Variant
+            converted_value = _convert_value_to_dbus(v)
+            # Determine the appropriate D-Bus signature for the converted value
+            signature = _get_dbus_signature(converted_value)
+            dbus_dict[key] = Variant(signature, converted_value)
+        return dbus_dict
+
+    elif isinstance(value, list):
+        # Convert list to D-Bus array
+        converted_list = []
+        for item in value:
+            converted_list.append(_convert_value_to_dbus(item))
+        return converted_list
+
+    elif isinstance(value, bool):
+        # Boolean values are fine as-is for D-Bus
+        return value
+
+    elif isinstance(value, int):
+        # Integer values are fine as-is for D-Bus
+        return value
+
+    elif isinstance(value, float):
+        # Float values are fine as-is for D-Bus
+        return value
+
+    elif isinstance(value, str):
+        # String values are fine as-is for D-Bus
+        return value
+
+    else:
+        # For any other type, try to convert to string as fallback
+        logger.warning(f"Unknown type {type(value)} for D-Bus conversion, converting to string: {value}")
+        return str(value)
+
+def _get_dbus_signature(value: Any) -> str:
+    """
+    Get the appropriate D-Bus signature for a value.
+
+    Args:
+        value: The value to get signature for
+
+    Returns:
+        D-Bus type signature string
+    """
+    if isinstance(value, bool):
+        return 'b'  # boolean
+    elif isinstance(value, int):
+        uint16_min = 0
+        uint16_max = 0xFFFF
+        int16_min = -0x7FFF - 1
+        int16_max = 0x7FFF
+        uint32_min = 0
+        uint32_max = 0xFFFFFFFF
+        int32_min = -0x7FFFFFFF - 1
+        int32_max = 0x7FFFFFFF
+        uint64_min = 0
+        uint64_max = 18446744073709551615
+
+        if uint16_min <= value <= uint16_max:
+            return 'q'  # 16-bit unsigned int
+        elif int16_min <= value <= int16_max:
+            return 'n'  # 16-bit signed int
+        elif uint32_min <= value <= uint32_max:
+            return 'u'  # 32-bit unsigned int
+        elif int32_min <= value <= int32_max:
+            return 'i'  # 32-bit signed integer
+        elif uint64_min <= value <= uint64_max:
+            return 't'  # 64-bit unsigned integer
+        else:
+            return 'x'  # 64-bit signed integer
+    elif isinstance(value, float):
+        return 'd'  # double
+    elif isinstance(value, str):
+        return 's'  # string
+    elif isinstance(value, list):
+        if not value:
+            return 'as'  # assume array of strings for empty arrays
+        # Get signature of first element and assume homogeneous array
+        element_sig = _get_dbus_signature(value[0])
+        return f'a{element_sig}'  # array of elements
+    elif isinstance(value, dict):
+        return 'a{sv}'  # dictionary of string to variant
+    else:
+        return 's'  # fallback to string
+
+# Wraps all complex types in VariantList
+def convert_mqtt_args_to_dbus(args: list[Any]) -> list[Any]:
+    """
+    Convert MQTT/JSON arguments to D-Bus with explicit Variant wrapping for all complex types.
+
+    Args:
+        args: List of arguments from MQTT
+
+    Returns:
+        List of D-Bus compatible arguments with explicit Variants
+    """
+    converted_args = []
+
+    for arg in args:
+        converted_arg = _convert_and_wrap_in_variant(arg)
+        converted_args.append(converted_arg)
+
+    return converted_args
+
+def _convert_and_wrap_in_variant(value: Any) -> Any:
+    """
+    Convert a value and wrap complex types in Variants.
+    """
+    if value is None:
+        return value
+    elif isinstance(value, bool | int | float | str):
+        # Primitive types can be used as-is or wrapped in Variant if needed
+        return value
+    elif isinstance(value, dict):
+        # Convert dict and wrap in Variant
+        converted_dict = {}
+        for k, v in value.items():
+            key = str(k)
+            converted_value = _convert_value_to_dbus(v)
+            signature = _get_dbus_signature(converted_value)
+            converted_dict[key] = Variant(signature, converted_value)
+        return converted_dict
+    elif isinstance(value, list):
+        # Convert list and potentially wrap in Variant
+        converted_list = []
+        for item in value:
+            converted_list.append(_convert_and_wrap_in_variant(item))
+        return converted_list
+    else:
+        # Fallback
+        return value

dbus2mqtt/event_broker.py

@@ -18,6 +18,10 @@ class MqttMessage:
     payload: Any
     payload_serialization_type: str = "json"
 
+@dataclass
+class MqttReceiveHints:
+    log_unmatched_message: bool = True
+
 @dataclass
 class FlowTriggerMessage:
     flow_config: FlowConfig
@@ -27,7 +31,7 @@ class FlowTriggerMessage:
 
 class EventBroker:
     def __init__(self):
-        self.mqtt_receive_queue = janus.Queue[MqttMessage]()
+        self.mqtt_receive_queue = janus.Queue[tuple[MqttMessage, MqttReceiveHints]]()
         self.mqtt_publish_queue = janus.Queue[MqttMessage]()
         self.flow_trigger_queue = janus.Queue[FlowTriggerMessage]()
         # self.dbus_send_queue: janus.Queue
@@ -40,9 +44,9 @@ class EventBroker:
             return_exceptions=True
         )
 
-    def on_mqtt_receive(self, msg: MqttMessage):
+    def on_mqtt_receive(self, msg: MqttMessage, hints: MqttReceiveHints):
         # logger.debug("on_mqtt_receive")
-        self.mqtt_receive_queue.sync_q.put(msg)
+        self.mqtt_receive_queue.sync_q.put((msg, hints))
 
     async def publish_to_mqtt(self, msg: MqttMessage):
         # logger.debug("publish_to_mqtt")

dbus2mqtt/flow/flow_processor.py

@@ -8,6 +8,9 @@ from apscheduler.schedulers.asyncio import AsyncIOScheduler
 
 from dbus2mqtt import AppContext
 from dbus2mqtt.config import (
+    FlowActionContextSetConfig,
+    FlowActionLogConfig,
+    FlowActionMqttPublishConfig,
     FlowConfig,
     FlowTriggerConfig,
     FlowTriggerDbusSignalConfig,
@@ -101,11 +104,11 @@ class FlowActionContext:
         res = []
         for action_config in self.flow_config.actions:
             action = None
-            if action_config.type == "context_set":
+            if action_config.type == FlowActionContextSetConfig.type:
                 action = ContextSetAction(action_config, self.app_context)
-            elif action_config.type == "mqtt_publish":
+            elif action_config.type == FlowActionMqttPublishConfig.type:
                 action = MqttPublishAction(action_config, self.app_context)
-            elif action_config.type == "log":
+            elif action_config.type == FlowActionLogConfig.type:
                 action = LogAction(action_config, self.app_context)
 
             if action:

dbus2mqtt/mqtt/mqtt_client.py

@@ -5,6 +5,7 @@ import logging
 import random
 import string
 
+from datetime import datetime
 from typing import Any
 from urllib.parse import ParseResult
 from urllib.request import urlopen
@@ -18,13 +19,15 @@ from paho.mqtt.properties import Properties
 from paho.mqtt.subscribeoptions import SubscribeOptions
 
 from dbus2mqtt import AppContext
-from dbus2mqtt.event_broker import MqttMessage
+from dbus2mqtt.config import FlowConfig, FlowTriggerMqttMessageConfig
+from dbus2mqtt.event_broker import FlowTriggerMessage, MqttMessage, MqttReceiveHints
 
 logger = logging.getLogger(__name__)
 
 class MqttClient:
 
     def __init__(self, app_context: AppContext, loop):
+        self.app_context = app_context
         self.config = app_context.config.mqtt
         self.event_broker = app_context.event_broker
 
@@ -140,6 +143,51 @@ class MqttClient:
         try:
             json_payload = json.loads(payload) if payload else {}
             logger.debug(f"on_message: msg.topic={msg.topic}, msg.payload={json.dumps(json_payload)}")
-            self.event_broker.on_mqtt_receive(MqttMessage(msg.topic, json_payload))
+
+            # publish to flow trigger queue for any configured mqtt_message triggers
+            flow_trigger_messages = self._trigger_flows(msg.topic, {
+                "topic": msg.topic,
+                "payload": json_payload
+            })
+
+            # publish on a queue that is being processed by dbus_client
+            self.event_broker.on_mqtt_receive(
+                MqttMessage(msg.topic, json_payload),
+                MqttReceiveHints(
+                    log_unmatched_message=len(flow_trigger_messages) == 0
+                )
+            )
+
         except json.JSONDecodeError as e:
             logger.warning(f"on_message: Unexpected payload, expecting json, topic={msg.topic}, payload={payload}, error={e}")
+
+    def _trigger_flows(self, topic: str, trigger_context: dict) -> list[FlowTriggerMessage]:
+        """Triggers all flows that have a mqtt_trigger defined that matches the given topic
+           and configured filters."""
+
+        flow_trigger_messages = []
+
+        all_flows: list[FlowConfig] = []
+        all_flows.extend(self.app_context.config.flows)
+        for subscription in self.app_context.config.dbus.subscriptions:
+            all_flows.extend(subscription.flows)
+
+        for flow in all_flows:
+            for trigger in flow.triggers:
+                if trigger.type == FlowTriggerMqttMessageConfig.type:
+                    matches_filter = trigger.topic == topic
+                    if matches_filter and trigger.filter is not None:
+                        matches_filter = trigger.matches_filter(self.app_context.templating, trigger_context)
+
+                    if matches_filter:
+                        trigger_message = FlowTriggerMessage(
+                            flow,
+                            trigger,
+                            datetime.now(),
+                            trigger_context=trigger_context,
+                        )
+
+                        flow_trigger_messages.append(trigger_message)
+                        self.event_broker.flow_trigger_queue.sync_q.put(trigger_message)
+
+        return flow_trigger_messages

dbus2mqtt/template/dbus_template_functions.py

@@ -29,7 +29,7 @@ class DbusContext:
     async def async_dbus_call_fn(self, bus_name: str, path: str, interface: str, method:str, method_args: list[Any] = []):
 
         if not isinstance(method_args, list):
-            # Pylance will mentiod this line is unreachable. It is not as jinja2 can pass in any type
+            # Pylance will mention this line is unreachable. It is not, jinja2 can pass in any type
             raise ValueError("method_args must be a list")
 
         proxy_object = self.dbus_client.get_subscribed_proxy_object(bus_name, path)

{dbus2mqtt-0.4.4.dist-info → dbus2mqtt-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbus2mqtt
-Version: 0.4.4
+Version: 0.5.1
 Summary: General purpose DBus to MQTT bridge - expose signals, methods and properties over MQTT - featuring jinja based templating, payload enrichment and MPRIS / BlueZ / Home Assistant ready examples 
 Project-URL: Documentation, https://jwnmulder.github.io/dbus2mqtt
 Project-URL: Source, https://github.com/jwnmulder/dbus2mqtt
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Home Automation
 Requires-Python: >=3.10
 Requires-Dist: apscheduler>=3.11.0
@@ -27,7 +28,6 @@ Requires-Dist: jinja2-ansible-filters>=1.3.2
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: jsonargparse>=4.38.0
 Requires-Dist: paho-mqtt>=2.1.0
-Requires-Dist: pydantic>=2.11.3
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: pyyaml>=6.0.2
 Description-Content-Type: text/markdown
@@ -51,7 +51,7 @@ This makes it easy to integrate Linux desktop services or system signals into MQ
 
 **dbus2mqtt** is considered stable for the use-cases it has been tested against, and is actively being developed. Documentation is continuously being improved.
 
-Initial testing has focused on MPRIS integration. A table of tested MPRIS players and their supported methods can be found here: [Mediaplayer integration with Home Assistant](https://jwnmulder.github.io/dbus2mqtt/examples/home_assistant_media_player/)
+Initial testing has focused on MPRIS integration. A table of tested MPRIS players and their supported methods can be found on [Mediaplayer integration with Home Assistant](https://jwnmulder.github.io/dbus2mqtt/examples/home_assistant_media_player.html)
 
 ## Getting started with dbus2mqtt
 
@@ -94,7 +94,6 @@ MQTT__USERNAME=
 MQTT__PASSWORD=
 ```
 
-
 ### Install and run dbus2mqtt
 
 ```bash
@@ -102,136 +101,25 @@ python -m pip install dbus2mqtt
 dbus2mqtt --config config.yaml
 ```
 
-
-### Run using docker with auto start behavior
-
-To build and run dbus2mqtt using Docker with the [home_assistant_media_player.yaml](https://github.com/jwnmulder/dbus2mqtt/blob/main/docs/examples/home_assistant_media_player.yaml) example from this repository.
-
-```bash
-# setup configuration
-mkdir -p $HOME/.config/dbus2mqtt
-cp docs/examples/home_assistant_media_player.yaml $HOME/.config/dbus2mqtt/config.yaml
-cp .env.example $HOME/.config/dbus2mqtt/.env
-
-# run image and automatically start on reboot
-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" \
-  --env-file "$HOME"/.config/dbus2mqtt/.env \
-  --user $(id -u):$(id -g) \
-  --privileged \
-  --restart unless-stopped \
-  jwnmulder/dbus2mqtt \
-  --config "$HOME"/.config/dbus2mqtt/config.yaml
-
-# view logs
-sudo docker logs dbus2mqtt -f
-```
+See [setup](https://jwnmulder.github.io/dbus2mqtt/setup.html) for more installation options and configuration details.
 
 ## Examples
 
-More dbus2mqtt examples can be found here: [examples](https://jwnmulder.github.io/dbus2mqtt/examples/).
-The most complete one being [MPRIS to Home Assistant Media Player integration](https://jwnmulder.github.io/dbus2mqtt/examples/home_assistant_media_player/)
-
-## Configuration reference
-
-dbus2mqtt leverages [jsonargparse](https://jsonargparse.readthedocs.io/en/stable/) which allows configuration via either yaml configuration, CLI or environment variables. Until this is fully documented have a look at the examples in this repository.
-
-### MQTT and D-Bus connection details
-
-```bash
-# dbus_fast configuration
-export DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus
-
-# dbus2mqtt configuration
-MQTT__HOST=localhost
-MQTT__PORT=1883
-MQTT__USERNAME=
-MQTT__PASSWORD=
-```
-
-or
-
-```yaml
-mqtt:
-  host: localhost
-  port: 1883
-  subscription_topics:
-    - dbus2mqtt/#
-```
-
-### Exposing dbus methods
-
-```yaml
-dbus:
-  subscriptions:
-    - bus_name: org.mpris.MediaPlayer2.*
-      path: /org/mpris/MediaPlayer2
-      interfaces:
-        - interface: org.mpris.MediaPlayer2.Player
-          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`.
+More dbus2mqtt examples can be found in the [examples](https://jwnmulder.github.io/dbus2mqtt/examples/index.html) section.
+The most complete one being [Mediaplayer integration with Home Assistant](https://jwnmulder.github.io/dbus2mqtt/examples/home_assistant_media_player.html)
 
-Some examples that call methods  on **all** bus_names matching the configured pattern
+## Exposing dbus methods, properties and signals
 
-```json
-{
-    "method": "Play",
-}
-```
+See [subscriptions](https://jwnmulder.github.io/dbus2mqtt/subscriptions.html) for documentation on calling methods, setting properties and exposing D-Bus signals to MQTT. When configured, D-Bus methods can be invoked by publishing a message like
 
 ```json
 {
-    "method": "OpenUri",
-    "args": []
+    "method": "Play"
 }
 ```
 
-To specifically target objects the properties `bus_name` and/or `path` can be used. Both properties support wildcards
-
-```json
-{
-    "method": "Play",
-    "bus_name": "*.firefox",
-    "path": "/org/mpris/MediaPlayer2"
-}
-```
-
-### Exposing dbus signals
-
-Publishing signals to MQTT topics works by subscribing to the relevant signal and using flows for publishing
-
-```yaml
-dbus:
-  subscriptions:
-    - bus_name: org.mpris.MediaPlayer2.*
-      path: /org/mpris/MediaPlayer2
-      interfaces:
-        - interface: org.freedesktop.DBus.Properties
-           signals:
-             - signal: PropertiesChanged
-
-      flows:
-        - name: "Property Changed flow"
-          triggers:
-            - type: on_signal
-          actions:
-            - type: mqtt_publish
-              topic: dbus2mqtt/org.mpris.MediaPlayer2/signals/PropertiesChanged
-              payload_type: json
-```
-
-## Flows
-
-A reference of all supported flow triggers and actions can be found on [Flows](https://jwnmulder.github.io/dbus2mqtt/flows/)
+## Flows and Jinja based templating
 
-## Jinja templating
+For more advanced use-cases, dbus2mqtt has support for flows and Jinja2 based templates. A reference of all supported flow triggers and actions can be found on [flows](https://jwnmulder.github.io/dbus2mqtt/flows/index.html)
 
-TODO: Document Jinja templating, for now see the [MPRIS to Home Assistant Media Player integration](https://jwnmulder.github.io/dbus2mqtt/examples/home_assistant_media_player/) example
+Jinja templating documentation can be found here: [templating](https://jwnmulder.github.io/dbus2mqtt/templating/index.html)

{dbus2mqtt-0.4.4.dist-info → dbus2mqtt-0.5.1.dist-info}/RECORD

@@ -1,24 +1,24 @@
 dbus2mqtt/__init__.py,sha256=VunubKEH4_lne9Ttd2YRpyXjZMIAzyD2eiJ2sfvvTFU,362
 dbus2mqtt/__main__.py,sha256=NAoa3nwgBSQI22eWzzRx61SIDThDwXmUofWWZU3_4-Q,71
-dbus2mqtt/event_broker.py,sha256=Hp5yurhP8FkAO-y0l2grygHxR2e37ZQ7QScjcQDA2UU,1334
+dbus2mqtt/event_broker.py,sha256=8Iw1PNpH4IxQbpcFtNvPDc8_M8kuGarN6Kvz_a2aFfc,1468
 dbus2mqtt/main.py,sha256=Kr2LRVxWcPDtNwCj8Eqz9TxtGLAVrV4q0nizKh1pLXc,4539
-dbus2mqtt/config/__init__.py,sha256=947_dLVt8qq7P3p15jGIy5Vf1jUUMGrh1xr_DVhZclQ,5372
-dbus2mqtt/config/jsonarparse.py,sha256=XK7CrMCGiHZK2tq1IqSpzJ3hdV0gCOixJq3LXUDiEjg,1298
-dbus2mqtt/dbus/dbus_client.py,sha256=WHsmOiaJ5SY6zk-C99m83MEpycnUyGpsYmGopJJbPE8,39690
+dbus2mqtt/config/__init__.py,sha256=daqVzuSxNnUNKtMoMYs73AdlkfS6goXUsxF1wnKi7y0,5894
+dbus2mqtt/config/jsonarparse.py,sha256=-wcJW-O-Coqs0uqr5VVvk9mj6DWEm45NylSLkOhCECs,1084
+dbus2mqtt/dbus/dbus_client.py,sha256=PDZiscCF4imn7cxo5bDLmhQ8g9ZL-6RbGu5had1xiso,44832
 dbus2mqtt/dbus/dbus_types.py,sha256=NmPD9um499e49Pk8DWH4IrIPQh1BinHYQgoXllCNiDw,777
-dbus2mqtt/dbus/dbus_util.py,sha256=h-1Y8Mvz9bj9X7mPZ8LghkvXDrujdJHK0__AOW373hE,697
+dbus2mqtt/dbus/dbus_util.py,sha256=NUe_9Aohcib_bU8RUa19UPFteDZ0_WsmgCbbnmTUvcY,5814
 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=N-btGap1wqnM4zKyulH_5KQhGi0IRlsK2cHrrnomMQQ,8922
+dbus2mqtt/flow/flow_processor.py,sha256=UUdnIeVKXFRTJDBHLein6riHAh7UOKPdT4mTsnAmVV8,9067
 dbus2mqtt/flow/actions/context_set.py,sha256=dIT39MJJVb0wuRI_ZM3ssnXYfa-iyB4o_UZD-1BZL2g,1087
 dbus2mqtt/flow/actions/log_action.py,sha256=2_-YEKkX5kvFzK6x4v-Hx3u2PEM8fip_4buMg_ij-oI,1156
 dbus2mqtt/flow/actions/mqtt_publish.py,sha256=psNkTvaR3JZwAwpM4AqiZTDnA5UQX9r4CUZ1LA7iRW4,2366
-dbus2mqtt/mqtt/mqtt_client.py,sha256=bVAPbjgIi8ZQZlYVLe-Mo_A6NW6oQYEw1EYMOJYoS7w,6057
-dbus2mqtt/template/dbus_template_functions.py,sha256=UEoXK2PqDKF6jR4vTFHQwq58f5APnOJr7B1_I1zW8yM,2449
+dbus2mqtt/mqtt/mqtt_client.py,sha256=qvhaxtftdE7uS5Vhw-Dvhaicro4pWGtGlk254m2nEtI,8076
+dbus2mqtt/template/dbus_template_functions.py,sha256=oYXJ4HC1XCFGarf_tRzNGhvx2ECXDoT9J4Mz-cxqoJg,2447
 dbus2mqtt/template/templating.py,sha256=QLar09NinZO8rYGbVs9EThX-SOyTeBVCOppueU7VYdo,4483
-dbus2mqtt-0.4.4.dist-info/METADATA,sha256=aEi1sQg8JVDc6A1_uavQC6lsQljSnIoQuxUUgwsj8bI,8069
-dbus2mqtt-0.4.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dbus2mqtt-0.4.4.dist-info/entry_points.txt,sha256=pmmacoHCsvTTUB5dIPaY4i0H9gX7BQlpd3rBU-Jbv3A,50
-dbus2mqtt-0.4.4.dist-info/licenses/LICENSE,sha256=a4bIEgyA9rrnAfUN90CgbgZ6BQIFHeABkk0JihiBaxM,1074
-dbus2mqtt-0.4.4.dist-info/RECORD,,
+dbus2mqtt-0.5.1.dist-info/METADATA,sha256=bvfnVoBAYjKCvTYwqyBpVlX98ObW9gjg1bWhYtfUBWg,5393
+dbus2mqtt-0.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dbus2mqtt-0.5.1.dist-info/entry_points.txt,sha256=pmmacoHCsvTTUB5dIPaY4i0H9gX7BQlpd3rBU-Jbv3A,50
+dbus2mqtt-0.5.1.dist-info/licenses/LICENSE,sha256=a4bIEgyA9rrnAfUN90CgbgZ6BQIFHeABkk0JihiBaxM,1074
+dbus2mqtt-0.5.1.dist-info/RECORD,,