boneio 1.6.0.dev10__tar.gz → 1.6.0.dev11__tar.gz

{boneio-1.6.0.dev10/boneio.egg-info → boneio-1.6.0.dev11}/PKG-INFO

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

{boneio-1.6.0.dev10 → boneio-1.6.0.dev11}/boneio/components/cover/cover.py

@@ -210,9 +210,23 @@ class BaseCover(BaseCoverABC, BasicMqtt):
     async def stop(self, on_exit=False) -> None:
         if self._movement_thread and self._movement_thread.is_alive():
             self._stop_event.set()
-            self._movement_thread.join(timeout=0.5)
-            self._open_relay.turn_off()
-            self._close_relay.turn_off()
+
+            # Halting is three blocking operations: waiting for the movement
+            # thread to notice the stop event, and two relay writes that go out
+            # over I2C behind a bus lock shared with every other device. Run
+            # inline they were the *event loop's* wait — up to half a second of
+            # frozen loop on every cover stop, and a cover stop is the first
+            # thing `toggle`, `toggle_open` and `toggle_close` do, so an
+            # ordinary button press paid it. Nothing reads GPIO while the loop
+            # is stopped. Order is unchanged: join first, then de-energise.
+            thread = self._movement_thread
+
+            def _halt() -> None:
+                thread.join(timeout=0.5)
+                self._open_relay.turn_off()
+                self._close_relay.turn_off()
+
+            await asyncio.get_running_loop().run_in_executor(None, _halt)
             # Send relay states to WebSocket (not MQTT - that's handled by output_type check)
             with suppress(RuntimeError):
                 asyncio.create_task(self._open_relay.async_send_state())

{boneio-1.6.0.dev10 → boneio-1.6.0.dev11}/boneio/components/input/__init__.py

@@ -9,11 +9,16 @@ Sub-packages:
 
 from boneio.components.input.binary_sensor import GpioInputBinarySensor
 from boneio.components.input.event import GpioEventButton
-from boneio.components.input.remote import ESPHomeBinarySensorInput, RemoteInputBase
+from boneio.components.input.remote import (
+    ESPHomeBinarySensorInput,
+    MqttBinarySensorInput,
+    RemoteInputBase,
+)
 
 __all__ = [
     "GpioInputBinarySensor",
     "GpioEventButton",
     "ESPHomeBinarySensorInput",
+    "MqttBinarySensorInput",
     "RemoteInputBase",
 ]

{boneio-1.6.0.dev10 → boneio-1.6.0.dev11}/boneio/components/input/binary_sensor.py

@@ -8,12 +8,18 @@ from typing import cast
 
 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.models import InputState
 from boneio.models.events import InputEvent
 
 _LOGGER = logging.getLogger(__name__)
 
+# Matches the binary_sensor bounce_time default in schema.yaml. Needed on the
+# hot-reload path, which reads the YAML without running Cerberus, so an
+# omitted bounce_time arrives as None rather than as the schema default.
+DEFAULT_BOUNCE_TIME_MS = 120
+
 
 class GpioInputBinarySensor(GpioBaseClass):
     """Represent Gpio binary sensor on input boards."""
@@ -57,6 +63,71 @@ class GpioInputBinarySensor(GpioBaseClass):
         if kwargs.get("initial_send", False):
             gpio_manager.register_on_start_callback(self._send_initial_state)
 
+    def update_inverted(self, inverted: bool) -> bool:
+        """Apply a new ``inverted`` setting to a running sensor.
+
+        Polarity is decided in ``__init__`` and baked into the detector, so a
+        config reload alone used to leave the running sensor on the old
+        polarity until the application was restarted.
+
+        Args:
+            inverted: New inverted flag from the reloaded config.
+
+        Returns:
+            True if the polarity actually changed (caller should re-publish
+            the state), False if it was already set that way.
+        """
+        inverted = bool(inverted)
+        if inverted == self._inverted:
+            return False
+
+        self._inverted = inverted
+        self._click_type = (RELEASED, PRESSED) if inverted else (PRESSED, RELEASED)
+
+        # Re-read the pin and re-anchor the detector with the new polarity.
+        gpio_manager = get_gpio_manager(loop=self._loop)
+        current_value = gpio_manager.read_value(self._pin)
+        is_pressed = current_value if inverted else not current_value
+        self._detector.resync(inverted=inverted, current_state=is_pressed)
+
+        _LOGGER.info(
+            "Binary sensor %s (%s): inverted changed to %s without restart",
+            self._name,
+            self._pin,
+            inverted,
+        )
+        return True
+
+    def update_bounce_time(self, bounce_time) -> bool:
+        """Apply a new debounce window to a running sensor.
+
+        Like ``inverted``, ``bounce_time`` is read in ``__init__`` and handed to
+        the detector, so a config reload used to leave the old window in place
+        until the application was restarted.
+
+        Args:
+            bounce_time: Value straight from the reloaded config — a TimePeriod
+                at startup, but a bare number of milliseconds (WebUI) or a string
+                such as "120ms" (hand-written YAML) on the hot-reload path, which
+                skips Cerberus coercion. ``None`` means the schema default.
+
+        Returns:
+            True if the window actually changed.
+        """
+        seconds = parse_time_to_ms(bounce_time, DEFAULT_BOUNCE_TIME_MS) / 1000.0
+        if seconds == self._bounce_time:
+            return False
+
+        self._bounce_time = seconds
+        self._detector.set_debounce(seconds)
+        _LOGGER.info(
+            "Binary sensor %s (%s): bounce_time changed to %.0fms without restart",
+            self._name,
+            self._pin,
+            seconds * 1000,
+        )
+        return True
+
     def _send_initial_state(self) -> None:
         """Send initial state after setup."""
         self.send_current_state()

{boneio-1.6.0.dev10 → boneio-1.6.0.dev11}/boneio/components/input/detectors.py

@@ -135,6 +135,14 @@ class MultiClickDetector:
                         self._delay_click_types.add(first)
                         break
 
+    def set_debounce(self, debounce_seconds: float) -> None:
+        """Change the debounce window on a running detector.
+
+        Only the window is replaced; timestamps already recorded stay valid
+        and are simply compared against the new window from now on.
+        """
+        self._debounce_seconds = debounce_seconds
+
     def _finalize_clicks(self) -> None:
         """Finalize a multi-click sequence."""
         count = self._state.click_count
@@ -415,13 +423,18 @@ class MultiClickDetector:
         GPIO state to detect missed RELEASE edge events.
         """
         if not self._state.last_press_loop_ts or self._state.last_release_ts:
-            # Button released or invalid state
+            # Button released or invalid state. Drop the handle as well: this
+            # chain is ending here, and a handle left pointing at a timer that
+            # has already fired reads as "a long press is running" to the
+            # release path, which then emits a phantom final LONG on the next
+            # ordinary click.
             _LOGGER.debug(
                 "Periodic long skipped for %s: press_ts=%s, release_ts=%s",
                 self._name,
                 self._state.last_press_loop_ts is not None,
                 self._state.last_release_ts,
             )
+            self._state.long_hold_periodic_timer = None
             return
         
         now = self._loop.time()
@@ -570,6 +583,27 @@ class MultiClickDetector:
                 return
 
             _LOGGER.debug("PRESSED: %s (%s)", self._name, self._pin)
+
+            # End any long-hold chain still running from the previous press.
+            # It can still be running only because that press never saw its
+            # release — the edge was lost while the event loop was blocked, or
+            # it was swallowed as a bounce. Left alone, the old chain keeps
+            # rescheduling itself and now measures against *this* press, so its
+            # safety timeout never trips and nothing can ever cancel it: the
+            # handle below is about to be overwritten. Every such press adds
+            # another immortal chain emitting LONG five times a second.
+            if self._state.long_hold_periodic_timer:
+                _LOGGER.warning(
+                    "New press on %s (%s) while a long-hold chain was still "
+                    "running — the previous release was never seen. Ending it.",
+                    self._name,
+                    self._pin,
+                )
+                self._state.long_hold_periodic_timer.cancel()
+                self._state.long_hold_periodic_timer = None
+                self._state.executed_long_actions = set()
+                self._state.last_repeat_times = {}
+
             self._state.last_press_ts = timestamp_s
             self._state.last_press_loop_ts = self._loop.time()  # Store loop time for duration calc
             self._state.last_release_ts = None  # Reset release timestamp for new press
@@ -847,6 +881,33 @@ class BinarySensorDetector:
         self._pin = pin
         self._state = BinarySensorState()
 
+    def set_debounce(self, debounce_seconds: float) -> None:
+        """Change the debounce window on a running detector.
+
+        Only the window is replaced; timestamps already recorded stay valid
+        and are simply compared against the new window from now on.
+        """
+        self._debounce_seconds = debounce_seconds
+
+    def resync(self, inverted: bool, current_state: bool) -> None:
+        """Apply a new polarity to a running detector.
+
+        Called when ``inverted`` is changed in the config and reloaded, so the
+        user does not have to restart the application for it to take effect.
+
+        Args:
+            inverted: New inverted flag.
+            current_state: Pressed state as read from the pin right now, already
+                interpreted with the *new* polarity. Without re-anchoring it the
+                cached state would still describe the old polarity and the next
+                edge would be dropped by the "state unchanged" guard.
+        """
+        self._inverted = bool(inverted)
+        self._state.current_state = bool(current_state)
+        # Drop the debounce anchor — the pending window belongs to the old
+        # polarity and would swallow the first edge after the change.
+        self._state.last_press_ts = None
+
     def handle_event(self, event: gpiod.EdgeEvent) -> None:
         """Process a GPIO edge event for binary sensor.
         

{boneio-1.6.0.dev10 → boneio-1.6.0.dev11}/boneio/components/input/event.py

@@ -7,7 +7,7 @@ import time
 
 from boneio.components.input.detectors import MultiClickDetector
 from boneio.const import ClickTypes
-from boneio.core.utils import TimePeriod
+from boneio.core.utils.timeperiod import parse_time_to_ms
 from boneio.hardware.gpio.input import GpioBaseClass, get_gpio_manager
 
 _LOGGER = logging.getLogger(__name__)
@@ -16,25 +16,31 @@ _LOGGER = logging.getLogger(__name__)
 DEFAULT_DOUBLE_CLICK_DURATION_MS = 220
 DEFAULT_LONG_PRESS_DURATION_MS = 400
 DEFAULT_SEQUENCE_WINDOW_MS = 500
+# Matches the event bounce_time default in schema.yaml. Needed on the hot-reload
+# path, which reads the YAML without running Cerberus, so an omitted bounce_time
+# arrives as None rather than as the schema default.
+DEFAULT_BOUNCE_TIME_MS = 30
 
 
 def _to_milliseconds(value, default_ms: int) -> int:
     """Convert a value to milliseconds.
 
     Args:
-        value: Can be int, float, TimePeriod, or None
-        default_ms: Default value in milliseconds if value is None
+        value: TimePeriod, bare number of milliseconds, string with a unit
+            (e.g. "300ms"), or None.
+        default_ms: Default value in milliseconds if value is None or unusable.
 
     Returns:
-        Value in milliseconds as integer
+        Value in milliseconds as integer.
+
+    Note:
+        Strings have to be handled here, not just TimePeriod: Cerberus coerces
+        these fields at startup, but the hot-reload path reads the YAML without
+        validating, and EventForm writes them as strings like "300ms". Falling
+        back to the default for those quietly reset every custom click timing on
+        each reload.
     """
-    if value is None:
-        return default_ms
-    if isinstance(value, TimePeriod):
-        return int(value.total_milliseconds)
-    if isinstance(value, (int, float)):
-        return int(value)
-    return default_ms
+    return parse_time_to_ms(value, default_ms)
 
 
 class GpioEventButton(GpioBaseClass):
@@ -173,6 +179,7 @@ class GpioEventButton(GpioBaseClass):
         enable_triple_click: bool | None = None,
         long_press_mqtt_mode: str | None = None,
         max_long_press_duration: int | float | None = None,
+        bounce_time: object | None = None,
     ) -> None:
         """Update timing parameters for click detection.
 
@@ -189,6 +196,9 @@ class GpioEventButton(GpioBaseClass):
             enable_triple_click: Enable triple click detection
             long_press_mqtt_mode: 'single' or 'periodic' for MQTT long press events
             max_long_press_duration: Safety timeout for long press in ms (default: 120000ms)
+            bounce_time: Debounce window — a TimePeriod at startup, but a bare
+                number of milliseconds or a string such as "30ms" on the
+                hot-reload path, which skips Cerberus coercion
         """
         from boneio.const import CLICK_SEQUENCES
 
@@ -260,3 +270,16 @@ class GpioEventButton(GpioBaseClass):
         if long_press_mqtt_mode is not None:
             self._long_press_mqtt_mode = long_press_mqtt_mode
             _LOGGER.debug("Updated long_press_mqtt_mode to %s for %s", long_press_mqtt_mode, self._name)
+
+        # bounce_time is handed to the detector in __init__, so it needs pushing
+        # through explicitly — None here means "back to the schema default".
+        seconds = parse_time_to_ms(bounce_time, DEFAULT_BOUNCE_TIME_MS) / 1000.0
+        if seconds != self._bounce_time:
+            self._bounce_time = seconds
+            self._detector.set_debounce(seconds)
+            _LOGGER.info(
+                "Event input %s (%s): bounce_time changed to %.0fms without restart",
+                self._name,
+                self._pin,
+                seconds * 1000,
+            )

{boneio-1.6.0.dev10 → boneio-1.6.0.dev11}/boneio/components/input/remote/__init__.py

@@ -8,6 +8,8 @@ the same duck-type interface as :class:`GpioBaseClass`.
 Subpackages:
     base:    ``RemoteInputBase`` — shared logic (EventBus, actions, MultiClickDetector)
     esphome: ``ESPHomeBinarySensorInput`` — ESPHome native API
+    mqtt:    ``MqttBinarySensorInput`` — any device that publishes a state on a
+             topic, most usefully another boneIO
     # future:
     # can_esphome: CAN bus → ESPHome device
     # can_boneio:  CAN bus → another boneIO Black
@@ -15,8 +17,10 @@ Subpackages:
 
 from boneio.components.input.remote.base import RemoteInputBase
 from boneio.components.input.remote.esphome import ESPHomeBinarySensorInput
+from boneio.components.input.remote.mqtt import MqttBinarySensorInput
 
 __all__ = [
     "RemoteInputBase",
     "ESPHomeBinarySensorInput",
+    "MqttBinarySensorInput",
 ]

boneio-1.6.0.dev11/boneio/components/input/remote/mqtt.py

@@ -0,0 +1,148 @@
+"""MQTT binary sensor input — a remote input carried over MQTT.
+
+The obvious use is mirroring another boneIO: a peer publishes its inputs at
+``<its topic prefix>/input/<input id>``, and this subscribes to exactly that,
+so a button on one controller can drive a relay on another with nothing in
+between but the broker.
+
+It is not limited to boneIO. Anything that publishes an on/off payload on a
+topic works — an ESPHome device in MQTT mode, a Zigbee bridge, a script — by
+giving the entry an explicit ``topic``.
+
+What it is *not* for: a flag you flip by hand from Home Assistant. That is a
+`virtual_switch`, which boneIO owns and persists. This is for mirroring
+something that already exists somewhere else.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+
+from boneio.components.input.remote.base import RemoteInputBase
+from boneio.core.events import EventBus
+
+_LOGGER = logging.getLogger(__name__)
+
+#: Payloads that mean "on". Three vocabularies at once, because the three
+#: things people point this at do not agree: boneIO publishes pressed/released,
+#: ESPHome publishes ON/OFF, and everything else publishes true/1.
+_TRUTHY = frozenset({"on", "true", "1", "pressed", "open", "opening", "active"})
+_FALSY = frozenset({"off", "false", "0", "released", "closed", "closing", "inactive"})
+
+
+class MqttBinarySensorInput(RemoteInputBase):
+    """A remote input whose state arrives on an MQTT topic.
+
+    Args:
+        device_id: ID of the remote device, from ``remote_devices``.
+        sensor_id: The input's id on that device.
+        topic: Topic to subscribe to.
+        id: Local input id.
+        name: Display name.
+        event_bus: EventBus.
+        actions: Parsed actions, keyed by click type.
+        **kwargs: Forwarded to :class:`RemoteInputBase`.
+    """
+
+    def __init__(
+        self,
+        *,
+        device_id: str,
+        sensor_id: str,
+        topic: str,
+        id: str,
+        name: str,
+        event_bus: EventBus,
+        actions: dict,
+        **kwargs,
+    ) -> None:
+        self._device_id = device_id
+        self._sensor_id = sensor_id
+        self._topic = topic
+
+        super().__init__(
+            id=id,
+            name=name,
+            pin=f"mqtt:{device_id}:{sensor_id}",
+            event_bus=event_bus,
+            actions=actions,
+            **kwargs,
+        )
+
+        _LOGGER.debug(
+            "Created MQTT binary sensor input %s (mode=%s, topic=%s)",
+            id,
+            self._mode,
+            topic,
+        )
+
+    @property
+    def topic(self) -> str:
+        """The topic this input listens on."""
+        return self._topic
+
+    @staticmethod
+    def parse_state(payload: str) -> bool | None:
+        """Read an on/off payload, or None if it is not one.
+
+        Returns:
+            True or False, or None when the payload means nothing here — in
+            which case the caller leaves the state alone rather than guessing,
+            because a wrong guess silently drives a relay.
+        """
+        text = (payload or "").strip().strip('"').lower()
+        if text in _TRUTHY:
+            return True
+        if text in _FALSY:
+            return False
+        return None
+
+    async def on_mqtt_message(self, _topic: str, payload: str) -> None:
+        """Handle a message on the subscribed topic.
+
+        Two payload shapes are understood. A plain on/off state is the usual
+        one. A JSON object with ``event_type`` is what a boneIO *event* input
+        publishes — a click that has already been classified — and in event
+        mode it is passed through as-is rather than re-derived from a state
+        this side never saw.
+
+        Args:
+            _topic: The topic it arrived on; unused, one subscription per input.
+            payload: The message.
+        """
+        text = (payload or "").strip()
+
+        if text.startswith("{"):
+            try:
+                event_type = json.loads(text).get("event_type")
+            except ValueError:
+                event_type = None
+            if event_type:
+                if self._mode == "event":
+                    self.press_callback(click_type=event_type, duration=None)
+                else:
+                    _LOGGER.debug(
+                        "Input %s got a click event but is in binary_sensor mode; "
+                        "set `mode: event` to use it.",
+                        self.id,
+                    )
+                return
+
+        state = self.parse_state(text)
+        if state is None:
+            _LOGGER.warning(
+                "Input %s: cannot read %r as a state. Expected on/off, "
+                "true/false, 1/0 or pressed/released.",
+                self.id,
+                payload,
+            )
+            return
+
+        if self._inverted:
+            state = not state
+
+        if self._mode == "event":
+            self._feed_detector(is_pressed=state)
+        else:
+            self._handle_binary_state_change(state)