boneio 1.6.0.dev23__tar.gz → 1.6.0.dev25__tar.gz

{boneio-1.6.0.dev23/boneio.egg-info → boneio-1.6.0.dev25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.6.0.dev23
+Version: 1.6.0.dev25
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/components/input/binary_sensor.py

@@ -131,6 +131,15 @@ class GpioInputBinarySensor(GpioBaseClass):
         """Send initial state after setup."""
         self.send_current_state()
 
+    def send_current_state_when_ready(self) -> None:
+        """Send the current state now, or as soon as the GPIO manager starts.
+
+        Before start the pin cannot be read, and ``read_value`` answers False —
+        which a non-inverted input reports as ``pressed``. Publishing that would
+        put a wrong state on a retained topic.
+        """
+        get_gpio_manager(loop=self._loop).register_on_start_callback(self.send_current_state)
+
     def send_current_state(self) -> None:
         """Send current state to MQTT without triggering actions.
         

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/components/input/remote/base.py

@@ -137,7 +137,7 @@ class RemoteInputBase:
     # Helpers for subclasses
     # ------------------------------------------------------------------
 
-    def _handle_binary_state_change(self, new_state: bool) -> None:
+    def _handle_binary_state_change(self, new_state: bool, publish_only: bool = False) -> None:
         """Process a state change in binary_sensor mode.
 
         Emits ``pressed`` or ``released`` directly to EventBus.
@@ -146,10 +146,14 @@ class RemoteInputBase:
 
         Args:
             new_state: ``True`` if the sensor is now active/on.
+            publish_only: Take the state without running actions — for a state
+                learnt rather than seen changing, e.g. a retained replay.
         """
         self._state = new_state
         click_type = PRESSED if new_state else RELEASED
-        self.press_callback(click_type=click_type, duration=None, start_time=time.time())
+        self.press_callback(
+            click_type=click_type, duration=None, start_time=time.time(), publish_only=publish_only
+        )
 
     def _feed_detector(self, is_pressed: bool) -> None:
         """Feed a state change into the MultiClickDetector (event mode).
@@ -189,6 +193,7 @@ class RemoteInputBase:
         click_type: ClickTypes,
         duration: float | None = None,
         start_time: float | None = None,
+        publish_only: bool = False,
     ) -> None:
         """Schedule async event processing.
 
@@ -196,14 +201,16 @@ class RemoteInputBase:
             click_type: Type of click.
             duration: Duration of the press in seconds.
             start_time: Start time of the press.
+            publish_only: Publish the state, run no actions.
         """
-        asyncio.create_task(self._handle_press_with_lock(click_type, duration, start_time))
+        asyncio.create_task(self._handle_press_with_lock(click_type, duration, start_time, publish_only))
 
     async def _handle_press_with_lock(
         self,
         click_type: ClickTypes,
         duration: float | None = None,
         start_time: float | None = None,
+        publish_only: bool = False,
     ) -> None:
         """Emit InputEvent on EventBus (serialised with lock)."""
         async with self._event_lock:
@@ -232,6 +239,7 @@ class RemoteInputBase:
                     click_type=click_type,
                     duration=duration,
                     state=event_state,
+                    publish_only=publish_only,
                 )
             )
 

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/components/input/remote/mqtt.py

@@ -98,7 +98,7 @@ class MqttBinarySensorInput(RemoteInputBase):
             return False
         return None
 
-    async def on_mqtt_message(self, _topic: str, payload: str) -> None:
+    async def on_mqtt_message(self, _topic: str, payload: str, retained: bool = False) -> None:
         """Handle a message on the subscribed topic.
 
         Two payload shapes are understood. A plain on/off state is the usual
@@ -107,12 +107,24 @@ class MqttBinarySensorInput(RemoteInputBase):
         mode it is passed through as-is rather than re-derived from a state
         this side never saw.
 
+        A retained message is the broker replaying what it stored, on every
+        subscribe — so on every reconnect. It says what the state *is*, not
+        that it just changed: binary_sensor mode takes it without running
+        actions, and event mode ignores it, because a lone ``pressed`` with no
+        release would turn into a long press.
+
         Args:
             _topic: The topic it arrived on; unused, one subscription per input.
             payload: The message.
+            retained: The broker is replaying its stored copy, not forwarding
+                a live message.
         """
         text = (payload or "").strip()
 
+        if retained and self._mode == "event":
+            _LOGGER.debug("Input %s: ignoring retained message in event mode", self.id)
+            return
+
         if text.startswith("{"):
             try:
                 event_type = json.loads(text).get("event_type")
@@ -145,4 +157,4 @@ class MqttBinarySensorInput(RemoteInputBase):
         if self._mode == "event":
             self._feed_detector(is_pressed=state)
         else:
-            self._handle_binary_state_change(state)
+            self._handle_binary_state_change(state, publish_only=retained)

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/cloud/registration.py

@@ -524,10 +524,10 @@ class CloudRegistration:
     def _check_compose_ownership(self) -> bool:
         """Check the compose file is managed by the privileged helper.
 
-        This used to check the opposite — that the file was *writable* — and its
-        error message told the operator to ``sudo chown $USER`` it. That advice
-        reopens F-04: ``docker compose up`` executes this file, so whoever can
-        write it can start a container as root with the host filesystem mounted.
+        The file must *not* be writable by the application, and no error here
+        should tell the operator to ``chown`` it: ``docker compose up`` executes
+        this file, so whoever can write it can start a container as root with
+        the host filesystem mounted.
 
         Returns:
             True when the cloud switch can proceed.

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/config/secret_masking.py

@@ -1,7 +1,7 @@
-"""Keep configured secrets out of API responses (F-03).
+"""Keep configured secrets out of API responses.
 
-``GET /api/config`` returned the MQTT password, and any other password in the
-configuration, in clear text. Masking it is only half the job: the settings
+Unmasked, ``GET /api/config`` would return the MQTT password, and any other
+password in the configuration, in clear text. Masking it is only half the job: the settings
 forms are populated from that same response and post the whole section back, so
 a mask that is written straight through would overwrite the real password with
 its own placeholder the first time anyone saved an unrelated field.

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/containers.py

@@ -1,17 +1,16 @@
 """Container operations, through the privileged helper when it is there.
 
-The application talks to Docker today because the ``boneio`` account is in the
-``docker`` group — which is root-equivalent, since a container can bind-mount
-the host root and write to it. Taking the account out of that group is the fix
-(F-04), and this module is what makes it possible: every container operation
-goes through ``boneio-containers``, which accepts a fixed verb and passes
-nothing from the caller to Docker.
+The ``boneio`` account is kept out of the ``docker`` group, because that group
+is root-equivalent: a container can bind-mount the host root and write to it.
+Every container operation goes through ``boneio-containers`` instead, which
+accepts a fixed verb and passes nothing from the caller to Docker. Nothing else
+in the application should call ``docker``; it comes through here.
 
 Direct ``docker`` invocation stays as a fallback while the helper is not
-installed. That is not a loophole, it is the transition: a device that has not
-applied the trust-transition migration yet is in exactly the state it is in
-today, and refusing to manage its containers would break Node-RED and the TLS
-panel for no gain. Once the helper is present it is always preferred, and once
+installed. That is not a loophole: a device that has not applied the
+trust-transition migration yet still has the account in the ``docker`` group,
+and refusing to manage its containers would break Node-RED and the TLS panel
+for no gain. Once the helper is present it is always preferred, and once
 the account leaves the ``docker`` group the fallback stops working on its own.
 
 Nothing here is a security boundary. The boundary is the helper, which refuses
@@ -466,9 +465,9 @@ def set_project_env(name: str, value: str) -> bool:
     the compose file, which is how the panel's own port reaches Caddy. The
     application may write this file: the directory belongs to it. It may not
     write the compose file beside it, which is root-owned because
-    ``docker compose up`` executes it — that distinction is F-04, and it holds
-    here because interpolation substitutes into scalar values after the YAML is
-    parsed, so nothing passed this way can introduce a volume or an entrypoint.
+    ``docker compose up`` executes it. Writing ``.env`` does not undo that:
+    interpolation substitutes into scalar values after the YAML is parsed, so
+    nothing passed this way can introduce a volume or an entrypoint.
 
     Read-modify-write rather than truncate: an operator may have put their own
     variables here, and a port change is no reason to lose them. Comments and

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/manager/covers.py

@@ -168,8 +168,9 @@ class CoverManager:
                         _cover._open_relay = open_relay
                         _cover._close_relay = close_relay
                         _cover.update_config_times(_config)
+                        self._store_ha_attributes(_cover, _config)
                         # Re-send HA autodiscovery with potentially new name/area
-                        if _config.get(SHOW_HA, True):
+                        if _cover.show_in_ha:
                             # Remove old autodiscovery first (in case area changed)
                             self._remove_cover_ha_discovery(_id)
                             # Send new autodiscovery
@@ -181,8 +182,8 @@ class CoverManager:
                                 id=_cover.id,
                                 name=_cover.name,
                                 config_helper=self._manager._config_helper,
-                                device_class=_config.get(DEVICE_CLASS),
-                                area=_config.get("area"),
+                                device_class=_cover.device_class,
+                                area=_cover.area,
                             )
                             self._manager.publish_ha_discovery(
                                 id=_cover.id,
@@ -375,14 +376,16 @@ class CoverManager:
             )
             availability_msg_func = ha_cover_availabilty_message
 
+        self._store_ha_attributes(cover, config)
+
         # Send HA autodiscovery
-        if config.get(SHOW_HA, True):
+        if cover.show_in_ha:
             payload = availability_msg_func(
                 id=cover.id,
                 name=cover.name,
                 config_helper=self._manager._config_helper,
-                device_class=config.get(DEVICE_CLASS),
-                area=config.get("area"),
+                device_class=cover.device_class,
+                area=cover.area,
             )
             self._manager.publish_ha_discovery(
                 id=cover.id,
@@ -393,6 +396,20 @@ class CoverManager:
         _LOGGER.debug("Configured cover %s", cover_id)
         return cover
 
+    @staticmethod
+    def _store_ha_attributes(cover: TimeBasedCover | VenetianCover, config: dict) -> None:
+        """Keep the HA discovery inputs on the cover itself.
+
+        The cover classes don't take ``area``/``device_class`` (``area`` is
+        swallowed by ``BasicMqtt``'s kwargs), yet ``send_ha_autodiscovery``
+        rebuilds the payload from the cover object. Without these the rebuild
+        would drop the area sub-device and the device class, and HA would move
+        the cover back to the main device with the default class.
+        """
+        cover.area = config.get("area")
+        cover.device_class = config.get(DEVICE_CLASS)
+        cover.show_in_ha = config.get(SHOW_HA, True)
+
     def _remove_cover_ha_discovery(self, cover_id: str) -> None:
         """Remove HA Discovery entries for a cover.
 
@@ -508,6 +525,8 @@ class CoverManager:
     async def send_ha_autodiscovery(self) -> None:
         """Send Home Assistant autodiscovery for all covers."""
         for cover_id, cover in self._covers.items():
+            if not cover.show_in_ha:
+                continue
             # Use tilt variant if cover supports tilt
             if hasattr(cover, "tilt_position"):
                 msg_func = ha_cover_with_tilt_availabilty_message
@@ -517,8 +536,8 @@ class CoverManager:
                 id=cover_id,
                 name=cover.name if hasattr(cover, "name") else cover_id,
                 config_helper=self._manager._config_helper,
-                device_class=getattr(cover, "device_class", None),
-                area=getattr(cover, "area", None),
+                device_class=cover.device_class,
+                area=cover.area,
             )
             self._manager.publish_ha_discovery(
                 id=cover_id,

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/manager/inputs.py

@@ -277,6 +277,7 @@ class InputManager:
 
                 # Store area on input
                 existing_input.area = area
+                existing_input.show_in_ha = gpio.get(SHOW_HA, True)
 
                 # Update device_class from new config
                 existing_input._device_class = gpio.get(DEVICE_CLASS)
@@ -327,6 +328,7 @@ class InputManager:
 
             # Store area on input
             input_device.area = area
+            input_device.show_in_ha = gpio.get(SHOW_HA, True)
 
             # Register with Home Assistant
             if gpio.get(SHOW_HA, True):
@@ -407,6 +409,7 @@ class InputManager:
 
                 # Store area on input
                 existing_input.area = area
+                existing_input.show_in_ha = gpio.get(SHOW_HA, True)
 
                 # Update device_class from new config
                 existing_input._device_class = gpio.get(DEVICE_CLASS)
@@ -453,6 +456,7 @@ class InputManager:
 
             # Store area on input
             input_device.area = area
+            input_device.show_in_ha = gpio.get(SHOW_HA, True)
 
             # Register with Home Assistant
             if gpio.get(SHOW_HA, True):
@@ -624,6 +628,20 @@ class InputManager:
         # Global listeners will receive these events for all inputs (including new ones)
         self._broadcast_all_input_states()
 
+    def resend_binary_sensor_states(self) -> None:
+        """Publish the pin state of every GPIO binary sensor, MQTT only.
+
+        Called on each MQTT connect. The topics are retained, and nothing else
+        corrects the broker's copy when an input changed while boneIO was off.
+        Actions do not run: these are ``publish_only`` events.
+        """
+        for input_ in self._inputs.values():
+            if isinstance(input_, GpioInputBinarySensor):
+                try:
+                    input_.send_current_state_when_ready()
+                except Exception as e:
+                    _LOGGER.debug("Error resending binary sensor state %s: %s", input_.id, e)
+
     def _broadcast_all_input_states(self) -> None:
         """Broadcast current state of all inputs via WebSocket.
 
@@ -766,9 +784,14 @@ class InputManager:
         elif input_type == INPUT_SENSOR:
             payload = str(click_type)  # "pressed" or "released"
 
+            # Retained: a float switch can hold one position for weeks, and
+            # without the broker's copy HA shows `unknown` after every restart
+            # until the input moves. Events above stay unretained — a click
+            # replayed on subscribe would be a click that never happened.
             self._manager.send_message(
                 topic=topic,
                 payload=payload,
+                retain=True,
             )
             _LOGGER.debug("Published binary sensor state to MQTT: topic=%s, payload=%s", topic, payload)
 
@@ -930,6 +953,8 @@ class InputManager:
         but can be called manually if needed.
         """
         for pin, input_device in self._inputs.items():
+            if not getattr(input_device, "show_in_ha", True):
+                continue
             try:
                 input_id = input_device.id if hasattr(input_device, "id") else pin
                 input_name = input_device.name if hasattr(input_device, "name") else input_id

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/manager/manager.py

@@ -618,6 +618,7 @@ class Manager:
                         self.send_message(
                             topic=f"{topic_prefix}/input/{input_id}",
                             payload=state,
+                            retain=True,
                         )
                 except Exception as e:
                     _LOGGER.debug(
@@ -2005,6 +2006,11 @@ class Manager:
         # trusts, and a reinstalled broker comes back with no retained set.
         await self.virtual_switches.republish_states()
 
+        # Binary sensors are retained, so the broker would otherwise keep
+        # serving whatever they were before this boot, however long ago that
+        # was. Read the pins and publish what is true now.
+        self.inputs.resend_binary_sensor_states()
+
         _LOGGER.info(
             "Resent states: %d outputs, %d covers.",
             len([o for o in self.outputs.get_all_outputs().values() if o.output_type not in ("cover", "none")]),

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/manager/outputs.py

@@ -962,6 +962,9 @@ class OutputManager:
         """Send Home Assistant autodiscovery for all outputs and groups."""
         # Send autodiscovery for outputs
         for output_id, output in self._outputs.items():
+            # Remote outputs are published only when show_in_ha is set
+            if not getattr(output, "show_in_ha", True):
+                continue
             if output.output_type not in (NONE, COVER):
                 ha_func = _OUTPUT_HA_FUNC.get(output.output_type, ha_switch_availabilty_message)
                 payload = ha_func(
@@ -1002,6 +1005,7 @@ class OutputManager:
                 name=group.name if hasattr(group, 'name') else group_id,
                 config_helper=self._manager._config_helper,
                 output_type=group.output_type,
+                area=getattr(group, 'area', None),
                 member_unique_ids=member_unique_ids,
             )
             self._manager.publish_ha_discovery(

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/manager/remote_input_registrar.py

@@ -117,7 +117,7 @@ class RemoteInputRegistrar:
         for remote_input in self._mqtt_inputs:
             try:
                 await self._manager.message_bus.subscribe_and_listen(
-                    remote_input.topic, remote_input.on_mqtt_message
+                    remote_input.topic, remote_input.on_mqtt_message, retain_aware=True
                 )
                 _LOGGER.debug(
                     "Remote input '%s' listening on %s",

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/manager/sensors.py

@@ -491,13 +491,15 @@ class SensorManager:
                 update_interval=sensor_config.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
                 filters=sensor_config.get(FILTERS, []),
             )
-            if sensor_config.get(SHOW_HA, True):
+            sensor.area = sensor_config.get("area")
+            sensor.show_in_ha = sensor_config.get(SHOW_HA, True)
+            if sensor.show_in_ha:
                 payload = ha_sensor_temp_availabilty_message(
                     id=sensor.id,
                     name=sensor.name,
                     config_helper=self._manager._config_helper,
                     unit_of_measurement=sensor_config.get("unit_of_measurement", "°C"),
-                    area=sensor_config.get("area"),
+                    area=sensor.area,
                 )
                 self._manager.publish_ha_discovery(id=sensor.id, ha_type=SENSOR, payload=payload)
             return sensor
@@ -569,12 +571,14 @@ class SensorManager:
                 update_interval=gpio.get(UPDATE_INTERVAL, TimePeriod(seconds=60)),
                 filters=gpio.get(FILTERS, []),
             )
-            if gpio.get(SHOW_HA, True):
+            sensor.area = gpio.get("area")
+            sensor.show_in_ha = gpio.get(SHOW_HA, True)
+            if sensor.show_in_ha:
                 payload = ha_adc_sensor_availabilty_message(
                     id=id,
                     name=name,
                     config_helper=self._manager._config_helper,
-                    area=gpio.get("area"),
+                    area=sensor.area,
                 )
                 self._manager.publish_ha_discovery(id=id, ha_type=SENSOR, payload=payload)
             return sensor
@@ -699,14 +703,17 @@ class SensorManager:
                         if new_interval:
                             sensor._update_interval = new_interval
 
+                        sensor.area = sensor_config.get("area")
+                        sensor.show_in_ha = sensor_config.get(SHOW_HA, True)
+
                         # Resend HA autodiscovery with updated info
-                        if sensor_config.get(SHOW_HA, True):
+                        if sensor.show_in_ha:
                             payload = ha_sensor_temp_availabilty_message(
                                 id=sensor.id,
                                 name=sensor.name,
                                 config_helper=self._manager._config_helper,
                                 unit_of_measurement=sensor_config.get("unit_of_measurement", "°C"),
-                                area=sensor_config.get("area"),
+                                area=sensor.area,
                             )
                             self._manager.publish_ha_discovery(id=sensor.id, ha_type=SENSOR, payload=payload)
                         break
@@ -842,13 +849,16 @@ class SensorManager:
                         if new_interval:
                             sensor._update_interval = new_interval
 
+                        sensor.area = sensor_config.get("area")
+                        sensor.show_in_ha = sensor_config.get(SHOW_HA, True)
+
                         # Resend HA autodiscovery with updated info
-                        if sensor_config.get(SHOW_HA, True):
+                        if sensor.show_in_ha:
                             payload = ha_adc_sensor_availabilty_message(
                                 id=sensor.id,
                                 name=new_name,
                                 config_helper=self._manager._config_helper,
-                                area=sensor_config.get("area"),
+                                area=sensor.area,
                             )
                             self._manager.publish_ha_discovery(id=sensor.id, ha_type=SENSOR, payload=payload)
                         break
@@ -1549,20 +1559,26 @@ class SensorManager:
 
         # Dallas 1-Wire sensors
         for sensor in self._dallas_sensors:
+            if not sensor.show_in_ha:
+                continue
             payload = ha_sensor_temp_availabilty_message(
                 id=sensor.id,
                 name=sensor.name,
                 config_helper=self._manager._config_helper,
                 unit_of_measurement=getattr(sensor, "unit_of_measurement", "°C"),
+                area=sensor.area,
             )
             self._manager.publish_ha_discovery(id=sensor.id, ha_type=SENSOR, payload=payload)
 
         # ADC sensors
         for sensor in self._adc_sensors:
+            if not sensor.show_in_ha:
+                continue
             payload = ha_adc_sensor_availabilty_message(
                 id=sensor.id,
                 name=sensor.name,
                 config_helper=self._manager._config_helper,
+                area=sensor.area,
             )
             self._manager.publish_ha_discovery(id=sensor.id, ha_type=SENSOR, payload=payload)
 

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/messaging/basic.py

@@ -55,8 +55,22 @@ class MessageBus(ABC):
         pass
 
     @abstractmethod
-    async def subscribe_and_listen(self, topic: str, callback: Callable[[str, str], Awaitable[None]]) -> None:
-        """Subscribe to a topic and listen for messages."""
+    async def subscribe_and_listen(
+        self,
+        topic: str,
+        callback: Callable[..., Awaitable[None]],
+        *,
+        retain_aware: bool = False,
+    ) -> None:
+        """Subscribe to a topic and listen for messages.
+
+        Args:
+            topic: Topic to subscribe to.
+            callback: Called as ``callback(topic, payload)``.
+            retain_aware: Also pass ``retained=`` — True when the broker is
+                replaying a stored message on subscribe rather than forwarding
+                a live one. Buses without retained messages always pass False.
+        """
         pass
 
     @abstractmethod

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/messaging/composite.py

@@ -82,10 +82,16 @@ class CompositeMessageBus(MessageBus):
         if tasks:
             await asyncio.gather(*tasks, return_exceptions=True)
 
-    async def subscribe_and_listen(self, topic: str, callback: Callable[[str, str], Awaitable[None]]) -> None:
+    async def subscribe_and_listen(
+        self,
+        topic: str,
+        callback: Callable[..., Awaitable[None]],
+        *,
+        retain_aware: bool = False,
+    ) -> None:
         """Subscribe to a topic and listen for messages on all buses."""
         for bus in self._buses:
-            await bus.subscribe_and_listen(topic, callback)
+            await bus.subscribe_and_listen(topic, callback, retain_aware=retain_aware)
 
     async def unsubscribe_and_stop_listen(self, topic: str) -> None:
         """Unsubscribe from a topic and stop listening on all buses."""

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/messaging/local.py

@@ -80,8 +80,18 @@ class LocalMessageBus(MessageBus):
         """Announce that the device is offline."""
         pass
 
-    async def subscribe_and_listen(self, topic: str, callback: Callable[[str, str], None]) -> None:
-        """Subscribe to a topic and listen for messages."""
+    async def subscribe_and_listen(
+        self,
+        topic: str,
+        callback: Callable[..., Any],
+        *,
+        retain_aware: bool = False,
+    ) -> None:
+        """Subscribe to a topic and listen for messages.
+
+        ``retain_aware`` is accepted for the interface and ignored: the callback
+        is called with two arguments, so ``retained`` keeps its default.
+        """
         await self.subscribe(topic, callback)
 
     async def unsubscribe_and_stop_listen(self, topic: str) -> None:

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/messaging/lox.py

@@ -388,8 +388,14 @@ class LoxUDPClient(MessageBus):
         if self._transport:
             self._transport.sendto(b"boneio=offline", (self.host, self.send_port))
 
-    async def subscribe_and_listen(self, topic: str, callback: Callable[[str, str], Coroutine[Any, Any, None]]) -> None:
-        """Register a listener for a topic pattern."""
+    async def subscribe_and_listen(
+        self,
+        topic: str,
+        callback: Callable[..., Coroutine[Any, Any, None]],
+        *,
+        retain_aware: bool = False,
+    ) -> None:
+        """Register a listener for a topic pattern. Lox has no retained messages."""
         self._listeners[topic] = callback
 
     async def unsubscribe_and_stop_listen(self, topic: str) -> None:

{boneio-1.6.0.dev23 → boneio-1.6.0.dev25}/boneio/core/messaging/mqtt.py

@@ -56,7 +56,9 @@ class MQTTClient(MessageBus):
         self.reconnect_interval = 1
         self._connection_established = False
         self.publish_queue: UniqueQueue = UniqueQueue()
-        self._mqtt_energy_listeners: dict[str, Callable[[str, str], Awaitable[None]]] = {}
+        self._mqtt_energy_listeners: dict[str, Callable[..., Awaitable[None]]] = {}
+        # Listeners that are told whether a message is a retained replay.
+        self._retain_aware_listeners: set[str] = set()
         self._discovery_topics = (
             [
                 f"{self._config_helper.ha_discovery_prefix}/{ha_type}/{self._config_helper.serial_number}/#"
@@ -144,8 +146,18 @@ class MQTTClient(MessageBus):
         )
 
     @override
-    async def subscribe_and_listen(self, topic: str, callback: Callable[[str, str], Awaitable[None]]) -> None:
+    async def subscribe_and_listen(
+        self,
+        topic: str,
+        callback: Callable[..., Awaitable[None]],
+        *,
+        retain_aware: bool = False,
+    ) -> None:
         self._mqtt_energy_listeners[topic] = callback
+        if retain_aware:
+            self._retain_aware_listeners.add(topic)
+        else:
+            self._retain_aware_listeners.discard(topic)
         # Subscribe immediately if already connected
         if self._connection_established:
             await self.subscribe(topics=[topic])
@@ -154,6 +166,7 @@ class MQTTClient(MessageBus):
     async def unsubscribe_and_stop_listen(self, topic: str) -> None:
         await self.unsubscribe([topic])
         del self._mqtt_energy_listeners[topic]
+        self._retain_aware_listeners.discard(topic)
 
     async def unsubscribe(
         self,
@@ -439,7 +452,14 @@ class MQTTClient(MessageBus):
                 if message.topic.matches(topic):
                     callback_start = False
                     try:
-                        await listener_callback(str(message.topic), payload)
+                        if topic in self._retain_aware_listeners:
+                            # v3.1.1: the broker sets retain only when replaying
+                            # its stored copy on subscribe, never on live ones.
+                            await listener_callback(
+                                str(message.topic), payload, retained=bool(message.retain)
+                            )
+                        else:
+                            await listener_callback(str(message.topic), payload)
                     except Exception as exc:
                         _LOGGER.error(
                             "Error in MQTT listener callback for topic %s: %s",