boneIO 1.2.0__tar.gz → 1.2.0.dev2__tar.gz

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

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

boneio-1.2.0.dev2/boneio/components/cover/__init__.py

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

{boneio-1.2.0 → boneio-1.2.0.dev2}/boneio/components/cover/cover.py

@@ -16,11 +16,11 @@ from boneio.const import (
     OPEN,
     OPENING,
 )
-from boneio.core.events import EventBus
+from boneio.core.events import EventBus, async_track_point_in_time, utcnow
 from boneio.core.messaging import BasicMqtt
 from boneio.core.utils import TimePeriod
 from boneio.models import CoverState, PositionDict
-from boneio.components.output import BasicOutput
+from boneio.components.output import MCPOutput
 from boneio.models.events import CoverEvent
 
 _LOGGER = logging.getLogger(__name__)
@@ -30,8 +30,8 @@ class BaseCoverABC(ABC):
 
     @abstractmethod
     def __init__(self, id: str,
-        open_relay: BasicOutput,
-        close_relay: BasicOutput,
+        open_relay: MCPOutput,
+        close_relay: MCPOutput,
         state_save: Callable,
         open_time: TimePeriod,
         close_time: TimePeriod,
@@ -147,8 +147,8 @@ class BaseVenetianCoverABC:
 
 class BaseCover(BaseCoverABC, BasicMqtt):
     def __init__(self, id: str,
-        open_relay: BasicOutput,
-        close_relay: BasicOutput,
+        open_relay: MCPOutput,
+        close_relay: MCPOutput,
         state_save: Callable,
         open_time: TimePeriod,
         close_time: TimePeriod,
@@ -171,7 +171,6 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._position = position
         self._initial_position = None
         self._current_operation = IDLE
-        self._last_operation = CLOSING
         _LOGGER.debug(
             "BaseCover %s initialized: open_time=%dms, close_time=%dms, initial_position=%d%%",
             id, self._open_time, self._close_time, position
@@ -208,8 +207,6 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             # Send relay states to WebSocket (not MQTT - that's handled by output_type check)
             asyncio.create_task(self._open_relay.async_send_state())
             asyncio.create_task(self._close_relay.async_send_state())
-            if self._current_operation in (OPENING, CLOSING):
-                self._last_operation = self._current_operation
             self._current_operation = IDLE
             if not on_exit:
                 self.send_state(self.state, self.json_position)
@@ -222,7 +219,6 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             "Opening cover %s from position %d%%. Estimated time: %.1fs (open_time=%dms)",
             self._id, self._position, estimated_time_s, self._open_time
         )
-        self._last_operation = OPENING
         await self.run_cover(current_operation=OPENING)
         self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=OPENING)
 
@@ -234,7 +230,6 @@ class BaseCover(BaseCoverABC, BasicMqtt):
             "Closing cover %s from position %d%%. Estimated time: %.1fs (close_time=%dms)",
             self._id, self._position, estimated_time_s, self._close_time
         )
-        self._last_operation = CLOSING
         await self.run_cover(current_operation=CLOSING)
         self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=CLOSING)
 
@@ -263,16 +258,10 @@ class BaseCover(BaseCoverABC, BasicMqtt):
 
     async def toggle(self) -> None:
         _LOGGER.debug("Toggle cover %s from input.", self._id)
-        if self._current_operation != IDLE:
-            await self.stop()
-        elif self._position >= 100:
+        if self._position > 50:
             await self.close()
-        elif self._position <= 0:
-            await self.open()
-        elif self._last_operation == CLOSING:
-            await self.open()
         else:
-            await self.close()
+            await self.open()
 
     async def toggle_open(self) -> None:
         _LOGGER.debug("Toggle open cover %s from input.", self._id)
@@ -288,33 +277,6 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         else:
             await self.close()
 
-    async def smart_toggle(self, always_open_till: int = 50) -> None:
-        """Smart toggle with position threshold.
-
-        If cover is moving → stop.
-        If position <= always_open_till → open (to 100%).
-        If position > always_open_till → normal toggle (based on last_operation).
-
-        Args:
-            always_open_till: Position threshold (0-100%). Below or equal this
-                value the cover will always open. Above it, normal toggle applies.
-        """
-        _LOGGER.debug(
-            "Smart toggle cover %s (position=%d%%, threshold=%d%%)",
-            self._id, self._position, always_open_till,
-        )
-        if self._current_operation != IDLE:
-            await self.stop()
-        elif self._position <= always_open_till:
-            await self.open()
-        elif self._position >= 100:
-            await self.close()
-        elif self._position <= 0:
-            await self.open()
-        elif self._last_operation == CLOSING:
-            await self.open()
-        else:
-            await self.close()
 
     @property
     def state(self) -> str:

boneio-1.2.0.dev2/boneio/components/cover/previous.py

@@ -0,0 +1,354 @@
+"""Cover module."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from collections.abc import Callable
+
+from boneio.components.output import MCPOutput
+from boneio.const import (
+    CLOSE,
+    CLOSED,
+    CLOSING,
+    COVER,
+    IDLE,
+    OPEN,
+    OPENING,
+    STOP,
+)
+from boneio.core.events import EventBus
+from boneio.core.utils import TimePeriod
+from boneio.core.messaging import BasicMqtt
+from boneio.models import CoverState
+from boneio.models.events import CoverEvent
+
+_LOGGER = logging.getLogger(__name__)
+DEFAULT_RESTORED_STATE = {"position": 100}
+COVER_COMMANDS = {
+    OPEN: "open_cover",
+    CLOSE: "close_cover",
+    STOP: "stop",
+    "toggle": "toggle",
+    "toggle_open": "toggle_open",
+}
+
+
+class RelayHelper:
+    """Relay helper for cover either open/close."""
+
+    def __init__(self, relay: MCPOutput, time: TimePeriod) -> None:
+        """Initialize helper."""
+        self._relay = relay
+        self._steps = 100 / time.total_seconds
+
+    @property
+    def relay(self) -> MCPOutput:
+        """Get relay."""
+        return self._relay
+
+    @property
+    def steps(self) -> int:
+        """Get steps for each time."""
+        return int(self._steps)
+
+
+class PreviousCover(BasicMqtt):
+    """Cover class of boneIO"""
+
+    def __init__(
+        self,
+        id: str,
+        open_relay: MCPOutput,
+        close_relay: MCPOutput,
+        state_save: Callable,
+        open_time: TimePeriod,
+        close_time: TimePeriod,
+        event_bus: EventBus,
+        restored_state: dict = DEFAULT_RESTORED_STATE,
+        **kwargs,
+    ) -> None:
+        """Initialize cover class."""
+        self._loop = asyncio.get_event_loop()
+        self._id = id
+        super().__init__(id=id, name=id, topic_type=COVER, **kwargs)
+        self._lock = asyncio.Lock()
+        self._state_save = state_save
+        self._open = RelayHelper(relay=open_relay, time=open_time)
+        self._close = RelayHelper(relay=close_relay, time=close_time)
+        self._open_time = open_time
+        self._close_time = close_time
+        _LOGGER.debug(
+            "Cover %s initialized: open_time=%s (%dms), close_time=%s (%dms), open_steps=%d/s, close_steps=%d/s",
+            id, open_time, open_time.total_milliseconds, close_time, close_time.total_milliseconds,
+            self._open.steps, self._close.steps
+        )
+        self._set_position = None
+        self._current_operation = IDLE
+        self._position = float(restored_state.get("position", DEFAULT_RESTORED_STATE["position"]))
+        self._requested_closing = True
+        self._event_bus = event_bus
+        self._timer_handle = None
+        self._last_timestamp = 0.0
+        if self._position is None:
+            self._closed = True
+        else:
+            self._closed = self._position <= 0
+        self._event_bus.add_sigterm_listener(self.on_exit)
+        self._loop.call_soon_threadsafe(
+            self._loop.call_later,
+            0.5,
+            self.send_state,
+        )
+
+    async def run_cover(
+        self,
+        current_operation: str,
+    ) -> None:
+        """Run cover engine."""
+        if self._current_operation != IDLE:
+            self._stop_cover()
+        self._current_operation = current_operation
+
+        def get_relays():
+            if current_operation == OPENING:
+                return (self._open.relay, self._close.relay)
+            else:
+                return (self._close.relay, self._open.relay)
+
+        (relay, inverted_relay) = get_relays()
+        async with self._lock:
+            if inverted_relay.is_active:
+                inverted_relay.turn_off()
+            self._timer_handle = self._event_bus.add_every_second_listener(
+                f"{COVER}{self.id}", self.listen_cover
+            )
+            relay.turn_on()
+
+    def on_exit(self) -> None:
+        """Stop on exit."""
+        self._stop_cover(on_exit=True)
+
+    @property
+    def state(self) -> str:
+        """Current state of cover."""
+        return CLOSED if self._closed else OPEN
+
+    async def stop(self) -> None:
+        """Public Stop cover graceful."""
+        _LOGGER.info("Stopping cover %s.", self._id)
+        if self._current_operation != IDLE:
+            self._stop_cover(on_exit=False)
+        await self.async_send_state()
+
+    async def async_send_state(self) -> None:
+        """Send state to Websocket on action asynchronously."""
+        self._last_timestamp = time.time()
+        event = CoverState(
+            id=self.id,
+            name=self.name,
+            state=self.state,
+            position=int(round(self._position, 0)),
+            kind=self.kind,
+            timestamp=self.last_timestamp,
+            current_operation=self._current_operation,
+        )
+        self._event_bus.trigger_event(CoverEvent(entity_id=self.id, state=event))
+
+    def send_state(self) -> None:
+        """Send state of cover to mqtt."""
+        self._message_bus.send_message(
+            topic=f"{self._send_topic}/state", payload=self.state
+        )
+        pos = round(self._position, 0)
+        self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload={ "position": str(pos) })
+        self._state_save(value={"position": pos})
+
+    def _stop_cover(self, on_exit=False) -> None:
+        """Stop cover."""
+        self._open.relay.turn_off()
+        self._close.relay.turn_off()
+        if self._timer_handle is not None:
+            self._event_bus.remove_every_second_listener(f"{COVER}{self.id}")
+            self._timer_handle = None
+            self._set_position = None
+            if not on_exit:
+                self.send_state()
+        self._current_operation = IDLE
+
+    @property
+    def current_cover_position(self) -> int:
+        """Return the current position of the cover."""
+        return int(round(self._position, 0))
+
+    def listen_cover(self, *args) -> None:
+        """Listen for change in cover."""
+        if self._current_operation == IDLE:
+            return
+
+        def get_step():
+            """Get step for current operation."""
+            if self._requested_closing:
+                return -self._close.steps
+            else:
+                return self._open.steps
+
+        step = get_step()
+        self._position += step
+        rounded_pos = round(self._position, 0)
+        if self._set_position:
+            # Set position is only working for every 10%, so round to nearest 10.
+            # Except for start moving time
+            if (
+                self._requested_closing and rounded_pos < 95
+            ) or rounded_pos > 5:
+                rounded_pos = round(self._position, -1)
+        else:
+            if rounded_pos > 100:
+                rounded_pos = 100
+            elif rounded_pos < 0:
+                rounded_pos = 0
+        self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload={"position": str(rounded_pos)})
+        asyncio.create_task(self.async_send_state())
+        if rounded_pos == self._set_position or (
+            self._set_position is None
+            and (rounded_pos >= 100 or rounded_pos <= 0)
+        ):
+            self._position = rounded_pos
+            self._closed = self.current_cover_position <= 0
+            self._stop_cover()
+            return
+
+        self._closed = self.current_cover_position <= 0
+
+    async def close_cover(self) -> None:
+        """Close cover."""
+        if self._position == 0:
+            return
+        if self._position is None:
+            self._closed = True
+            return
+        estimated_time_s = self._position / self._close.steps
+        _LOGGER.info(
+            "Closing cover %s from position %d%%. Estimated time: %.1fs (close_time=%dms, steps=%d/s)",
+            self._id, self._position, estimated_time_s, self._close_time.total_milliseconds, self._close.steps
+        )
+
+        self._requested_closing = True
+        self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=CLOSING)
+        await self.run_cover(
+            current_operation=CLOSING,
+        )
+
+    async def open_cover(self) -> None:
+        """Open cover."""
+        if self._position == 100:
+            return
+        if self._position is None:
+            self._closed = False
+            return
+        estimated_time_s = (100 - self._position) / self._open.steps
+        _LOGGER.info(
+            "Opening cover %s from position %d%%. Estimated time: %.1fs (open_time=%dms, steps=%d/s)",
+            self._id, self._position, estimated_time_s, self._open_time.total_milliseconds, self._open.steps
+        )
+
+        self._requested_closing = False
+        self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=OPENING)
+        await self.run_cover(
+            current_operation=OPENING,
+        )
+
+    async def set_cover_position(self, position: int) -> None:
+        """Move cover to a specific position."""
+        set_position = round(position, -1)
+        if self._position == position or set_position == self._set_position:
+            return
+        if self._set_position:
+            self._stop_cover(on_exit=True)
+        self._set_position = set_position
+
+        self._requested_closing = set_position < self._position
+        current_operation = CLOSING if self._requested_closing else OPENING
+        
+        # Calculate estimated time
+        position_diff = abs(self._position - set_position)
+        if self._requested_closing:
+            steps = self._close.steps
+            time_config = self._close_time
+        else:
+            steps = self._open.steps
+            time_config = self._open_time
+        estimated_time_s = position_diff / steps if steps > 0 else 0
+        
+        _LOGGER.info(
+            "Setting cover %s position from %d%% to %d%% (%s). Estimated time: %.1fs (time_config=%dms, steps=%d/s)",
+            self._id, self._position, set_position, current_operation, 
+            estimated_time_s, time_config.total_milliseconds, steps
+        )
+        self._message_bus.send_message(
+            topic=f"{self._send_topic}/state", payload=current_operation
+        )
+        await self.run_cover(
+            current_operation=current_operation,
+        )
+
+    async def open(self) -> None:
+        _LOGGER.debug("Opening cover %s.", self._id)
+        await self.open_cover()
+
+    async def close(self) -> None:
+        _LOGGER.debug("Closing cover %s.", self._id)
+        await self.close_cover()
+
+    async def toggle(self) -> None:
+        _LOGGER.debug("Toggle cover %s from input.", self._id)
+        if self.state == CLOSED:
+            await self.close()
+        else:
+            await self.open()
+
+    async def toggle_open(self) -> None:
+        _LOGGER.debug("Toggle open cover %s from input.", self._id)
+        if self._current_operation != IDLE:
+            await self.stop()
+        else:
+            await self.open()
+
+    async def toggle_close(self) -> None:
+        _LOGGER.debug("Toggle close cover %s from input.", self._id)
+        if self._current_operation != IDLE:
+            await self.stop()
+        else:
+            await self.close()
+
+    @property
+    def last_timestamp(self) -> float:
+        return self._last_timestamp
+
+    @property
+    def position(self) -> int:
+        return int(round(self._position, 0))
+
+    @property
+    def current_operation(self) -> str:
+        return self._current_operation
+
+    @property
+    def kind(self) -> str:
+        return "previous"
+    
+    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
+        """
+        if "open_time" in config:
+            self._open_time = config["open_time"]
+            self._open = RelayHelper(relay=self._open.relay, time=config["open_time"])
+        if "close_time" in config:
+            self._close_time = config["close_time"]
+            self._close = RelayHelper(relay=self._close.relay, time=config["close_time"])

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

@@ -10,7 +10,7 @@ from boneio.const import CLOSE, CLOSING, IDLE, OPEN, OPENING, STOP
 from boneio.components.cover.cover import BaseCover
 from boneio.core.events import EventBus
 from boneio.core.utils import TimePeriod
-from boneio.components.output import BasicOutput
+from boneio.components.output import MCPOutput
 
 _LOGGER = logging.getLogger(__name__)
 DEFAULT_RESTORED_STATE = {"position": 100}
@@ -19,8 +19,8 @@ class TimeBasedCover(BaseCover):
     """Time-based cover algorithm similar to ESPHome."""
     def __init__(
         self,
-        open_relay: BasicOutput,
-        close_relay: BasicOutput,
+        open_relay: MCPOutput,
+        close_relay: MCPOutput,
         state_save: Callable,
         open_time: TimePeriod,
         close_time: TimePeriod,

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

@@ -31,7 +31,6 @@ class ClickState:
     """State for tracking multi-click detection."""
     click_count: int = 0
     last_press_ts: float | None = None
-    last_press_loop_ts: float | None = None  # Event loop time of last press (for duration calc)
     last_release_ts: float | None = None
     finalizer: asyncio.TimerHandle | None = None
     finalizer_scheduled_loop_ts: float | None = None
@@ -47,7 +46,6 @@ class ClickState:
     # Long hold periodic events
     long_hold_periodic_timer: asyncio.TimerHandle | None = None
     executed_long_actions: set[int] = field(default_factory=set)  # Track which long actions already executed
-    last_repeat_times: dict[int, float] = field(default_factory=dict)  # Track last execution time per repeat action index
 
 
 @dataclass
@@ -78,7 +76,6 @@ class MultiClickDetector:
         enable_triple_click: bool = False,
         name: str = "unknown",
         pin: str = "unknown",
-        max_long_press_seconds: float = 120.0,
     ):
         """Initialize multiclick detector.
         
@@ -94,7 +91,6 @@ class MultiClickDetector:
             enable_triple_click: Enable triple click detection (default: False)
             name: Name of the input
             pin: Pin name for logging
-            max_long_press_seconds: Safety timeout for long press in seconds (default: 120s)
         """
         self._loop = loop
         self._callback = callback
@@ -107,7 +103,6 @@ class MultiClickDetector:
         self._enable_triple_click = enable_triple_click
         self._name = name
         self._pin = pin
-        self._max_long_press_seconds = max_long_press_seconds
         self._state = ClickState()
         
         # Pre-compute which click types should be delayed in exclusive mode
@@ -361,14 +356,13 @@ class MultiClickDetector:
 
     def _detect_long_press(self) -> None:
         """Detect and report a long press and start periodic updates."""
-        if not self._state.last_press_loop_ts:
+        if not self._state.last_press_ts:
             return
         
         # Reset executed actions for new long press
         self._state.executed_long_actions = set()
-        self._state.last_repeat_times = {}
         
-        duration = self._loop.time() - self._state.last_press_loop_ts
+        duration = self._loop.time() - self._state.last_press_ts
         
         _LOGGER.info("Detected LONG press on %s (%s)", self._name, self._pin)
         
@@ -387,24 +381,11 @@ class MultiClickDetector:
     
     def _send_periodic_long_event(self) -> None:
         """Send periodic 'long' event with updated duration."""
-        if not self._state.last_press_loop_ts or self._state.last_release_ts:
+        if not self._state.last_press_ts or self._state.last_release_ts:
             # Button released or invalid state
             return
         
-        duration = self._loop.time() - self._state.last_press_loop_ts
-        
-        # Safety timeout: stop periodic events if duration exceeds max
-        if duration > self._max_long_press_seconds:
-            _LOGGER.warning(
-                "Safety timeout: long press on %s (%s) exceeded %.0fs (duration=%.1fs). "
-                "Possible missed RELEASE event. Forcing stop.",
-                self._name,
-                self._pin,
-                self._max_long_press_seconds,
-                duration,
-            )
-            self._force_stop_long_press()
-            return
+        duration = self._loop.time() - self._state.last_press_ts
         
         _LOGGER.debug(
             "Periodic long event on %s (%s), duration=%.3fs",
@@ -421,34 +402,6 @@ class MultiClickDetector:
             0.2,
             self._send_periodic_long_event
         )
-    
-    def _force_stop_long_press(self) -> None:
-        """Force stop a long press due to safety timeout (missed RELEASE).
-        
-        Cleans up all long-press related state as if a RELEASE event occurred.
-        """
-        if self._state.long_hold_periodic_timer:
-            self._state.long_hold_periodic_timer.cancel()
-            self._state.long_hold_periodic_timer = None
-        
-        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
-        
-        # Simulate release: use last_press_ts (kernel time) as base to stay
-        # consistent with debounce comparisons that use kernel timestamps
-        self._state.last_release_ts = self._state.last_press_ts or 0.0
-        
-        # Reset long press action tracking
-        self._state.executed_long_actions = set()
-        self._state.last_repeat_times = {}
-        
-        _LOGGER.info(
-            "Forced long press stop on %s (%s) - state cleaned up",
-            self._name,
-            self._pin,
-        )
 
     def handle_event(self, event: gpiod.EdgeEvent) -> None:
         """Process a GPIO edge event and update click state.
@@ -480,7 +433,6 @@ class MultiClickDetector:
 
             _LOGGER.debug("PRESSED: %s (%s)", self._name, self._pin)
             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
 
             # Cancel any pending finalizer for a multi-click sequence
@@ -516,7 +468,7 @@ class MultiClickDetector:
         elif event.event_type is event.Type.RISING_EDGE:
             # Button released (RISING_EDGE on BeagleBone with pull-up)
             
-            # Software debounce (release-vs-release)
+            # Software debounce
             if self._state.last_release_ts and (timestamp_s - self._state.last_release_ts) < self._debounce_seconds:
                 delta_ms = (timestamp_s - self._state.last_release_ts) * 1000
                 _LOGGER.debug(
@@ -525,20 +477,8 @@ class MultiClickDetector:
                     delta_ms,
                 )
                 return
-            
-            # Cross-debounce: ignore release too close to press (bounce on rising edge)
-            if self._state.last_press_ts and (timestamp_s - self._state.last_press_ts) < self._debounce_seconds:
-                delta_ms = (timestamp_s - self._state.last_press_ts) * 1000
-                _LOGGER.debug(
-                    "Ignoring bounced release on %s (%.3f ms since press, debounce %.3f ms)",
-                    self._name,
-                    delta_ms,
-                    self._debounce_seconds * 1000,
-                )
-                return
 
-            press_duration_ms = (timestamp_s - self._state.last_press_ts) * 1000 if self._state.last_press_ts else 0
-            _LOGGER.debug("RELEASED: %s (%s) after %.1f ms", self._name, self._pin, press_duration_ms)
+            _LOGGER.debug("RELEASED: %s (%s)", self._name, self._pin)
             self._state.last_release_ts = timestamp_s
             
             _LOGGER.debug(
@@ -556,8 +496,8 @@ class MultiClickDetector:
                 # Note: The callback creates an async task, so we need to delay
                 # the reset of executed_actions to allow the async handler to
                 # read the current state before it's cleared
-                if self._state.last_press_loop_ts:
-                    duration = self._loop.time() - self._state.last_press_loop_ts
+                if self._state.last_press_ts:
+                    duration = timestamp_s - self._state.last_press_ts
                     _LOGGER.debug(
                         "Sending final long event on release for %s, duration=%.3fs, executed_actions=%s",
                         self._name,
@@ -571,7 +511,6 @@ class MultiClickDetector:
                 # need to give it time to start and read executed_long_actions.
                 def reset_executed_actions():
                     self._state.executed_long_actions = set()
-                    self._state.last_repeat_times = {}
                     _LOGGER.debug("Reset executed_long_actions for %s", self._name)
                 self._loop.call_later(0.05, reset_executed_actions)