boneio 1.6.0.dev24__tar.gz → 1.6.0.dev26__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.6.0.dev24
+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.dev24 → 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.dev24 → 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.dev24 → 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.dev24 → 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.dev24 → 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.dev24 → 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.dev24 → 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.dev24 → 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.dev24 → 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.dev24 → 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.dev24 → 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.dev24 → 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.dev24 → 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,10 +163,18 @@ class CoverManager:
                         _cover._open_relay = open_relay
                         _cover._close_relay = close_relay
                         _cover.update_config_times(_config)
-                        # Re-send HA autodiscovery with potentially new name/area
-                        if _config.get(SHOW_HA, True):
-                            # Remove old autodiscovery first (in case area changed)
+                        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:
+                            # 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
@@ -181,8 +184,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 +378,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 +398,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.
 
@@ -403,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)
@@ -432,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.
 
@@ -508,6 +567,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 +578,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.dev24 → 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)
@@ -277,6 +284,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)
@@ -301,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,
@@ -327,6 +338,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):
@@ -393,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)
@@ -407,6 +421,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)
@@ -421,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,
@@ -453,6 +471,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):
@@ -949,6 +968,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
@@ -1075,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)