boneIO 1.1.0.dev1__tar.gz → 1.1.0.dev3__tar.gz

{boneio-1.1.0.dev1/boneio.egg-info → boneio-1.1.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.1.0.dev1
+Version: 1.1.0.dev3
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0
@@ -13,6 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: smbus2==0.4.3
 Requires-Dist: aiomqtt==2.4.0
+Requires-Dist: aiohttp==3.13.3
 Requires-Dist: Cerberus==1.3.7
 Requires-Dist: colorlog==6.9.0
 Requires-Dist: luma-core==2.5.1

{boneio-1.1.0.dev1 → boneio-1.1.0.dev3}/boneio/components/input/detectors.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import logging
 from collections.abc import Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import cast
 
 import gpiod
@@ -43,6 +43,9 @@ class ClickState:
     pending_click_type: str | None = None
     pending_click_duration: float | None = None
     pending_click_timer: asyncio.TimerHandle | None = None
+    # 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
 
 
 @dataclass
@@ -352,10 +355,14 @@ class MultiClickDetector:
         return None
 
     def _detect_long_press(self) -> None:
-        """Detect and report a long press."""
-        duration = None
-        if self._state.last_press_ts and self._state.last_release_ts:
-            duration = self._state.last_release_ts - self._state.last_press_ts
+        """Detect and report a long press and start periodic updates."""
+        if not self._state.last_press_ts:
+            return
+        
+        # Reset executed actions for new long press
+        self._state.executed_long_actions = set()
+        
+        duration = self._loop.time() - self._state.last_press_ts
         
         _LOGGER.info("Detected LONG press on %s (%s)", self._name, self._pin)
         
@@ -365,6 +372,36 @@ class MultiClickDetector:
         
         # Emit the long press (may also trigger sequence)
         self._emit_click(LONG, duration)
+        
+        # Start periodic timer for subsequent long events
+        self._state.long_hold_periodic_timer = self._loop.call_later(
+            0.2,  # 200ms
+            self._send_periodic_long_event
+        )
+    
+    def _send_periodic_long_event(self) -> None:
+        """Send periodic 'long' event with updated duration."""
+        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_ts
+        
+        _LOGGER.debug(
+            "Periodic long event on %s (%s), duration=%.3fs",
+            self._name,
+            self._pin,
+            duration
+        )
+        
+        # Emit 'long' event with updated duration
+        self._emit_click(LONG, duration)
+        
+        # Schedule next update
+        self._state.long_hold_periodic_timer = self._loop.call_later(
+            0.2,
+            self._send_periodic_long_event
+        )
 
     def handle_event(self, event: gpiod.EdgeEvent) -> None:
         """Process a GPIO edge event and update click state.
@@ -396,6 +433,7 @@ class MultiClickDetector:
 
             _LOGGER.debug("PRESSED: %s (%s)", self._name, self._pin)
             self._state.last_press_ts = timestamp_s
+            self._state.last_release_ts = None  # Reset release timestamp for new press
 
             # Cancel any pending finalizer for a multi-click sequence
             if self._state.finalizer:
@@ -449,6 +487,33 @@ class MultiClickDetector:
                 "EXISTS" if self._state.long_press_timer else "None",
             )
 
+            # Cancel periodic timer if running
+            if self._state.long_hold_periodic_timer:
+                self._state.long_hold_periodic_timer.cancel()
+                self._state.long_hold_periodic_timer = None
+                
+                # Send final 'long' event with final duration
+                # 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_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,
+                        duration,
+                        self._state.executed_long_actions
+                    )
+                    self._emit_click(LONG, duration)
+                
+                # Reset executed actions with a small delay to allow async handler
+                # to read the current state. The handler uses create_task() so we
+                # need to give it time to start and read executed_long_actions.
+                def reset_executed_actions():
+                    self._state.executed_long_actions = set()
+                    _LOGGER.debug("Reset executed_long_actions for %s", self._name)
+                self._loop.call_later(0.05, reset_executed_actions)
+            
             # If a long press timer exists, it means it hasn't fired yet.
             # This is a short click.
             if self._state.long_press_timer:

{boneio-1.1.0.dev1 → boneio-1.1.0.dev3}/boneio/core/manager/inputs.py

@@ -22,6 +22,7 @@ from boneio.const import (
     ID,
     INPUT,
     INPUT_SENSOR,
+    LONG,
     PIN,
     PRESSED,
     RELEASED,
@@ -686,8 +687,48 @@ class InputManager:
         # Send event to MQTT for Home Assistant
         self._publish_input_event_to_mqtt(input_instance, event)
         
-        # Execute actions for this input event (skip if publish_only)
-        if actions and not event.publish_only:
+        # Execute actions with duration threshold support
+        if actions and event.click_type == LONG:
+            # Get executed_actions from detector state
+            detector = getattr(input_instance, '_detector', None)
+            executed_actions = getattr(detector._state, 'executed_long_actions', set()) if detector else set()
+            
+            # Lazy evaluation: Check if there are any actions with duration thresholds
+            # or any actions without thresholds that haven't been executed yet
+            has_pending_actions = False
+            for idx, action in enumerate(actions):
+                if idx in executed_actions:
+                    continue  # Already executed
+                min_dur = action.get("min_duration")
+                max_dur = action.get("max_duration")
+                if min_dur is not None or max_dur is not None:
+                    # Has duration thresholds - might need to execute
+                    has_pending_actions = True
+                    break
+                elif not executed_actions:
+                    # No thresholds and nothing executed yet - first event
+                    has_pending_actions = True
+                    break
+            
+            # Skip execute_actions if no pending actions (optimization for periodic events)
+            if not has_pending_actions:
+                _LOGGER.debug(
+                    "Skipping execute_actions for %s - no pending actions (executed=%s)",
+                    event.entity_id, executed_actions
+                )
+            else:
+                # Execute actions with duration checking
+                new_executed = await self._manager.execute_actions(
+                    actions=actions,
+                    duration=event.duration,
+                    executed_actions=executed_actions,
+                )
+                
+                # Update detector state
+                if detector:
+                    detector._state.executed_long_actions = new_executed
+        elif actions:
+            # Non-long events - execute all actions normally
             await self._manager.execute_actions(actions=actions)
 
     async def send_ha_autodiscovery(self) -> None:

{boneio-1.1.0.dev1 → boneio-1.1.0.dev3}/boneio/core/manager/manager.py

@@ -26,6 +26,7 @@ from boneio.const import (
     REMOTE_OUTPUT,
     SET_BRIGHTNESS,
     STATE,
+    TOGGLE,
     cover_actions,
     output_actions,
 )
@@ -423,17 +424,28 @@ class Manager:
                     # Support both new 'boneio_output' and legacy 'pin' for backward compatibility
                     entity_id = action_definition.get("boneio_output") or action_definition.get("pin")
                     stripped_entity_id = strip_accents(entity_id)
-                    action_output = action_definition.get("action_output")
+                    action_output = action_definition.get("action_output", TOGGLE)
                     output = self.outputs.get_output(stripped_entity_id) or self.outputs.get_output_group(stripped_entity_id)
                     action_to_execute = output_actions.get(action_output)
                     if output and action_to_execute:
                         _f = getattr(output, action_to_execute, None)
                         if _f:
-                            parsed_actions[click_type].append({
+                            parsed_action = {
                                 "action": action,
                                 "pin": stripped_entity_id,
                                 "action_to_execute": action_to_execute,
-                            })
+                            }
+                            # Copy duration thresholds for long press actions
+                            if action_definition.get("min_duration") is not None:
+                                parsed_action["min_duration"] = action_definition["min_duration"]
+                            if action_definition.get("max_duration") is not None:
+                                parsed_action["max_duration"] = action_definition["max_duration"]
+                            _LOGGER.debug(
+                                "Parsed OUTPUT action for %s: output=%s, action=%s, min_dur=%s, max_dur=%s",
+                                pin, stripped_entity_id, action_to_execute,
+                                parsed_action.get("min_duration"), parsed_action.get("max_duration")
+                            )
+                            parsed_actions[click_type].append(parsed_action)
                             continue
                     _LOGGER.warning("Device %s for action in %s not found. Omitting.", entity_id, pin)
                     
@@ -441,19 +453,25 @@ class Manager:
                     # Support both new 'boneio_cover' and legacy 'pin' for backward compatibility
                     entity_id = action_definition.get("boneio_cover") or action_definition.get("pin")
                     stripped_entity_id = strip_accents(entity_id)
-                    action_cover = action_definition.get("action_cover")
+                    action_cover = action_definition.get("action_cover", TOGGLE)
                     extra_data = action_definition.get("data", {})
                     cover = self.covers.get_cover(stripped_entity_id)
                     action_to_execute = cover_actions.get(action_cover)
                     if cover and action_to_execute:
                         _f = getattr(cover, action_to_execute, None)
                         if _f:
-                            parsed_actions[click_type].append({
+                            parsed_action = {
                                 "action": action,
                                 "pin": stripped_entity_id,
                                 "action_to_execute": action_to_execute,
                                 "extra_data": extra_data,
-                            })
+                            }
+                            # Copy duration thresholds for long press actions
+                            if action_definition.get("min_duration") is not None:
+                                parsed_action["min_duration"] = action_definition["min_duration"]
+                            if action_definition.get("max_duration") is not None:
+                                parsed_action["max_duration"] = action_definition["max_duration"]
+                            parsed_actions[click_type].append(parsed_action)
                             continue
                     _LOGGER.warning("Device %s for action not found. Omitting.", entity_id)
                     
@@ -461,11 +479,17 @@ class Manager:
                     action_mqtt_msg = action_definition.get("action_mqtt_msg")
                     action_topic = action_definition.get(TOPIC)
                     if action_topic and action_mqtt_msg:
-                        parsed_actions[click_type].append({
+                        parsed_action = {
                             "action": action,
                             "action_mqtt_msg": action_mqtt_msg,
                             "action_topic": action_topic,
-                        })
+                        }
+                        # Copy duration thresholds for long press actions
+                        if action_definition.get("min_duration") is not None:
+                            parsed_action["min_duration"] = action_definition["min_duration"]
+                        if action_definition.get("max_duration") is not None:
+                            parsed_action["max_duration"] = action_definition["max_duration"]
+                        parsed_actions[click_type].append(parsed_action)
                         continue
                     _LOGGER.warning("MQTT action missing topic or message for %s", pin)
                     
@@ -474,11 +498,17 @@ class Manager:
                     action_output = action_definition.get("action_output")
                     action_to_execute = output_actions.get(action_output.upper())
                     if boneio_id and action_to_execute:
-                        parsed_actions[click_type].append({
+                        parsed_action = {
                             "action": action,
                             "boneio_id": boneio_id,
                             "action_output": action_output,
-                        })
+                        }
+                        # Copy duration thresholds for long press actions
+                        if action_definition.get("min_duration") is not None:
+                            parsed_action["min_duration"] = action_definition["min_duration"]
+                        if action_definition.get("max_duration") is not None:
+                            parsed_action["max_duration"] = action_definition["max_duration"]
+                        parsed_actions[click_type].append(parsed_action)
                         continue
                     _LOGGER.warning("OUTPUT_OVER_MQTT action missing data for %s", pin)
                     
@@ -487,11 +517,17 @@ class Manager:
                     action_cover = action_definition.get("action_cover")
                     action_to_execute = cover_actions.get(action_cover.upper())
                     if boneio_id and action_to_execute:
-                        parsed_actions[click_type].append({
+                        parsed_action = {
                             "action": action,
                             "boneio_id": boneio_id,
                             "action_cover": action_cover,
-                        })
+                        }
+                        # Copy duration thresholds for long press actions
+                        if action_definition.get("min_duration") is not None:
+                            parsed_action["min_duration"] = action_definition["min_duration"]
+                        if action_definition.get("max_duration") is not None:
+                            parsed_action["max_duration"] = action_definition["max_duration"]
+                        parsed_actions[click_type].append(parsed_action)
                         continue
                     _LOGGER.warning("COVER_OVER_MQTT action missing data for %s", pin)
                 
@@ -501,12 +537,18 @@ class Manager:
                     output_id = action_definition.get("output_id")
                     action_output = action_definition.get("action_output", "TOGGLE")
                     if remote_device and output_id:
-                        parsed_actions[click_type].append({
+                        parsed_action = {
                             "action": action,
                             "remote_device": remote_device,
                             "output_id": output_id,
                             "action_output": action_output,
-                        })
+                        }
+                        # Copy duration thresholds for long press actions
+                        if action_definition.get("min_duration") is not None:
+                            parsed_action["min_duration"] = action_definition["min_duration"]
+                        if action_definition.get("max_duration") is not None:
+                            parsed_action["max_duration"] = action_definition["max_duration"]
+                        parsed_actions[click_type].append(parsed_action)
                         continue
                     _LOGGER.warning("REMOTE_OUTPUT action missing remote_device or output_id for %s", pin)
                 
@@ -517,13 +559,19 @@ class Manager:
                     action_cover = action_definition.get("action_cover", "TOGGLE")
                     extra_data = action_definition.get("data", {})
                     if remote_device and cover_id:
-                        parsed_actions[click_type].append({
+                        parsed_action = {
                             "action": action,
                             "remote_device": remote_device,
                             "cover_id": cover_id,
                             "action_cover": action_cover,
                             "extra_data": extra_data,
-                        })
+                        }
+                        # Copy duration thresholds for long press actions
+                        if action_definition.get("min_duration") is not None:
+                            parsed_action["min_duration"] = action_definition["min_duration"]
+                        if action_definition.get("max_duration") is not None:
+                            parsed_action["max_duration"] = action_definition["max_duration"]
+                        parsed_actions[click_type].append(parsed_action)
                         continue
                     _LOGGER.warning("REMOTE_COVER action missing remote_device or cover_id for %s", pin)
                     
@@ -531,18 +579,58 @@ class Manager:
 
     async def execute_actions(
         self,
-        actions: list
-    ) -> None:
+        actions: list,
+        duration: float | None = None,
+        executed_actions: set[int] | None = None,
+    ) -> set[int]:
         """Execute list of actions.
         
         Args:
             actions: List of actions to execute
+            duration: Current duration in seconds (for long press threshold checking)
+            executed_actions: Set of action indices already executed (for long press)
+        
+        Returns:
+            Set of action indices that were executed
         """
+        if executed_actions is None:
+            executed_actions = set()
         
+        duration_ms = (duration or 0) * 1000  # Convert to ms
         
         start_time = time.time()
         
-        for action_definition in actions:
+        for idx, action_definition in enumerate(actions):
+            # Skip if already executed
+            if idx in executed_actions:
+                _LOGGER.debug("Action %d already executed, skipping", idx)
+                continue
+            
+            # Check duration thresholds
+            min_dur = action_definition.get("min_duration")  # ms
+            max_dur = action_definition.get("max_duration")  # ms
+            
+            _LOGGER.debug(
+                "Checking action %d: min_dur=%s, max_dur=%s, duration_ms=%.1f, executed=%s",
+                idx, min_dur, max_dur, duration_ms, executed_actions
+            )
+            
+            if min_dur is not None or max_dur is not None:
+                # Action has duration thresholds
+                if min_dur is not None and duration_ms < min_dur:
+                    _LOGGER.debug("Action %d: duration %.1fms < min_dur %dms, skipping", idx, duration_ms, min_dur)
+                    continue  # Duration too short
+                if max_dur is not None and duration_ms >= max_dur:
+                    _LOGGER.debug("Action %d: duration %.1fms >= max_dur %dms, skipping", idx, duration_ms, max_dur)
+                    continue  # Duration too long
+                _LOGGER.debug("Action %d: duration %.1fms in range [%s, %s), executing", idx, duration_ms, min_dur, max_dur)
+            else:
+                # Action without thresholds - execute only once (on first long event)
+                # Check if THIS specific action was already executed, not just any action
+                if idx in executed_actions:
+                    _LOGGER.debug("Action %d: no thresholds, already executed, skipping", idx)
+                    continue
+                _LOGGER.debug("Action %d: no thresholds, not yet executed, executing", idx)
             action = action_definition.get("action")
             
             if action == MQTT:
@@ -610,7 +698,7 @@ class Manager:
                 )
             
             elif action == REMOTE_OUTPUT:
-                # Control output on remote device
+                # Control output on remote device (supports ESPHome lights with brightness/color and WLED effects)
                 remote_device_id = action_definition.get("remote_device")
                 output_id = action_definition.get("output_id")
                 action_output = action_definition.get("action_output", "TOGGLE")
@@ -618,6 +706,14 @@ class Manager:
                     device_id=remote_device_id,
                     output_id=output_id,
                     action=action_output,
+                    brightness=action_definition.get("brightness"),
+                    color_temp=action_definition.get("color_temp"),
+                    rgb=action_definition.get("rgb"),
+                    transition=action_definition.get("transition"),
+                    effect=action_definition.get("effect"),
+                    palette=action_definition.get("palette"),
+                    effect_speed=action_definition.get("effect_speed"),
+                    effect_intensity=action_definition.get("effect_intensity"),
                 )
             
             elif action == REMOTE_COVER:
@@ -632,6 +728,11 @@ class Manager:
                     action=action_cover,
                     **extra_data,
                 )
+            
+            # Mark action as executed
+            executed_actions.add(idx)
+        
+        return executed_actions
 
     def _reload_logger(self) -> None:
         """Reload logger configuration from config file.
@@ -647,16 +748,17 @@ class Manager:
         configure_logger(log_config, debug=0)
         _LOGGER.info("Logger configuration reloaded successfully")
 
-    def _reload_remote_devices(self) -> None:
+    async def _reload_remote_devices(self) -> None:
         """Reload remote devices configuration from config file.
         
         This allows hot-reloading of remote devices without restarting the application.
+        Handles ESPHome connections properly (stops old, starts new).
         """
         config = self._config_helper.get_config()
         remote_devices_config = config.get("remote_devices", [])
         
         _LOGGER.info("Reloading remote devices configuration")
-        self.remote_devices.reload(remote_devices_config)
+        await self.remote_devices.reload(remote_devices_config)
         _LOGGER.info("Remote devices configuration reloaded successfully")
     
     async def publish_discovery(self) -> None: