boneio 1.3.1.dev2__tar.gz → 1.4.0__tar.gz

{boneio-1.3.1.dev2/boneio.egg-info → boneio-1.4.0}/PKG-INFO

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

{boneio-1.3.1.dev2 → boneio-1.4.0}/boneio/components/cover/cover.py

@@ -21,7 +21,7 @@ from boneio.const import (
 from boneio.core.events import EventBus
 from boneio.core.messaging import BasicMqtt
 from boneio.core.utils import TimePeriod
-from boneio.models import CoverState, PositionDict
+from boneio.models import CoverState, PositionDict, SavedPositionDict
 from boneio.models.events import CoverEvent
 
 _LOGGER = logging.getLogger(__name__)
@@ -40,7 +40,7 @@ class BaseCoverABC(ABC):
         open_time: TimePeriod,
         close_time: TimePeriod,
         event_bus: EventBus,
-        position: int = 100,
+        position: float = 100.0,
         **kwargs,
     ) -> None:
         pass
@@ -106,14 +106,12 @@ class BaseCoverABC(ABC):
         pass
 
     @abstractmethod
-    async def run_cover(
-        self, current_operation: str, target_position: float | None = None, target_tilt: float | None = None
-    ) -> None:
+    async def run_cover(self, current_operation: str, target_position: int | None = None, **kwargs) -> None:
         """This function is called to run cover after calling open, close, toggle, toggle_open, toggle_close, set_cover_position"""
         pass
 
     @abstractmethod
-    async def send_state(self, state: str, position: float) -> None:
+    def send_state(self, state: str, json_position: PositionDict) -> None:
         pass
 
 
@@ -159,7 +157,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         open_time: TimePeriod,
         close_time: TimePeriod,
         event_bus: EventBus,
-        position: int = 100,
+        position: float = 100.0,
         name: str | None = None,
         **kwargs,
     ) -> None:
@@ -175,7 +173,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._open_time = open_time.total_milliseconds
         self._close_time = close_time.total_milliseconds
         self._position = position
-        self._initial_position = None
+        self._initial_position: float = position
         self._current_operation = IDLE
         self._last_operation = CLOSING
         _LOGGER.debug(
@@ -188,12 +186,18 @@ class BaseCover(BaseCoverABC, BasicMqtt):
 
         self._last_timestamp = time.time()
 
-        self._last_update_time = 0
+        self._last_update_time = 0.0
         self._closed = position <= 0
 
         self._movement_thread = None
         self._stop_event = threading.Event()
 
+        # Flag set by action executor to signal this call originates from a button action.
+        # Used by VenetianCover to conditionally skip tilt restore.
+        self._from_action: bool = False
+        # When True, tilt restore is explicitly requested by the action definition.
+        self._action_tilt_restore: bool = False
+
         self._event_bus.add_sigterm_listener(self.on_exit)
 
         with suppress(RuntimeError):
@@ -356,7 +360,8 @@ class BaseCover(BaseCoverABC, BasicMqtt):
 
     @property
     def position(self) -> int:
-        return round(self._position, 0)
+        """Return current cover position as integer (0-100)."""
+        return round(self._position)
 
     @property
     def json_position(self) -> PositionDict:
@@ -384,6 +389,12 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=state)
         self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload=json.dumps(json_position))
 
+    @property
+    def saved_position(self) -> SavedPositionDict:
+        """Raw float position for disk persistence."""
+        return {"position": self._position}
+
     def send_state_and_save(self, json_position: PositionDict):
+        """Send state to MQTT/WebSocket and save raw float position to disk."""
         self.send_state(self.state, json_position)
-        self._state_save(json_position)
+        self._state_save(self.saved_position)

{boneio-1.3.1.dev2 → boneio-1.4.0}/boneio/components/cover/time_based.py

@@ -31,7 +31,7 @@ class TimeBasedCover(BaseCover):
         restored_state: dict = DEFAULT_RESTORED_STATE,
         **kwargs,
     ) -> None:
-        position = int(restored_state.get("position", DEFAULT_RESTORED_STATE["position"]))
+        position = float(restored_state.get("position", DEFAULT_RESTORED_STATE["position"]))
         super().__init__(
             open_relay=open_relay,
             close_relay=close_relay,
@@ -113,7 +113,7 @@ class TimeBasedCover(BaseCover):
             self._loop.call_soon_threadsafe(lambda: self.send_state_and_save(self.json_position))
         self._last_update_time = time.monotonic()  # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
 
-    async def run_cover(self, current_operation: str, target_position: int | None = None) -> None:
+    async def run_cover(self, current_operation: str, target_position: int | None = None, **kwargs) -> None:
         if self._movement_thread and self._movement_thread.is_alive():
             _LOGGER.warning("Cover movement already in progress. Stopping first.")
             await self.stop()

{boneio-1.3.1.dev2 → boneio-1.4.0}/boneio/components/cover/venetian.py

@@ -8,7 +8,7 @@ import time
 from boneio.components.cover.cover import BaseCover, BaseVenetianCoverABC
 from boneio.const import CLOSE, CLOSING, IDLE, OPEN, OPENING, STOP
 from boneio.core.utils import TimePeriod
-from boneio.models import PositionDict
+from boneio.models import PositionDict, SavedPositionDict
 
 _LOGGER = logging.getLogger(__name__)
 COVER_MOVE_UPDATE_INTERVAL = 50  # ms
@@ -25,26 +25,28 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         tilt_duration: TimePeriod,  # ms
         actuator_activation_duration: TimePeriod,  # ms
         restored_state: dict = DEFAULT_RESTORED_STATE,
+        tilt_restore_after_close: bool = False,
         **kwargs,
     ) -> None:
-        self._tilt_duration = (
-            tilt_duration.total_milliseconds
-        )  # Czas trwania ruchu lameli
-        self._initial_tilt_position = int(
-            restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"])
-        )
+        """Initialize venetian cover.
 
-        position = int(
-            restored_state.get("position", DEFAULT_RESTORED_STATE["position"])
-        )
+        Args:
+            tilt_duration: Duration for full tilt movement.
+            actuator_activation_duration: Actuator activation time (unused).
+            restored_state: Persisted position/tilt from disk.
+            tilt_restore_after_close: If True, restore previous tilt
+                position after closing the cover (UI/HA calls).
+        """
+        self._tilt_duration = tilt_duration.total_milliseconds  # Czas trwania ruchu lameli
+        self._initial_tilt_position = float(restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"]))
+
+        position = float(restored_state.get("position", DEFAULT_RESTORED_STATE["position"]))
         # --- TILT ---
-        self._tilt_position = int(
-            restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"])
-        )
+        self._tilt_position = float(restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"]))
+
+        self._tilt_restore_after_close = tilt_restore_after_close
+        self._tilt_before_close: float | None = None
 
-        # self._actuator_activation_duration = (
-        #     actuator_activation_duration.total_milliseconds
-        # )  # ms
         self._last_tilt_update = 0.0
 
         super().__init__(
@@ -52,8 +54,15 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             **kwargs,
         )
         _LOGGER.debug(
-            "VenetianCover %s initialized: open_time=%dms, close_time=%dms, tilt_duration=%dms, position=%d%%, tilt=%d%%",
-            self._id, self._open_time, self._close_time, self._tilt_duration, position, self._tilt_position
+            "VenetianCover %s initialized: open_time=%dms, close_time=%dms, tilt_duration=%dms, "
+            "position=%d%%, tilt=%d%%, tilt_restore=%s",
+            self._id,
+            self._open_time,
+            self._close_time,
+            self._tilt_duration,
+            position,
+            self._tilt_position,
+            self._tilt_restore_after_close,
         )
 
     def _move_cover(
@@ -69,20 +78,12 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         if direction == OPEN:
             relay = self._open_relay
             total_steps = 100 - self._position
-            total_tilt_step = (
-                tilt_delta
-                if target_tilt_position is not None
-                else 100 - self._initial_tilt_position
-            )
+            total_tilt_step = tilt_delta if target_tilt_position is not None else 100 - self._initial_tilt_position
 
         elif direction == CLOSE:
             relay = self._close_relay
             total_steps = self._position
-            total_tilt_step = (
-                tilt_delta
-                if target_tilt_position is not None
-                else self._initial_tilt_position
-            )
+            total_tilt_step = tilt_delta if target_tilt_position is not None else self._initial_tilt_position
         else:
             return
         if target_tilt_position is not None:
@@ -93,9 +94,7 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
         if total_steps == 0 or duration == 0:
             self._current_operation = IDLE
-            self._loop.call_soon_threadsafe(
-                self.send_state, self.state, self.json_position
-            )
+            self._loop.call_soon_threadsafe(self.send_state, self.state, self.json_position)
             return
 
         # Calculate actual duration based on remaining distance
@@ -111,17 +110,11 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         needed_tilt_duration = tilt_duration * (total_tilt_step / 100)
         if target_tilt_position is None:
             tilt_delta = 1.0
-            
 
         while not self._stop_event.is_set():
-            current_time = (
-                time.monotonic()
-            )  # Pobierz aktualny czas tylko raz na iterację
-            elapsed_time = (
-                current_time - start_time
-            ) * 1000  # Konwersja na milisekundy
-
-           
+            current_time = time.monotonic()  # Pobierz aktualny czas tylko raz na iterację
+            elapsed_time = (current_time - start_time) * 1000  # Konwersja na milisekundy
+
             if elapsed_time < needed_tilt_duration:
                 tilt_progress = elapsed_time / needed_tilt_duration if needed_tilt_duration > 0 else 1.0
                 progress = 0.0
@@ -135,8 +128,10 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
                 # Obliczanie _tilt_position dla kierunku OPEN
                 if target_tilt_position is not None:
-                    self._tilt_position = min(target_tilt_position, self._initial_tilt_position + tilt_progress * tilt_delta)
-                else: # Fallback jeśli nie ma target_tilt_position
+                    self._tilt_position = min(
+                        target_tilt_position, self._initial_tilt_position + tilt_progress * tilt_delta
+                    )
+                else:  # Fallback jeśli nie ma target_tilt_position
                     self._tilt_position = min(
                         100.0, self._initial_tilt_position + tilt_progress * (100 - self._initial_tilt_position)
                     )
@@ -146,24 +141,23 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
                 # Obliczanie _tilt_position dla kierunku CLOSE
                 if target_tilt_position is not None:
-                    self._tilt_position = max(target_tilt_position, self._initial_tilt_position - tilt_progress * tilt_delta)
-                else: # Fallback jeśli nie ma target_tilt_position
+                    self._tilt_position = max(
+                        target_tilt_position, self._initial_tilt_position - tilt_progress * tilt_delta
+                    )
+                else:  # Fallback jeśli nie ma target_tilt_position
                     self._tilt_position = max(
                         0.0, self._initial_tilt_position - tilt_progress * self._initial_tilt_position
                     )
 
             self._last_timestamp = time.time()  # Wall clock for display
             if current_time - self._last_update_time >= 1:
-                self._loop.call_soon_threadsafe(
-                    self.send_state, self.state, self.json_position
-                )
+                self._loop.call_soon_threadsafe(self.send_state, self.state, self.json_position)
                 self._last_update_time = current_time
 
-            if target_tilt_position is not None and ((
-                direction == OPEN and self._tilt_position >= target_tilt_position
-            ) or (
-                direction == CLOSE and self._tilt_position <= target_tilt_position
-            )):
+            if target_tilt_position is not None and (
+                (direction == OPEN and self._tilt_position >= target_tilt_position)
+                or (direction == CLOSE and self._tilt_position <= target_tilt_position)
+            ):
                 break
 
             if target_position is not None and (
@@ -183,12 +177,32 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         # Send relay state to WebSocket (not MQTT - that's handled by output_type check)
         self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
         self._current_operation = IDLE
-        self._loop.call_soon_threadsafe(
-            self.send_state_and_save, self.json_position
-        )
-        self._last_update_time = (
-            time.monotonic()
-        )  # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
+        self._loop.call_soon_threadsafe(self.send_state_and_save, self.json_position)
+        self._last_update_time = time.monotonic()  # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
+
+        # Tilt restore: schedule tilt recovery on the event loop.
+        # Skip when position reached 0% (fully closed) or 100% (fully open)
+        # — at extremes, restoring tilt contradicts user intent.
+        if self._tilt_restore_after_close and self._tilt_before_close is not None:
+            restore_tilt = self._tilt_before_close
+            self._tilt_before_close = None
+            at_extreme = self._position <= 0 or self._position >= 100
+            if not at_extreme and restore_tilt > 0 and abs(self._tilt_position - restore_tilt) >= 1:
+                _LOGGER.info(
+                    "VenetianCover %s: restoring tilt from %d%% to %d%%",
+                    self._id,
+                    round(self._tilt_position),
+                    round(restore_tilt),
+                )
+                self._loop.call_soon_threadsafe(
+                    lambda t=restore_tilt: asyncio.ensure_future(self.set_tilt(int(round(t))))
+                )
+            elif at_extreme:
+                _LOGGER.debug(
+                    "VenetianCover %s: skipping tilt restore at extreme position %d%%",
+                    self._id,
+                    round(self._position),
+                )
 
     async def set_tilt(self, tilt_position: int) -> None:
         """Setting tilt position."""
@@ -200,31 +214,36 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
         tilt_diff = abs(self._tilt_position - tilt_position)
         estimated_time_s = tilt_diff / 100 * self._tilt_duration / 1000
-        
+
         if tilt_position > self._tilt_position:
             _LOGGER.info(
                 "Setting tilt %s from %d%% to %d%% (OPENING). Estimated time: %.2fs (tilt_duration=%dms)",
-                self._id, self._tilt_position, tilt_position, estimated_time_s, self._tilt_duration
-            )
-            await self.run_cover(
-                current_operation=OPENING, target_tilt_position=tilt_position
+                self._id,
+                self._tilt_position,
+                tilt_position,
+                estimated_time_s,
+                self._tilt_duration,
             )
+            await self.run_cover(current_operation=OPENING, target_tilt_position=tilt_position)
         elif tilt_position < self._tilt_position:
             _LOGGER.info(
                 "Setting tilt %s from %d%% to %d%% (CLOSING). Estimated time: %.2fs (tilt_duration=%dms)",
-                self._id, self._tilt_position, tilt_position, estimated_time_s, self._tilt_duration
-            )
-            await self.run_cover(
-                current_operation=CLOSING, target_tilt_position=tilt_position
+                self._id,
+                self._tilt_position,
+                tilt_position,
+                estimated_time_s,
+                self._tilt_duration,
             )
+            await self.run_cover(current_operation=CLOSING, target_tilt_position=tilt_position)
 
     @property
     def json_position(self) -> PositionDict:
-        return {"position": round(self.position, 0), "tilt": self.tilt}
+        """Return position dict with int values for API/MQTT/WebUI."""
+        return {"position": self.position, "tilt": self.tilt}
 
     @property
     def tilt(self) -> int:
-        return int(round(self._tilt_position, 0))
+        return round(self._tilt_position)
 
     @property
     def tilt_position(self) -> int:
@@ -245,6 +264,11 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
     def kind(self) -> str:
         return "venetian"
 
+    @property
+    def saved_position(self) -> SavedPositionDict:
+        """Raw float position for disk persistence (includes tilt)."""
+        return {"position": self._position, "tilt": self._tilt_position}
+
     async def set_cover_tilt_position(self, position: int) -> None:
         """Set cover tilt position (required by BaseVenetianCoverABC)."""
         await self.set_tilt(position)
@@ -254,7 +278,10 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         estimated_time_s = (100 - self._tilt_position) / 100 * self._tilt_duration / 1000
         _LOGGER.info(
             "Opening tilt cover %s from %d%%. Estimated time: %.2fs (tilt_duration=%dms)",
-            self._id, self._tilt_position, estimated_time_s, self._tilt_duration
+            self._id,
+            self._tilt_position,
+            estimated_time_s,
+            self._tilt_duration,
         )
         await self.set_tilt(tilt_position=100)
 
@@ -263,16 +290,76 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         estimated_time_s = self._tilt_position / 100 * self._tilt_duration / 1000
         _LOGGER.info(
             "Closing tilt cover %s from %d%%. Estimated time: %.2fs (tilt_duration=%dms)",
-            self._id, self._tilt_position, estimated_time_s, self._tilt_duration
+            self._id,
+            self._tilt_position,
+            estimated_time_s,
+            self._tilt_duration,
         )
         await self.set_tilt(tilt_position=0)
 
+    def _save_tilt_for_restore(self) -> None:
+        """Save current tilt position for later restoration.
+
+        Called before any closing movement. Determines whether to save
+        based on the call source:
+        - UI/HA calls: uses tilt_restore_after_close setting
+        - Action calls: uses _action_tilt_restore flag (set by executor)
+        """
+        if self._from_action:
+            should_restore = self._action_tilt_restore
+        else:
+            should_restore = self._tilt_restore_after_close
+
+        if should_restore and self._tilt_position > 0:
+            self._tilt_before_close = self._tilt_position
+            _LOGGER.debug(
+                "VenetianCover %s: saving tilt=%d%% before close",
+                self._id,
+                round(self._tilt_position),
+            )
+        else:
+            self._tilt_before_close = None
+
+    async def close(self) -> None:
+        """Close venetian cover.
+
+        If tilt_restore_after_close is enabled, saves the current tilt
+        position so it can be restored after the closing movement finishes.
+        """
+        self._save_tilt_for_restore()
+        await super().close()
+
+    async def set_cover_position(self, position: int) -> None:
+        """Set cover position with tilt restore support.
+
+        When moving to a lower position (closing direction) and
+        tilt_restore_after_close is enabled, saves the current tilt
+        so it can be restored after the movement finishes.
+
+        Args:
+            position: Target position (0-100).
+        """
+        if position < self._position:
+            self._save_tilt_for_restore()
+        else:
+            self._tilt_before_close = None
+        await super().set_cover_position(position)
+
+    async def open(self) -> None:
+        """Open venetian cover.
+
+        Clears any saved tilt-before-close value since opening
+        resets the tilt to 100% naturally.
+        """
+        self._tilt_before_close = None
+        await super().open()
+
     def update_config_times(self, config: dict) -> None:
         """Update cover timing configuration.
-        
+
         Args:
             config: Dictionary with timing values as TimePeriod objects.
-                   Keys: open_time, close_time, tilt_duration
+                   Keys: open_time, close_time, tilt_duration, tilt_restore_after_close
         """
         if "open_time" in config:
             self._open_time = config["open_time"].total_milliseconds
@@ -280,17 +367,20 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             self._close_time = config["close_time"].total_milliseconds
         if "tilt_duration" in config and config["tilt_duration"]:
             self._tilt_duration = config["tilt_duration"].total_milliseconds
+        if "tilt_restore_after_close" in config:
+            self._tilt_restore_after_close = bool(config["tilt_restore_after_close"])
 
     async def run_cover(
         self,
         current_operation: str,
         target_position: int | None = None,
         target_tilt_position: int | None = None,
+        **kwargs,
     ) -> None:
         if self._movement_thread and self._movement_thread.is_alive():
             _LOGGER.warning("Cover movement is already in progress. Stopping first.")
             await self.stop()
-        
+
         # If STOP was requested, don't start new movement
         if current_operation == STOP:
             await self.stop()
@@ -300,9 +390,7 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         self._initial_position = self._position
         self._initial_tilt_position = self._tilt_position
         self._stop_event.clear()
-        self._last_update_time = (
-            time.monotonic()
-        )  # Inicjalizacja czasu ostatniej aktualizacji
+        self._last_update_time = time.monotonic()  # Inicjalizacja czasu ostatniej aktualizacji
 
         if current_operation == OPENING:
             self._movement_thread = threading.Thread(

{boneio-1.3.1.dev2 → boneio-1.4.0}/boneio/components/group/output_group.py

@@ -84,7 +84,7 @@ class OutputGroup(BasicOutput):
             self._state = state
             self._loop.create_task(self.async_send_state())
 
-    async def async_turn_on(self, timestamp=None) -> None:
+    async def async_turn_on(self, timestamp=None) -> bool:
         """Turn on all members in the group.
         
         Executes turn_on sequentially to prevent I2C bus contention
@@ -92,9 +92,16 @@ class OutputGroup(BasicOutput):
         
         Args:
             timestamp: Optional timestamp for the operation
+
+        Returns:
+            True if all members were turned on, False if any was blocked.
         """
+        all_ok = True
         for x in self._group_members:
-            await x.async_turn_on(timestamp=timestamp)
+            result = await x.async_turn_on(timestamp=timestamp)
+            if not result:
+                all_ok = False
+        return all_ok
 
     async def async_turn_off(self, timestamp=None) -> None:
         """Turn off all members in the group.

{boneio-1.3.1.dev2 → boneio-1.4.0}/boneio/components/input/__init__.py

@@ -2,12 +2,18 @@
 
 This module provides high-level input components that combine
 hardware GPIO drivers with business logic, MQTT, and Home Assistant integration.
+
+Sub-packages:
+    remote: Virtual inputs from remote devices (ESPHome API, CAN bus, …)
 """
 
 from boneio.components.input.binary_sensor import GpioInputBinarySensor
 from boneio.components.input.event import GpioEventButton
+from boneio.components.input.remote import ESPHomeBinarySensorInput, RemoteInputBase
 
 __all__ = [
     "GpioInputBinarySensor",
     "GpioEventButton",
+    "ESPHomeBinarySensorInput",
+    "RemoteInputBase",
 ]

{boneio-1.3.1.dev2 → boneio-1.4.0}/boneio/components/input/detectors.py

@@ -603,6 +603,93 @@ class MultiClickDetector:
                 )
 
 
+    def handle_raw_state(self, is_pressed: bool) -> None:
+        """Process a raw state change for virtual/remote inputs.
+
+        Uses wall-clock time instead of kernel GPIO timestamps.
+        Suitable for ESPHome binary sensors and other network-based inputs
+        that don't generate gpiod edge events.
+
+        Args:
+            is_pressed: True if the input is now active (pressed)
+        """
+        import time
+
+        timestamp_s = time.time()
+
+        if is_pressed:
+            # Debounce
+            if (
+                self._state.last_press_ts
+                and (timestamp_s - self._state.last_press_ts) < self._debounce_seconds
+            ):
+                return
+
+            _LOGGER.debug("RAW PRESSED: %s (%s)", self._name, self._pin)
+            self._state.last_press_ts = timestamp_s
+            self._state.last_press_loop_ts = self._loop.time()
+            self._state.last_release_ts = None
+
+            if self._state.finalizer:
+                self._state.finalizer.cancel()
+                self._state.finalizer = None
+                self._state.finalizer_scheduled_loop_ts = None
+
+            if self._sequence_mode == "exclusive" and self._state.pending_click_timer:
+                self._state.pending_click_timer.cancel()
+                self._state.pending_click_timer = None
+
+            self._state.long_press_scheduled_loop_ts = self._loop.time()
+            self._state.long_press_timer = self._loop.call_later(
+                self._hold_threshold,
+                self._detect_long_press,
+            )
+        else:
+            # Debounce
+            if (
+                self._state.last_release_ts
+                and (timestamp_s - self._state.last_release_ts)
+                < self._debounce_seconds
+            ):
+                return
+            if (
+                self._state.last_press_ts
+                and (timestamp_s - self._state.last_press_ts)
+                < self._debounce_seconds
+            ):
+                return
+
+            _LOGGER.debug("RAW RELEASED: %s (%s)", self._name, self._pin)
+            self._state.last_release_ts = timestamp_s
+
+            if self._state.long_hold_periodic_timer:
+                self._state.long_hold_periodic_timer.cancel()
+                self._state.long_hold_periodic_timer = None
+
+                if self._state.last_press_loop_ts:
+                    duration = self._loop.time() - self._state.last_press_loop_ts
+                    self._emit_click(LONG, duration)
+
+                def _reset():
+                    self._state.executed_long_actions = set()
+                    self._state.last_repeat_times = {}
+
+                self._loop.call_later(0.05, _reset)
+
+            if self._state.long_press_timer:
+                self._state.long_press_timer.cancel()
+                self._state.long_press_timer = None
+                self._state.long_press_scheduled_loop_ts = None
+
+                self._state.click_count += 1
+
+                self._state.finalizer_scheduled_loop_ts = self._loop.time()
+                self._state.finalizer = self._loop.call_later(
+                    self._multiclick_window,
+                    self._finalize_clicks,
+                )
+
+
 class BinarySensorDetector:
     """Detects binary state changes (PRESSED/RELEASED) with software debounce."""