boneIO 1.5.6__tar.gz → 1.6.0.dev1__tar.gz

{boneio-1.5.6/boneio.egg-info → boneio-1.6.0.dev1}/PKG-INFO

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

{boneio-1.5.6 → boneio-1.6.0.dev1}/boneio/bonecli.py

@@ -258,6 +258,9 @@ def run(
         from boneio.const import ACTION
         _LOGGER.debug("[RUNNER IMPORT] boneio.const: %.2fs", _time.monotonic() - _t_a)
         _t_a = _time.monotonic()
+        from boneio.core.cloud import CloudRegistration
+        _LOGGER.debug("[RUNNER IMPORT] boneio.core.cloud: %.2fs", _time.monotonic() - _t_a)
+        _t_a = _time.monotonic()
         from boneio.core.manager import Manager
         _LOGGER.debug("[RUNNER IMPORT] boneio.core.manager: %.2fs", _time.monotonic() - _t_a)
         _t_a = _time.monotonic()

boneio-1.6.0.dev1/boneio/components/cover/__init__.py

@@ -0,0 +1,6 @@
+"""Cover classes."""
+from .remote import RemoteCoverOutput
+from .time_based import TimeBasedCover
+from .venetian import VenetianCover
+
+__all__ = ["RemoteCoverOutput", "TimeBasedCover", "VenetianCover"]

{boneio-1.5.6 → boneio-1.6.0.dev1}/boneio/components/cover/cover.py

@@ -210,23 +210,9 @@ 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()
-
-            # 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)
+            self._movement_thread.join(timeout=0.5)
+            self._open_relay.turn_off()
+            self._close_relay.turn_off()
             # 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.dev1/boneio/components/cover/remote.py

@@ -0,0 +1,277 @@
+"""Remote cover output for covers on remote devices (ESPHome API).
+
+``RemoteCoverOutput`` provides a duck-type compatible interface with
+:class:`TimeBasedCover` / :class:`VenetianCover` so that the conditions
+system (``is_open`` / ``is_closed``), ``CoverManager.get_cover()``,
+and WebSocket event emission work transparently with remote covers.
+
+The actual hardware control is delegated to the parent
+``ESPHomeDeviceManager`` via ``control_cover()``.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import TYPE_CHECKING, Any
+
+from boneio.const import CLOSED, CLOSING, COVER, IDLE, OPEN, OPENING
+from boneio.core.events import EventBus
+from boneio.models import CoverState
+from boneio.models.events import CoverEvent
+
+if TYPE_CHECKING:
+    from boneio.core.messaging import MessageBus
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class RemoteCoverOutput:
+    """Remote cover from ESPHome — duck-type compatible with local Cover.
+
+    Provides the same public interface that the condition evaluators and
+    the ``CoverManager`` expect:
+
+    - ``is_open`` / ``is_closed`` property for action conditions
+    - ``state`` / ``position`` / ``tilt`` for state reporting
+    - ``on_remote_state_change()`` callback from ESPHome subscription
+    - ``CoverEvent`` emission on EventBus for WebSocket clients
+
+    Args:
+        id: Entity identifier (usually ``{device_id}_{cover_id}``).
+        name: Human-readable display name.
+        device_id: ID of the remote device hosting this cover.
+        cover_id: Entity object_id on the remote device.
+        remote_source: Transport protocol (``esphome_api``).
+        event_bus: Central event bus for emitting ``CoverEvent`` objects.
+        kind: Cover device class (``blind``, ``shutter``, ``gate``, etc.).
+        show_in_ha: Whether to publish HA autodiscovery.
+        area: Optional HA area assignment.
+    """
+
+    # Duck-type compatibility with local covers
+    is_remote: bool = True
+
+    def __init__(
+        self,
+        *,
+        id: str,
+        name: str,
+        device_id: str,
+        cover_id: str,
+        remote_source: str,
+        event_bus: EventBus,
+        message_bus: MessageBus | None = None,
+        topic_prefix: str = "",
+        kind: str = "cover",
+        show_in_ha: bool = False,
+        area: str | None = None,
+    ) -> None:
+        self._id = id
+        self._name = name
+        self._device_id = device_id
+        self._cover_id = cover_id
+        self._remote_source = remote_source
+        self._event_bus = event_bus
+        self._message_bus: MessageBus | None = message_bus
+        self._send_topic = f"{topic_prefix}/{COVER}/{id}" if topic_prefix else ""
+        self._kind = kind
+        self.show_in_ha = show_in_ha
+        self.area: str | None = area
+
+        # State tracking
+        self._position: int = 0  # 0=closed, 100=open
+        self._tilt: int = 0
+        self._current_operation: str = IDLE
+        self._last_timestamp: float = 0.0
+        self._available: bool = False
+
+        # Reference to remote device manager — set by registration.
+        self._device_manager: Any = None
+        self._remote_devices_ref: Any = None
+
+    # ------------------------------------------------------------------
+    # Public properties (duck-type compatible with TimeBasedCover)
+    # ------------------------------------------------------------------
+
+    @property
+    def id(self) -> str:
+        """Entity identifier."""
+        return self._id
+
+    @property
+    def name(self) -> str:
+        """Human-readable name."""
+        return self._name
+
+    @property
+    def kind(self) -> str:
+        """Cover device class (blind, shutter, gate, etc.)."""
+        return self._kind
+
+    @property
+    def state(self) -> str:
+        """Current state as string (open/closed/opening/closing)."""
+        if self._current_operation == OPENING:
+            return OPENING
+        elif self._current_operation == CLOSING:
+            return CLOSING
+        else:
+            return CLOSED if self._position == 0 else OPEN
+
+    @property
+    def is_open(self) -> bool:
+        """True when cover position > 0 (not fully closed)."""
+        return self._position > 0
+
+    @property
+    def is_closed(self) -> bool:
+        """True when cover is fully closed (position == 0)."""
+        return self._position == 0
+
+    @property
+    def position(self) -> int:
+        """Current cover position (0-100)."""
+        return self._position
+
+    @property
+    def tilt(self) -> int:
+        """Current tilt position (0-100)."""
+        return self._tilt
+
+    @property
+    def current_operation(self) -> str:
+        """Current operation (idle/opening/closing)."""
+        return self._current_operation
+
+    @property
+    def last_timestamp(self) -> float:
+        """Timestamp of last state update."""
+        return self._last_timestamp
+
+    # ------------------------------------------------------------------
+    # Remote state callback
+    # ------------------------------------------------------------------
+
+    def on_remote_state_change(self, state_dict: dict[str, Any]) -> None:
+        """Called by ESPHome device manager when cover state changes.
+
+        Args:
+            state_dict: Cover state from ESPHome containing:
+                - position: float (0.0-1.0)
+                - tilt: float | None
+                - current_operation: int (0=IDLE, 1=OPENING, 2=CLOSING)
+        """
+        position_raw = state_dict.get("position")
+        if position_raw is not None:
+            self._position = round(float(position_raw) * 100)
+
+        tilt_raw = state_dict.get("tilt")
+        if tilt_raw is not None:
+            self._tilt = round(float(tilt_raw) * 100)
+
+        current_op_int = state_dict.get("current_operation", 0)
+        if current_op_int == 1:
+            self._current_operation = OPENING
+        elif current_op_int == 2:
+            self._current_operation = CLOSING
+        else:
+            self._current_operation = IDLE
+
+        self._last_timestamp = time.time()
+        self._available = True
+
+        _LOGGER.debug(
+            "Remote cover '%s' state: position=%d%%, tilt=%d%%, operation=%s",
+            self._id,
+            self._position,
+            self._tilt,
+            self._current_operation,
+        )
+
+        # Emit CoverEvent for WebSocket clients
+        self._emit_cover_event()
+
+    def _emit_cover_event(self) -> None:
+        """Emit a CoverEvent on the event bus."""
+        event = CoverState(
+            id=self._id,
+            name=self._name,
+            state=self.state,
+            kind=self._kind,
+            timestamp=self._last_timestamp,
+            current_operation=self._current_operation,
+            position=self._position,
+            tilt=self._tilt,
+        )
+        self._event_bus.trigger_event(CoverEvent(entity_id=self._id, state=event))
+
+    # ------------------------------------------------------------------
+    # Device manager resolution (lazy — same pattern as RemoteOutputBase)
+    # ------------------------------------------------------------------
+
+    def _resolve_device_manager(self) -> bool:
+        """Try to resolve device manager lazily from remote_devices reference.
+
+        Returns:
+            ``True`` if device manager is now available.
+        """
+        if self._device_manager is not None:
+            return True
+        if self._remote_devices_ref is None:
+            return False
+        device = self._remote_devices_ref.get_device(self._device_id)
+        if device is not None:
+            self._device_manager = device
+            self._remote_devices_ref = None
+            self._register_state_callback()
+            _LOGGER.info(
+                "Lazily resolved device manager for remote cover '%s' (device '%s')",
+                self._id,
+                self._device_id,
+            )
+            return True
+        return False
+
+    def _register_state_callback(self) -> None:
+        """Register a cover state change callback on the device manager.
+
+        Called after device manager is resolved (lazy or immediate).
+        ESPHome devices will call back on cover state changes.
+        Also syncs current state from the device if available.
+        """
+        if self._device_manager is None:
+            return
+        register_fn = getattr(self._device_manager, "register_cover_callback", None)
+        if register_fn is not None:
+            register_fn(self._cover_id, self.on_remote_state_change)
+            _LOGGER.debug(
+                "Registered cover callback for remote cover '%s' on device '%s'",
+                self._id,
+                self._device_id,
+            )
+
+        # Sync initial state from device's current known states
+        self._sync_initial_state()
+
+    def _sync_initial_state(self) -> None:
+        """Sync initial state from ESPHome device's cached cover states."""
+        if self._device_manager is None:
+            return
+
+        cover_states: dict[str, dict[str, Any]] = getattr(
+            self._device_manager, "_cover_states", {}
+        )
+        if self._cover_id in cover_states:
+            self.on_remote_state_change(cover_states[self._cover_id])
+            _LOGGER.debug(
+                "Synced initial cover state for '%s': position=%d%%",
+                self._id,
+                self._position,
+            )
+
+    def __repr__(self) -> str:
+        return (
+            f"RemoteCoverOutput(id={self._id!r}, device={self._device_id!r}, "
+            f"cover={self._cover_id!r}, position={self._position})"
+        )

{boneio-1.5.6 → boneio-1.6.0.dev1}/boneio/components/cover/time_based.py

@@ -61,20 +61,6 @@ class TimeBasedCover(BaseCover):
         else:
             return
 
-        if duration == 0:
-            # A zero open_time/close_time makes movement impossible: the guard
-            # below returns before relay.turn_on(), so the relay is never
-            # energised and the motor never gets voltage — while the cover still
-            # reports IDLE and publishes state, so the UI looks like it worked.
-            # This is always a misconfiguration, never a normal outcome.
-            _LOGGER.error(
-                "Cover %s cannot move %s: %s_time is 0. The relay will NOT be "
-                "switched. Set a non-zero time in the cover configuration.",
-                self._id,
-                direction,
-                "open" if direction == OPEN else "close",
-            )
-
         if total_steps == 0 or duration == 0:
             self._current_operation = IDLE
             with suppress(RuntimeError):

{boneio-1.5.6 → boneio-1.6.0.dev1}/boneio/components/cover/venetian.py

@@ -93,20 +93,6 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             else:
                 total_steps = 1
 
-        if duration == 0:
-            # A zero open_time/close_time makes movement impossible: the guard
-            # below returns before relay.turn_on(), so the relay is never
-            # energised and the motor never gets voltage — while the cover still
-            # reports IDLE and publishes state, so the UI looks like it worked.
-            # This is always a misconfiguration, never a normal outcome.
-            _LOGGER.error(
-                "Cover %s cannot move %s: %s_time is 0. The relay will NOT be "
-                "switched. Set a non-zero time in the cover configuration.",
-                self._id,
-                direction,
-                "open" if direction == OPEN else "close",
-            )
-
         if total_steps == 0 or duration == 0:
             self._current_operation = IDLE
             self._loop.call_soon_threadsafe(self.send_state, self.state, self.json_position)

{boneio-1.5.6 → boneio-1.6.0.dev1}/boneio/components/input/binary_sensor.py

@@ -8,18 +8,12 @@ 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."""
@@ -63,71 +57,6 @@ 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.5.6 → boneio-1.6.0.dev1}/boneio/components/input/detectors.py

@@ -135,14 +135,6 @@ 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
@@ -423,18 +415,13 @@ 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. 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.
+            # Button released or invalid state
             _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()
@@ -583,27 +570,6 @@ 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
@@ -881,33 +847,6 @@ 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.5.6 → boneio-1.6.0.dev1}/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.timeperiod import parse_time_to_ms
+from boneio.core.utils import TimePeriod
 from boneio.hardware.gpio.input import GpioBaseClass, get_gpio_manager
 
 _LOGGER = logging.getLogger(__name__)
@@ -16,31 +16,25 @@ _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: 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.
+        value: Can be int, float, TimePeriod, or None
+        default_ms: Default value in milliseconds if value is None
 
     Returns:
-        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.
+        Value in milliseconds as integer
     """
-    return parse_time_to_ms(value, default_ms)
+    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
 
 
 class GpioEventButton(GpioBaseClass):
@@ -179,7 +173,6 @@ 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.
 
@@ -196,9 +189,6 @@ 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
 
@@ -270,16 +260,3 @@ 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,
-            )