boneio 1.6.0.dev25__tar.gz → 1.6.0.dev26__tar.gz

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

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

{boneio-1.6.0.dev25 → boneio-1.6.0.dev26}/boneio/components/cover/cover.py

@@ -532,6 +532,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             kind=self.kind,
             timestamp=self._last_timestamp,
             current_operation=self._current_operation,
+            area=getattr(self, "area", None),
             **json_position,
         )
         self._event_bus.trigger_event(CoverEvent(entity_id=self.id, state=event))

{boneio-1.6.0.dev25 → boneio-1.6.0.dev26}/boneio/components/cover/remote.py

@@ -203,6 +203,7 @@ class RemoteCoverOutput:
             current_operation=self._current_operation,
             position=self._position,
             tilt=self._tilt,
+            area=self.area,
         )
         self._event_bus.trigger_event(CoverEvent(entity_id=self._id, state=event))
 

{boneio-1.6.0.dev25 → boneio-1.6.0.dev26}/boneio/components/group/output_group.py

@@ -141,6 +141,7 @@ class OutputGroup(BasicOutput):
             state=self._state,
             type=self._output_type,
             timestamp=self._last_timestamp,
+            area=getattr(self, "area", None),
         )
         group_event = GroupEvent(
             entity_id=self.id,

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

@@ -10,6 +10,7 @@ from boneio.components.input.detectors import BinarySensorDetector
 from boneio.const import PRESSED, RELEASED, BinaryStateTypes, ClickTypes
 from boneio.core.utils.timeperiod import parse_time_to_ms
 from boneio.hardware.gpio.input import GpioBaseClass, get_gpio_manager
+from boneio.hardware.gpio.input.base import warn_if_bounce_too_long
 from boneio.models import InputState
 from boneio.models.events import InputEvent
 
@@ -125,6 +126,7 @@ class GpioInputBinarySensor(GpioBaseClass):
             self._pin,
             seconds * 1000,
         )
+        warn_if_bounce_too_long(seconds, self._name, self._pin)
         return True
 
     def _send_initial_state(self) -> None:

{boneio-1.6.0.dev25 → boneio-1.6.0.dev26}/boneio/components/input/event.py

@@ -9,6 +9,7 @@ from boneio.components.input.detectors import MultiClickDetector
 from boneio.const import ClickTypes
 from boneio.core.utils.timeperiod import parse_time_to_ms
 from boneio.hardware.gpio.input import GpioBaseClass, get_gpio_manager
+from boneio.hardware.gpio.input.base import warn_if_bounce_too_long
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -282,3 +283,4 @@ class GpioEventButton(GpioBaseClass):
                 self._pin,
                 seconds * 1000,
             )
+            warn_if_bounce_too_long(seconds, self._name, self._pin)

{boneio-1.6.0.dev25 → boneio-1.6.0.dev26}/boneio/components/output/remote.py

@@ -740,6 +740,11 @@ class RemoteOutputBase:
         """Whether this is a remote output — always True."""
         return True
 
+    @property
+    def interlock_groups(self) -> list[str]:
+        """Interlock groups this output belongs to."""
+        return self._interlock_groups
+
     # ------------------------------------------------------------------
     # Adjustable duration stubs (remote outputs don't support this)
     # ------------------------------------------------------------------

{boneio-1.6.0.dev25 → boneio-1.6.0.dev26}/boneio/components/sensor/virtual_energy.py

@@ -11,6 +11,7 @@ import asyncio
 import json
 import logging
 import time
+from collections.abc import Callable
 from typing import TYPE_CHECKING
 
 from boneio.const import ON
@@ -131,6 +132,17 @@ class VirtualEnergySensor:
         """Get timestamp when output was last turned ON."""
         return self._last_on_timestamp
 
+    def rebind_output(self, resolve: Callable[[BasicOutput], BasicOutput]) -> None:
+        """Swap the tracked output for the one registered now under its id.
+
+        Tracking reads the output's state; after an output reload the old
+        object's state no longer changes, so nothing was counted.
+
+        Args:
+            resolve: Maps the held output to the current one.
+        """
+        self._output = resolve(self._output)
+
     def start_tracking(self):
         """Start tracking consumption (called when output turns ON)."""
         self._last_on_timestamp = time.time()

{boneio-1.6.0.dev25 → boneio-1.6.0.dev26}/boneio/components/template/alarm_panel.py

@@ -15,6 +15,7 @@ import hmac
 import json
 import logging
 import time
+from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 from boneio.const import ALARM_CONTROL_PANEL, STATE
@@ -916,6 +917,15 @@ class BoneIOAlarmPanel:
             self._publish_code_lock(False)
         _LOGGER.info("Alarm panel %s started", self._id)
 
+    def rebind_outputs(self, resolve: Callable[[Any], Any]) -> None:
+        """Swap each alarm output for the one registered now under its id.
+
+        Args:
+            resolve: Maps a held output to the current one.
+        """
+        for alarm_output in self._outputs:
+            alarm_output.output = resolve(alarm_output.output)
+
     async def stop(self) -> None:
         """Stop alarm panel — cancel timers and unsubscribe."""
         self._cancel_all_timers()

{boneio-1.6.0.dev25 → boneio-1.6.0.dev26}/boneio/components/template/gate_cover.py

@@ -35,6 +35,7 @@ import asyncio
 import contextlib
 import json
 import logging
+from collections.abc import Callable
 from typing import TYPE_CHECKING
 
 from boneio.const import (
@@ -200,6 +201,19 @@ class BoneIOGateCover:
         self._publish_state()
         _LOGGER.info("GateCover %s started (state=%s), subscribed to %s", self._id, self._state, self._cmd_topic)
 
+    def rebind_outputs(self, resolve: Callable[[BasicOutput | None], BasicOutput | None]) -> None:
+        """Swap the relays for the ones registered now under their ids.
+
+        A pulse already timed keeps the relay its off-timer captured.
+
+        Args:
+            resolve: Maps a held output to the current one; None stays None.
+        """
+        self._pulse_output = resolve(self._pulse_output)
+        self._open_output = resolve(self._open_output)
+        self._close_output = resolve(self._close_output)
+        self._stop_output = resolve(self._stop_output)
+
     async def stop(self) -> None:
         """Unsubscribe from MQTT and cancel timers."""
         self._cancel_pulse_timer()

{boneio-1.6.0.dev25 → boneio-1.6.0.dev26}/boneio/components/template/thermostat.py

@@ -12,6 +12,7 @@ import asyncio
 import json
 import logging
 import time
+from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 from boneio.const import CLIMATE, OFF, ON, SENSOR, STATE
@@ -302,6 +303,15 @@ class BoneIOThermostat:
         self._publish_state()
         _LOGGER.info("Thermostat %s started", self._id)
 
+    def rebind_outputs(self, resolve: Callable[[Any], Any]) -> None:
+        """Swap the controlled output for the one registered now under its id.
+
+        Args:
+            resolve: Maps the held object to the current one (an output reload
+                rebuilds outputs and groups as new objects).
+        """
+        self._output = resolve(self._output)
+
     async def stop(self) -> None:
         """Stop MQTT command subscriptions."""
         try:

{boneio-1.6.0.dev25 → boneio-1.6.0.dev26}/boneio/const.py

@@ -88,6 +88,9 @@ TRIPLE = "triple"
 LONG = "long"
 PRESSED = "pressed"
 RELEASED = "released"
+# Longest GPIO debounce the panel accepts. Past this a press feels lost; a
+# longer value already in a config still loads, with a warning in the log.
+BOUNCE_TIME_MAX_MS = 1000
 
 
 # MQTT CONST

{boneio-1.6.0.dev25 → boneio-1.6.0.dev26}/boneio/core/config/config_helper.py

@@ -4,7 +4,6 @@ Module to provide basic config options.
 from __future__ import annotations
 
 import logging
-from _collections_abc import dict_values
 from typing import TYPE_CHECKING, Any
 import time as _time
 
@@ -414,6 +413,18 @@ class ConfigHelper:
         """Add autodiscovery message."""
         self._autodiscovery_messages[ha_type][topic] = {"topic": topic, "payload": payload}
 
+    def reserve_autodiscovery_msg(self, ha_type: str, topic: str) -> None:
+        """Claim the topic of an entity that is configured but not announced yet.
+
+        A reserved topic counts as in use, so a retained config left on it
+        from an earlier run is not removed, but it is not resent until
+        add_autodiscovery_msg gives it a payload. Reserving a topic that
+        already has one changes nothing.
+        """
+        self._autodiscovery_messages[ha_type].setdefault(
+            topic, {"topic": topic, "payload": None}
+        )
+
     @property
     def ha_types(self) -> list[str]:
         return list(self._autodiscovery_messages.keys())
@@ -574,9 +585,11 @@ class ConfigHelper:
 
 
     @property
-    def autodiscovery_msgs(self) -> dict_values:
-        """Get autodiscovery messages"""
-        output = {}
-        for ha_type in self._autodiscovery_messages:
-            output.update(self._autodiscovery_messages[ha_type])
-        return output.values()
+    def autodiscovery_msgs(self) -> list[dict[str, Any]]:
+        """Get autodiscovery messages, leaving out topics only reserved."""
+        return [
+            msg
+            for messages in self._autodiscovery_messages.values()
+            for msg in messages.values()
+            if msg["payload"] is not None
+        ]

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

@@ -68,7 +68,9 @@ class CoverManager:
             # Get config from ConfigHelper (already reloaded by Manager)
             config = self._manager._config_helper.get_config()
             self._config_covers = config.get(COVER, [])
-            self._manager._config_helper.clear_autodiscovery_type(ha_type=COVER)
+            # The discovery cache is not cleared: COVER is shared with gate
+            # covers and remote covers, and the MQTT client deletes from HA
+            # any discovery topic it sees that the cache does not hold.
 
             # Remove covers that are no longer in config
             new_ids = set()
@@ -80,26 +82,16 @@ class CoverManager:
                     _close = str(_cfg.get("close_relay", ""))
                     new_ids.add(f"cover_{_open}_{_close}".lower().replace(" ", "_"))
 
-            removed_ids = [cid for cid in self._covers if cid not in new_ids]
+            # Remote covers are not in this section; they have their own reload.
+            removed_ids = [
+                cid
+                for cid, cover in self._covers.items()
+                if cid not in new_ids and not getattr(cover, "is_remote", False)
+            ]
             for cid in removed_ids:
                 _LOGGER.info("Cover %s removed from config, cleaning up", cid)
                 cover = self._covers.pop(cid)
-                # Stop cover movement if running (synchronous - no running loop guaranteed)
-                try:
-                    if hasattr(cover, "_stop_event"):
-                        cover._stop_event.set()
-                    if (
-                        hasattr(cover, "_movement_thread")
-                        and cover._movement_thread
-                        and cover._movement_thread.is_alive()
-                    ):
-                        cover._movement_thread.join(timeout=1.0)
-                    if hasattr(cover, "_open_relay"):
-                        cover._open_relay.turn_off()
-                    if hasattr(cover, "_close_relay"):
-                        cover._close_relay.turn_off()
-                except Exception:
-                    pass
+                self._halt_cover(cover)
                 # Remove HA autodiscovery
                 self._remove_cover_ha_discovery(cid)
 
@@ -144,6 +136,9 @@ class CoverManager:
                         _LOGGER.info(
                             "Cover %s platform changed from %s to %s, recreating cover", _id, current_kind, new_kind
                         )
+                        # The old object goes away: a movement it was running
+                        # would otherwise keep its relay energised.
+                        self._halt_cover(_cover)
                         # Remove old HA autodiscovery
                         self._remove_cover_ha_discovery(_id)
                         # Remove old cover from dict (will be recreated below)
@@ -168,11 +163,18 @@ class CoverManager:
                         _cover._open_relay = open_relay
                         _cover._close_relay = close_relay
                         _cover.update_config_times(_config)
+                        was_shown = _cover.show_in_ha
+                        old_area = _cover.area
                         self._store_ha_attributes(_cover, _config)
+                        if was_shown and not _cover.show_in_ha:
+                            self._remove_cover_ha_discovery(_id)
                         # Re-send HA autodiscovery with potentially new name/area
                         if _cover.show_in_ha:
-                            # Remove old autodiscovery first (in case area changed)
-                            self._remove_cover_ha_discovery(_id)
+                            # A new area is a new HA device: take the entity off
+                            # the old one first. Otherwise update in place — a
+                            # removal makes HA delete the entity and recreate it.
+                            if was_shown and old_area != _cover.area:
+                                self._remove_cover_ha_discovery(_id)
                             # Send new autodiscovery
                             if new_platform == "venetian":
                                 availability_msg_func = ha_cover_with_tilt_availabilty_message
@@ -420,8 +422,12 @@ class CoverManager:
         Args:
             cover_id: ID of the cover to remove from HA Discovery
         """
-        # Find all autodiscovery topics for this cover ID
-        matching_topics = self._manager._config_helper.get_autodiscovery_topics_for_id(cover_id)
+        # Only COVER: another entity type may use the same id.
+        matching_topics = [
+            (ha_type, topic)
+            for ha_type, topic in self._manager._config_helper.get_autodiscovery_topics_for_id(cover_id)
+            if ha_type == COVER
+        ]
 
         for ha_type, topic in matching_topics:
             _LOGGER.debug("Removing HA Discovery for cover %s: %s", cover_id, topic)
@@ -449,6 +455,42 @@ class CoverManager:
         """
         return self._covers
 
+    @staticmethod
+    def _halt_cover(cover: Any) -> None:
+        """Stop a cover that is being dropped and de-energise both relays.
+
+        Synchronous: a reload may run without a usable event loop for the
+        cover's own async stop.
+        """
+        try:
+            if hasattr(cover, "_stop_event"):
+                cover._stop_event.set()
+            if (
+                hasattr(cover, "_movement_thread")
+                and cover._movement_thread
+                and cover._movement_thread.is_alive()
+            ):
+                cover._movement_thread.join(timeout=1.0)
+            if hasattr(cover, "_open_relay"):
+                cover._open_relay.turn_off()
+            if hasattr(cover, "_close_relay"):
+                cover._close_relay.turn_off()
+        except Exception:
+            _LOGGER.exception("Could not stop cover %s", getattr(cover, "id", "?"))
+
+    def rebind_outputs(self) -> None:
+        """Point each cover at the relays registered now under their ids.
+
+        Called after an output reload, which rebuilds the relays as new
+        objects. A movement already running keeps the relay it started with.
+        """
+        outputs = self._manager.outputs
+        for cover in self._covers.values():
+            if getattr(cover, "is_remote", False):
+                continue
+            cover._open_relay = outputs.resolve_current(cover._open_relay)
+            cover._close_relay = outputs.resolve_current(cover._close_relay)
+
     def reload_covers(self) -> None:
         """Reload cover configuration from file.
 

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

@@ -186,8 +186,13 @@ class InputManager:
             if config:
                 self._event_pins = config.get(EVENT_ENTITY, [])
                 self._binary_pins = config.get(BINARY_SENSOR, [])
-                self._manager._config_helper.clear_autodiscovery_type(ha_type=EVENT_ENTITY)
-                self._manager._config_helper.clear_autodiscovery_type(ha_type=BINARY_SENSOR)
+                # The discovery cache is left alone: an input whose HA fields
+                # did not change is not re-published, so its entry must stay.
+                # The MQTT client deletes any discovery topic it receives that
+                # is not in the cache — including the echo of our own publish —
+                # and the cache is shared with entities that are not inputs
+                # (security events, the OLED button). Removed and hidden inputs
+                # take their own entries out.
 
         # Configure event buttons
         for gpio in self._event_pins:
@@ -262,10 +267,12 @@ class InputManager:
                 new_device_class = gpio.get(DEVICE_CLASS)
                 old_mqtt_sequences = existing_input.mqtt_sequences if hasattr(existing_input, "mqtt_sequences") else {}
                 new_mqtt_sequences = gpio.get("mqtt_sequences", {})
+                was_shown = getattr(existing_input, "show_in_ha", True)
                 ha_fields_changed = (
                     (old_name != name) or (old_area != area)
                     or (old_device_class != new_device_class)
                     or (old_mqtt_sequences != new_mqtt_sequences)
+                    or not was_shown
                 )
 
                 # Update actions (always - this is internal to the controller)
@@ -302,7 +309,10 @@ class InputManager:
 
                 # Re-send HA discovery only if HA-relevant fields changed (name, area, mqtt_sequences)
                 # Actions are internal to the controller and don't need HA update
-                if ha_fields_changed and gpio.get(SHOW_HA, True):
+                if not gpio.get(SHOW_HA, True):
+                    if was_shown:
+                        self._unpublish_input_ha_discovery(EVENT_ENTITY, input_id)
+                elif ha_fields_changed:
                     _LOGGER.debug(f"HA-relevant fields changed for {input_id}, re-sending discovery")
                     self._publish_input_ha_discovery(
                         ha_type=EVENT_ENTITY,
@@ -395,9 +405,11 @@ class InputManager:
                 old_area = getattr(existing_input, "area", None)
                 old_device_class = getattr(existing_input, "_device_class", None)
                 new_device_class = gpio.get(DEVICE_CLASS)
+                was_shown = getattr(existing_input, "show_in_ha", True)
                 ha_fields_changed = (
                     (old_name != name) or (old_area != area)
                     or (old_device_class != new_device_class)
+                    or not was_shown
                 )
 
                 # Update actions (always - this is internal to the controller)
@@ -424,7 +436,10 @@ class InputManager:
 
                 # Re-send HA discovery only if HA-relevant fields changed (name, area)
                 # Actions are internal to the controller and don't need HA update
-                if ha_fields_changed and gpio.get(SHOW_HA, True):
+                if not gpio.get(SHOW_HA, True):
+                    if was_shown:
+                        self._unpublish_input_ha_discovery(BINARY_SENSOR, input_id)
+                elif ha_fields_changed:
                     _LOGGER.debug(f"HA-relevant fields changed for {input_id}, re-sending discovery")
                     self._publish_input_ha_discovery(
                         ha_type=BINARY_SENSOR,
@@ -1081,3 +1096,16 @@ class InputManager:
             ha_type=ha_type,
             payload=payload,
         )
+
+    def _unpublish_input_ha_discovery(self, ha_type: str, input_id: str) -> None:
+        """Take an input out of Home Assistant and out of the discovery cache.
+
+        Args:
+            ha_type: HA entity type the input was published as.
+            input_id: Unique input identifier.
+        """
+        config_helper = self._manager._config_helper
+        topic = f"{config_helper.ha_discovery_prefix}/{ha_type}/{config_helper.serial_number}/{input_id}/config"
+        _LOGGER.info("Input %s hidden from HA, removing discovery %s", input_id, topic)
+        self._manager.send_message(topic=topic, payload=None, retain=True)
+        config_helper.remove_autodiscovery_msg(ha_type, topic)

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

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import contextlib
 import logging
+from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Any
 
 from boneio.components.irrigation import IrrigationController, IrrigationZone, WaterSource
@@ -35,6 +36,9 @@ class IrrigationManager:
         self._manager = manager
         self._controllers: dict[str, IrrigationController] = {}
         self._subscribed_topics: set[str] = set()
+        # Who handles each subscribed topic now. A topic is subscribed once,
+        # and its messages go to whatever handler was registered last.
+        self._topic_handlers: dict[str, Callable[[str, str], Awaitable[None]]] = {}
 
         self._initialize(irrigation_config)
 
@@ -224,6 +228,7 @@ class IrrigationManager:
             with contextlib.suppress(Exception):
                 await self._manager.message_bus.unsubscribe_and_stop_listen(topic)
         self._subscribed_topics.clear()
+        self._topic_handlers.clear()
 
         for ctrl in self._controllers.values():
             await ctrl.full_stop()
@@ -250,6 +255,10 @@ class IrrigationManager:
             if ctrl_id:
                 new_ids.add(ctrl_id)
 
+        # Every controller registers its handlers again below; whatever is
+        # left without one afterwards belongs to nothing that exists.
+        self._topic_handlers.clear()
+
         # Stop & remove deleted controllers
         removed_ids = set(self._controllers.keys()) - new_ids
         for ctrl_id in removed_ids:
@@ -288,11 +297,8 @@ class IrrigationManager:
             await ctrl.publish_all_states()
             _LOGGER.info("Reloaded irrigation controller '%s'", ctrl_id)
 
-        # Unsubscribe topics for controllers that no longer exist
-        valid_prefixes = set()
-        for ctrl in self._controllers.values():
-            valid_prefixes.add(f"{ctrl._topic_prefix}/cmd/irrigation/{ctrl.id}")
-        stale_topics = {t for t in self._subscribed_topics if not any(t.startswith(p) for p in valid_prefixes)}
+        # Unsubscribe topics of controllers, zones and schedules that are gone
+        stale_topics = self._subscribed_topics - self._topic_handlers.keys()
         for topic in stale_topics:
             with contextlib.suppress(Exception):
                 await self._manager.message_bus.unsubscribe_and_stop_listen(topic)
@@ -308,9 +314,6 @@ class IrrigationManager:
 
         Sends empty payload to discovery topics to remove entities from HA.
         """
-        cfg = self._manager.config_helper
-        serial = cfg.serial_number
-
         # Build list of discovery IDs to remove
         discovery_ids: list[tuple[str, str]] = [
             (f"{ctrl.id}", "switch"),
@@ -321,7 +324,11 @@ class IrrigationManager:
             (f"{ctrl.id}_pause", "button"),
             (f"{ctrl.id}_resume", "button"),
             (f"{ctrl.id}_event", "event"),
+            (f"{ctrl.id}_zone_end_time", "sensor"),
+            (f"{ctrl.id}_next_run_time", "sensor"),
         ]
+        if len(ctrl.water_sources) > 1:
+            discovery_ids.append((f"{ctrl.id}_water_source", "select"))
         # Multi-zone-only entities
         if len(ctrl.zones) > 1:
             discovery_ids.extend([
@@ -337,17 +344,41 @@ class IrrigationManager:
             discovery_ids.append((f"{ctrl.id}_schedule_{idx}_skip", "switch"))
 
         for disc_id, ha_type in discovery_ids:
-            topic = f"{cfg.ha_discovery_prefix}/{ha_type}/{serial}/{disc_id}/config"
-            self._manager.send_message(topic=topic, payload="", retain=True)
+            self._unpublish_discovery(id=disc_id, ha_type=ha_type)
+
+    def _unpublish_discovery(self, id: str, ha_type: str) -> None:
+        """Take an entity out of Home Assistant and out of the discovery cache.
+
+        Left in the cache, the entity would be announced again whenever Home
+        Assistant comes online, and an empty payload there is resent each time.
+        """
+        cfg = self._manager.config_helper
+        topic = f"{cfg.ha_discovery_prefix}/{ha_type}/{cfg.serial_number}/{id}/config"
+        self._manager.send_message(topic=topic, payload="", retain=True)
+        cfg.remove_autodiscovery_msg(ha_type, topic)
+
+    async def _subscribe_topic(self, topic: str, handler: Callable[[str, str], Awaitable[None]]) -> None:
+        """Route a command topic to handler, replacing any handler it had.
 
-    async def _subscribe_topic(self, topic: str, handler) -> None:
+        A reload rebuilds controllers with the ids they had, on the same
+        topics; the subscription stays and the new controller's handler takes
+        the messages from then on.
+        """
+        self._topic_handlers[topic] = handler
         if topic in self._subscribed_topics:
-            _LOGGER.debug("Irrigation: topic already subscribed: %s", topic)
             return
         _LOGGER.debug("Irrigation: subscribing to MQTT topic: %s → handler=%s", topic, handler.__name__)
-        await self._manager.message_bus.subscribe_and_listen(topic, handler)
+        await self._manager.message_bus.subscribe_and_listen(topic, self._dispatch)
         self._subscribed_topics.add(topic)
 
+    async def _dispatch(self, topic: str, payload: str) -> None:
+        handler = self._topic_handlers.get(topic)
+        if handler is None:
+            # Between a reload dropping the old handlers and registering new ones.
+            _LOGGER.debug("Irrigation: no handler for %s, dropping command", topic)
+            return
+        await handler(topic, payload)
+
     async def _subscribe_controller(self, ctrl: IrrigationController) -> None:
         async def handle_main(_topic: str, payload: str, _ctrl: IrrigationController = ctrl) -> None:
             await _ctrl.handle_main_command(payload)
@@ -570,11 +601,7 @@ class IrrigationManager:
 
         for zone in ctrl.zones:
             # Remove stale switch discovery (migration from switch → valve)
-            self._manager.publish_ha_discovery(
-                id=f"{ctrl.id}_zone_{zone.id}",
-                ha_type="switch",
-                payload="",
-            )
+            self._unpublish_discovery(id=f"{ctrl.id}_zone_{zone.id}", ha_type="switch")
             _pub(
                 id=f"{ctrl.id}_zone_{zone.id}",
                 ha_type="valve",
@@ -621,10 +648,8 @@ class IrrigationManager:
 
             # Remove stale per-zone next_run sensor (migrated to valve attributes)
             if zone.run_every_n > 1:
-                self._manager.publish_ha_discovery(
-                    id=f"{ctrl.id}_zone_{zone.id}_next_run",
-                    ha_type="sensor",
-                    payload="",
+                self._unpublish_discovery(
+                    id=f"{ctrl.id}_zone_{zone.id}_next_run", ha_type="sensor"
                 )
 
         for idx, _schedule in enumerate(ctrl._schedule):
@@ -690,3 +715,17 @@ class IrrigationManager:
                 config_helper=cfg,
             ),
         )
+
+    def rebind_outputs(self) -> None:
+        """Point zones and water sources at the outputs registered now.
+
+        Called after an output reload, which rebuilds outputs as new objects.
+        Unlike reload_irrigation it stops nothing: a running cycle carries on
+        with the current valves.
+        """
+        outputs = self._manager.outputs
+        for ctrl in self._controllers.values():
+            for zone in ctrl.zones:
+                zone.valve = outputs.resolve_current(zone.valve)
+            for water_source in ctrl.water_sources:
+                water_source.outputs[:] = [outputs.resolve_current(o) for o in water_source.outputs]

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

@@ -520,6 +520,7 @@ class Manager:
         _LOGGER.info("Sending HA autodiscovery messages")
 
         await self.outputs.send_ha_autodiscovery()
+        self.virtual_switches.publish_discovery()
         await self.inputs.send_ha_autodiscovery()
         await self.covers.send_ha_autodiscovery()
         await self.sensors.send_ha_autodiscovery()
@@ -1427,7 +1428,7 @@ class Manager:
     async def _reload_mqtt_credentials(self) -> None:
         """Adopt new broker credentials without a restart.
 
-        Host, port, username and password only. The rest of the mqtt section —
+        Host, port, username, password and TLS only. The rest of the mqtt section —
         the topic prefix, Home Assistant discovery, the update channel — is
         read into entity names and subscriptions all over the application while
         it starts, and still takes a restart.
@@ -1456,6 +1457,7 @@ class Manager:
                 port=int(mqtt.get(PORT) or bus.port),
                 username=mqtt.get(USERNAME, bus.client_options.get(USERNAME)),
                 password=mqtt.get(PASSWORD, bus.client_options.get(PASSWORD)),
+                tls=mqtt.get("tls"),
             )
 
     def _reload_logger(self) -> None: