boneIO 1.1.0__tar.gz → 1.1.0.dev1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.1.0
+Version: 1.1.0.dev1
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0
@@ -13,7 +13,6 @@ 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 → boneio-1.1.0.dev1}/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, field
+from dataclasses import dataclass
 from typing import cast
 
 import gpiod
@@ -43,9 +43,6 @@ 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
@@ -355,14 +352,10 @@ class MultiClickDetector:
         return None
 
     def _detect_long_press(self) -> None:
-        """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
+        """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
         
         _LOGGER.info("Detected LONG press on %s (%s)", self._name, self._pin)
         
@@ -372,36 +365,6 @@ 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.
@@ -433,7 +396,6 @@ 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:
@@ -487,33 +449,6 @@ 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 → boneio-1.1.0.dev1}/boneio/core/config/config_helper.py

@@ -45,7 +45,6 @@ class ConfigHelper:
         config_file_path: str | None = None,
         send_boneio_autodiscovery: bool = True,
         receive_boneio_autodiscovery: bool = True,
-        update_channel: str = "stable",
     ):
         self._name = name
         
@@ -64,7 +63,6 @@ class ConfigHelper:
         self._ha_discovery_prefix = ha_discovery_prefix
         self._send_boneio_autodiscovery = send_boneio_autodiscovery
         self._receive_boneio_autodiscovery = receive_boneio_autodiscovery
-        self._update_channel = update_channel
         self._device_type = device_type
         self._web_port = web_port
         self._proxy_port = proxy_port
@@ -81,7 +79,6 @@ class ConfigHelper:
             TEXT_SENSOR: {},
             SELECT: {},
             NUMERIC: {},
-            "update": {}
         }
         self.manager_ready: bool = False
         self._network_info = network_info
@@ -184,11 +181,6 @@ class ConfigHelper:
         """Check if BoneIO autodiscovery receiving is enabled."""
         return self._receive_boneio_autodiscovery
 
-    @property
-    def update_channel(self) -> str:
-        """Get update channel (stable or dev)."""
-        return self._update_channel
-
     @property
     def device_type(self) -> str:
         return self._device_type

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

@@ -22,7 +22,6 @@ from boneio.const import (
     ID,
     INPUT,
     INPUT_SENSOR,
-    LONG,
     PIN,
     PRESSED,
     RELEASED,
@@ -687,56 +686,8 @@ class InputManager:
         # Send event to MQTT for Home Assistant
         self._publish_input_event_to_mqtt(input_instance, event)
         
-        # If publish_only is set, skip action execution (used for initial state sync)
-        if event.publish_only:
-            _LOGGER.debug(
-                "Skipping action execution for %s (publish_only=True)",
-                event.entity_id
-            )
-            return
-        
-        # 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
+        # Execute actions for this input event (skip if publish_only)
+        if actions and not event.publish_only:
             await self._manager.execute_actions(actions=actions)
 
     async def send_ha_autodiscovery(self) -> None:

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

@@ -26,7 +26,6 @@ from boneio.const import (
     REMOTE_OUTPUT,
     SET_BRIGHTNESS,
     STATE,
-    TOGGLE,
     cover_actions,
     output_actions,
 )
@@ -39,7 +38,6 @@ from boneio.core.manager.modbus import ModbusManager
 from boneio.core.manager.outputs import OutputManager
 from boneio.core.manager.sensors import SensorManager
 from boneio.core.manager.remote import RemoteDeviceManager
-from boneio.core.manager.update import UpdateManager
 from boneio.core.discovery import BlackDiscoveryPublisher
 from boneio.core.messaging import MessageBus
 from boneio.core.state import StateManager
@@ -205,11 +203,6 @@ class Manager:
             message_bus=message_bus,
         )
         
-        # 9. UpdateManager (checks for software updates and publishes to HA)
-        self.update_manager = UpdateManager(
-            manager=self,
-        )
-        
         # Configure virtual energy sensors (must be after outputs are initialized)
         self.sensors.configure_virtual_energy_sensors()
         
@@ -329,7 +322,6 @@ class Manager:
         await self.sensors.send_ha_autodiscovery()
         await self.modbus.send_ha_autodiscovery()
         await self.display.send_ha_autodiscovery()
-        await self.update_manager.send_ha_autodiscovery()
 
     def send_ha_autodiscovery(
         self,
@@ -387,9 +379,6 @@ class Manager:
             availability_msg_func = ha_cover_availabilty_message
         elif ha_type == BUTTON:
             availability_msg_func = ha_button_availabilty_message
-        elif ha_type == "update":
-            from boneio.integration.homeassistant import ha_update_availability_message
-            availability_msg_func = ha_update_availability_message
         
         # Use availability_msg_func from kwargs if provided (for sensors)
         if 'availability_msg_func' in kwargs:
@@ -410,16 +399,6 @@ class Manager:
             )
             self.send_message(topic=topic, payload=payload, retain=True)
 
-    async def _handle_update_install_command(self, topic: str, payload: str) -> None:
-        """Handle update install command from Home Assistant.
-        
-        Args:
-            topic: MQTT topic
-            payload: MQTT payload (should be "INSTALL")
-        """
-        _LOGGER.info("Received update install command: %s", payload)
-        await self.update_manager.handle_install_command(payload)
-
     def parse_actions(self, pin: str, actions: dict) -> dict:
         """Parse actions configuration.
         
@@ -444,28 +423,17 @@ 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", TOGGLE)
+                    action_output = action_definition.get("action_output")
                     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_action = {
+                            parsed_actions[click_type].append({
                                 "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)
                     
@@ -473,25 +441,19 @@ 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", TOGGLE)
+                    action_cover = action_definition.get("action_cover")
                     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_action = {
+                            parsed_actions[click_type].append({
                                 "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)
                     
@@ -499,17 +461,11 @@ 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_action = {
+                        parsed_actions[click_type].append({
                             "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)
                     
@@ -518,17 +474,11 @@ 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_action = {
+                        parsed_actions[click_type].append({
                             "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)
                     
@@ -537,17 +487,11 @@ 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_action = {
+                        parsed_actions[click_type].append({
                             "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)
                 
@@ -557,18 +501,12 @@ class Manager:
                     output_id = action_definition.get("output_id")
                     action_output = action_definition.get("action_output", "TOGGLE")
                     if remote_device and output_id:
-                        parsed_action = {
+                        parsed_actions[click_type].append({
                             "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)
                 
@@ -579,19 +517,13 @@ class Manager:
                     action_cover = action_definition.get("action_cover", "TOGGLE")
                     extra_data = action_definition.get("data", {})
                     if remote_device and cover_id:
-                        parsed_action = {
+                        parsed_actions[click_type].append({
                             "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)
                     
@@ -599,58 +531,18 @@ class Manager:
 
     async def execute_actions(
         self,
-        actions: list,
-        duration: float | None = None,
-        executed_actions: set[int] | None = None,
-    ) -> set[int]:
+        actions: list
+    ) -> None:
         """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 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)
+        for action_definition in actions:
             action = action_definition.get("action")
             
             if action == MQTT:
@@ -718,7 +610,7 @@ class Manager:
                 )
             
             elif action == REMOTE_OUTPUT:
-                # Control output on remote device (supports ESPHome lights with brightness/color and WLED effects)
+                # Control output on remote device
                 remote_device_id = action_definition.get("remote_device")
                 output_id = action_definition.get("output_id")
                 action_output = action_definition.get("action_output", "TOGGLE")
@@ -726,14 +618,6 @@ 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:
@@ -748,11 +632,6 @@ 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.
@@ -768,17 +647,16 @@ class Manager:
         configure_logger(log_config, debug=0)
         _LOGGER.info("Logger configuration reloaded successfully")
 
-    async def _reload_remote_devices(self) -> None:
+    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")
-        await self.remote_devices.reload(remote_devices_config)
+        self.remote_devices.reload(remote_devices_config)
         _LOGGER.info("Remote devices configuration reloaded successfully")
     
     async def publish_discovery(self) -> None: