boneIO 1.0.0.dev16__tar.gz → 1.0.0.dev17__tar.gz

{boneio-1.0.0.dev16/boneio.egg-info → boneio-1.0.0.dev17}/PKG-INFO

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

{boneio-1.0.0.dev16 → boneio-1.0.0.dev17}/boneio/components/input/binary_sensor.py

@@ -4,9 +4,14 @@ from __future__ import annotations
 
 import logging
 
+import time
+from typing import cast
+
 from boneio.components.input.detectors import BinarySensorDetector
-from boneio.const import BinaryStateTypes, PRESSED, RELEASED
+from boneio.const import BinaryStateTypes, ClickTypes, PRESSED, RELEASED
 from boneio.hardware.gpio.input import GpioBaseClass, get_gpio_manager
+from boneio.models import InputState
+from boneio.models.events import InputEvent
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -51,24 +56,61 @@ class GpioInputBinarySensor(GpioBaseClass):
         
         # Send initial state if requested
         if kwargs.get("initial_send", False):
-            self._loop.call_soon(self._send_initial_state)
+            self._loop.call_soon(callback=self._send_initial_state)
 
     def _send_initial_state(self) -> None:
         """Send initial state after setup."""
+        self.send_current_state()
+
+    def send_current_state(self) -> None:
+        """Send current state to MQTT without triggering actions.
+        
+        This can be called on startup (if initial_send=True) or after config reload.
+        Only publishes state to MQTT broker, does not execute any configured actions.
+        """
         # Read current state from GPIO manager
-        from boneio.hardware.gpio.input.base import read_input
-        current_value = read_input(self._pin)
+        gpio_manager = get_gpio_manager(loop=self._loop)
+        current_value = gpio_manager.read_value(self._pin)
         
         # Determine state based on inversion
         is_pressed = not current_value if not self._inverted else current_value
         state_str = PRESSED if is_pressed else RELEASED
         
-        _LOGGER.debug("Sending initial state for %s: %s", self._name, state_str)
-        self.press_callback(
-            click_type=state_str,
-            duration=None,
-            start_time=0.0,
+        _LOGGER.debug("Publishing current state for %s: %s (publish_only)", self._name, state_str)
+        
+        # Use publish_only=True to send to MQTT without executing actions
+        self._publish_state_only(state_str)
+
+    def _publish_state_only(self, state_str: str) -> None:
+        """Publish state to MQTT without triggering actions.
+        
+        Creates an InputEvent with publish_only=True flag, which tells
+        the InputManager to only publish to MQTT without executing actions.
+        
+        Args:
+            state_str: State string (PRESSED or RELEASED)
+        """
+        timestamp = time.time()
+        
+        # Create event state
+        event_state = InputState(
+            name=self.name,
+            pin=self._pin,
+            state=state_str,
+            type=self.input_type,
+            timestamp=timestamp,
+            boneio_input=self.boneio_input,
+            area=self.area,
         )
+        
+        # Trigger event with publish_only=True
+        self._event_bus.trigger_event(InputEvent(
+            entity_id=self.id,
+            click_type=cast(ClickTypes, state_str),
+            duration=None,
+            state=event_state,
+            publish_only=True,
+        ))
 
     def _on_state_changed(self, state: BinaryStateTypes, timestamp: float) -> None:
         """Called by BinarySensorDetector when state changes.

{boneio-1.0.0.dev16 → boneio-1.0.0.dev17}/boneio/components/input/detectors.py

@@ -6,10 +6,22 @@ import asyncio
 import logging
 from collections.abc import Callable
 from dataclasses import dataclass
+from typing import cast
 
 import gpiod
 
-from boneio.const import BinaryStateTypes, ClickTypes, DOUBLE, LONG, PRESSED, RELEASED, SINGLE
+from boneio.const import (
+    BinaryStateTypes,
+    ClickTypes,
+    CLICK_SEQUENCES,
+    DEFAULT_SEQUENCE_WINDOW_MS,
+    DOUBLE,
+    LONG,
+    PRESSED,
+    RELEASED,
+    SINGLE,
+    TRIPLE,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -24,6 +36,9 @@ class ClickState:
     finalizer_scheduled_loop_ts: float | None = None
     long_press_timer: asyncio.TimerHandle | None = None
     long_press_scheduled_loop_ts: float | None = None
+    # Sequence tracking
+    last_click_type: str | None = None
+    last_click_time: float | None = None
 
 
 @dataclass
@@ -35,8 +50,9 @@ class BinarySensorState:
 
 
 class MultiClickDetector:
-    """Detects single, double, and long-press events with software debounce.
+    """Detects single, double, triple, long-press events and sequences with software debounce.
     
+    Supports sequence detection like double_then_long, single_then_long, etc.
     Based on multiclick_detector.py from tests.
     """
 
@@ -47,6 +63,7 @@ class MultiClickDetector:
         debounce_ms: float = 50.0,
         multiclick_window_ms: float = 220.0,
         hold_threshold_ms: float = 400.0,
+        sequence_window_ms: float = DEFAULT_SEQUENCE_WINDOW_MS,
         name: str = "unknown",
         pin: str = "unknown",
     ):
@@ -58,6 +75,7 @@ class MultiClickDetector:
             debounce_ms: Debounce time in milliseconds
             multiclick_window_ms: Window for double-click detection
             hold_threshold_ms: Time threshold for long press
+            sequence_window_ms: Window for sequence detection (e.g., double_then_long)
             name: Name of the input
             pin: Pin name for logging
         """
@@ -66,6 +84,7 @@ class MultiClickDetector:
         self._debounce_seconds = debounce_ms / 1000.0
         self._multiclick_window = multiclick_window_ms / 1000.0
         self._hold_threshold = hold_threshold_ms / 1000.0
+        self._sequence_window = sequence_window_ms / 1000.0
         self._name = name
         self._pin = pin
         self._state = ClickState()
@@ -80,19 +99,80 @@ class MultiClickDetector:
         elif count == 2:
             click_type = DOUBLE
             _LOGGER.info("Detected DOUBLE click on %s (%s)", self._name, self._pin)
+        elif count == 3:
+            click_type = TRIPLE
+            _LOGGER.info("Detected TRIPLE click on %s (%s)", self._name, self._pin)
         else:
-            click_type = SINGLE  # Fallback for 3+ clicks
+            click_type = SINGLE  # Fallback for 4+ clicks
             _LOGGER.info("Detected %d clicks on %s (%s), treating as SINGLE", count, self._name, self._pin)
         
         self._state.click_count = 0
         self._state.finalizer = None
         self._state.finalizer_scheduled_loop_ts = None
         
-        # Call the callback
+        # Emit the click
+        self._emit_click(click_type, None)
+
+    def _emit_click(self, click_type: ClickTypes, duration: float | None) -> None:
+        """Emit a click event, checking for sequences first.
+        
+        Args:
+            click_type: The detected click type (single, double, triple, long)
+            duration: Duration of the click (for long press)
+        """
+        current_time = self._loop.time()
+        
+        # Check if this click forms a sequence with the previous one
+        sequence_type = self._check_sequence(click_type, current_time)
+        if sequence_type:
+            _LOGGER.info(
+                "Detected sequence %s on %s (%s)",
+                sequence_type.upper(), self._name, self._pin
+            )
+            try:
+                self._callback(sequence_type, duration)
+            except Exception as exc:
+                _LOGGER.error("Error in sequence callback for %s: %s", self._name, exc, exc_info=True)
+        
+        # Always emit the basic click type
         try:
-            self._callback(click_type, None)
+            self._callback(click_type, duration)
         except Exception as exc:
-            _LOGGER.error("Error in multiclick callback for %s: %s", self._name, exc, exc_info=True)
+            _LOGGER.error("Error in click callback for %s: %s", self._name, exc, exc_info=True)
+        
+        # Remember this click for potential sequence detection
+        self._state.last_click_type = click_type
+        self._state.last_click_time = current_time
+
+    def _check_sequence(self, current_click: ClickTypes, current_time: float) -> ClickTypes | None:
+        """Check if current click forms a sequence with previous click.
+        
+        Args:
+            current_click: Current click type
+            current_time: Current timestamp
+            
+        Returns:
+            Sequence type if detected, None otherwise
+        """
+        if not self._state.last_click_type or not self._state.last_click_time:
+            return None
+        
+        elapsed = current_time - self._state.last_click_time
+        if elapsed > self._sequence_window:
+            # Too much time passed, no sequence - this is normal behavior
+            return None
+        
+        # Look up sequence in mapping
+        sequence_key = (self._state.last_click_type, current_click)
+        sequence_type = CLICK_SEQUENCES.get(sequence_key)
+        
+        if sequence_type:
+            # Clear sequence state to prevent chaining
+            self._state.last_click_type = None
+            self._state.last_click_time = None
+            return cast(ClickTypes, sequence_type)
+        
+        return None
 
     def _detect_long_press(self) -> None:
         """Detect and report a long press."""
@@ -106,11 +186,8 @@ class MultiClickDetector:
         self._state.long_press_timer = None
         self._state.long_press_scheduled_loop_ts = None
         
-        # Call the callback
-        try:
-            self._callback(LONG, duration)
-        except Exception as exc:
-            _LOGGER.error("Error in long press callback for %s: %s", self._name, exc, exc_info=True)
+        # Emit the long press (may also trigger sequence)
+        self._emit_click(LONG, duration)
 
     def handle_event(self, event: gpiod.EdgeEvent) -> None:
         """Process a GPIO edge event and update click state.

{boneio-1.0.0.dev16 → boneio-1.0.0.dev17}/boneio/components/input/event.py

@@ -15,6 +15,7 @@ _LOGGER = logging.getLogger(__name__)
 # DEFAULT TIMINGS FOR BUTTONS (can be overridden in config)
 DEFAULT_DOUBLE_CLICK_DURATION_MS = 220
 DEFAULT_LONG_PRESS_DURATION_MS = 400
+DEFAULT_SEQUENCE_WINDOW_MS = 500
 
 
 def _to_milliseconds(value, default_ms: int) -> int:
@@ -45,6 +46,7 @@ class GpioEventButton(GpioBaseClass):
         Args:
             double_click_duration: Time window in ms to detect double click (default: 220ms)
             long_press_duration: Time in ms to detect long press (default: 400ms)
+            sequence_window_duration: Time window in ms to detect sequences (default: 500ms)
             **kwargs: Additional arguments passed to GpioBaseClass
         """
         super().__init__(**kwargs)
@@ -58,6 +60,10 @@ class GpioEventButton(GpioBaseClass):
             kwargs.get('long_press_duration'),
             DEFAULT_LONG_PRESS_DURATION_MS
         )
+        sequence_window_duration = _to_milliseconds(
+            kwargs.get('sequence_window_duration'),
+            DEFAULT_SEQUENCE_WINDOW_MS
+        )
         
         # Create multiclick detector
         self._detector = MultiClickDetector(
@@ -66,6 +72,7 @@ class GpioEventButton(GpioBaseClass):
             debounce_ms=self._bounce_time * 1000,  # Convert to ms
             multiclick_window_ms=double_click_duration,
             hold_threshold_ms=long_press_duration,
+            sequence_window_ms=sequence_window_duration,
             name=self._name,
             pin=self._pin,
         )
@@ -102,4 +109,35 @@ class GpioEventButton(GpioBaseClass):
             click_type=click_type,
             duration=duration,
             start_time=start_time,
-        )
+        )
+
+    def update_timings(
+        self,
+        double_click_duration: int | float | None = None,
+        long_press_duration: int | float | None = None,
+        sequence_window_duration: int | float | None = None,
+    ) -> None:
+        """Update timing parameters for click detection.
+        
+        This method allows updating timing parameters at runtime without
+        recreating the detector. Useful for config reload.
+        
+        Args:
+            double_click_duration: Time window in ms to detect double click
+            long_press_duration: Time in ms to detect long press
+            sequence_window_duration: Time window in ms to detect sequences
+        """
+        if double_click_duration is not None:
+            value_ms = _to_milliseconds(double_click_duration, DEFAULT_DOUBLE_CLICK_DURATION_MS)
+            self._detector._multiclick_window = value_ms / 1000.0
+            _LOGGER.debug("Updated double_click_duration to %dms for %s", value_ms, self._name)
+        
+        if long_press_duration is not None:
+            value_ms = _to_milliseconds(long_press_duration, DEFAULT_LONG_PRESS_DURATION_MS)
+            self._detector._hold_threshold = value_ms / 1000.0
+            _LOGGER.debug("Updated long_press_duration to %dms for %s", value_ms, self._name)
+        
+        if sequence_window_duration is not None:
+            value_ms = _to_milliseconds(sequence_window_duration, DEFAULT_SEQUENCE_WINDOW_MS)
+            self._detector._sequence_window = value_ms / 1000.0
+            _LOGGER.debug("Updated sequence_window_duration to %dms for %s", value_ms, self._name)

{boneio-1.0.0.dev16 → boneio-1.0.0.dev17}/boneio/components/sensor/__init__.py

@@ -4,10 +4,8 @@ This module provides high-level sensor components that combine
 hardware drivers with business logic.
 """
 
-from boneio.components.sensor.system import SerialNumberSensor
 from boneio.components.sensor.virtual_energy import VirtualEnergySensor
 
 __all__ = [
-    "SerialNumberSensor",
     "VirtualEnergySensor",
 ]

{boneio-1.0.0.dev16 → boneio-1.0.0.dev17}/boneio/const.py

@@ -24,6 +24,8 @@ ACTIONS = "actions"
 ACTION = "action"
 OUTPUT_OVER_MQTT = "output_over_mqtt"
 COVER_OVER_MQTT = "cover_over_mqtt"
+REMOTE_OUTPUT = "remote_output"
+REMOTE_COVER = "remote_cover"
 SWITCH = "switch"
 LIGHT = "light"
 BUTTON = "button"
@@ -81,6 +83,7 @@ WHITE = "white"
 INPUT = "input"
 SINGLE = "single"
 DOUBLE = "double"
+TRIPLE = "triple"
 LONG = "long"
 PRESSED = "pressed"
 RELEASED = "released"
@@ -143,7 +146,24 @@ CLOSE = "close"
 STOP = "stop"
 
 # TYPING
-ClickTypes = Literal["single", "double", "long", "pressed", "released"]
+# Basic click types + sequence aliases
+ClickTypes = Literal[
+    "single", "double", "triple", "long", "pressed", "released",
+    # Sequence aliases
+    "double_then_long",   # double click followed by long press
+    "single_then_long",   # single click followed by long press
+    "double_then_single", # double click followed by single click
+]
+
+# Sequence definitions for MultiClickDetector
+CLICK_SEQUENCES: dict[tuple[str, str], str] = {
+    ("double", "long"): "double_then_long",
+    ("single", "long"): "single_then_long",
+    ("double", "single"): "double_then_single",
+}
+
+# Default window for sequence detection (ms)
+DEFAULT_SEQUENCE_WINDOW_MS = 500
 BinaryStateTypes = Literal["pressed", "released"]
 OledDataTypes = Literal[UPTIME, NETWORK, CPU, DISK, MEMORY, SWAP, OUTPUT]
 InputTypes = Literal[INPUT, INPUT_SENSOR]

{boneio-1.0.0.dev16 → boneio-1.0.0.dev17}/boneio/core/config/__init__.py

@@ -1,12 +1,10 @@
 """Configuration management modules."""
 
 from boneio.core.config.config_helper import ConfigHelper
-from boneio.core.config.loader import create_serial_number_sensor
 from boneio.core.config.yaml_util import clear_config_cache, load_config_from_file
 
 __all__ = [
     "ConfigHelper",
     "clear_config_cache",
-    "create_serial_number_sensor",
     "load_config_from_file",
 ]

{boneio-1.0.0.dev16 → boneio-1.0.0.dev17}/boneio/core/config/config_helper.py

@@ -23,6 +23,7 @@ from boneio.const import (
     VALVE,
 )
 from boneio.core.utils.util import sanitize_mqtt_topic
+from boneio.core.system import get_serial_from_mac
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -30,7 +31,6 @@ _LOGGER = logging.getLogger(__name__)
 class ConfigHelper:
     def __init__(
         self,
-        topic_prefix: str,
         name: str = BONEIO,
         device_type: str = "boneIO Black",
         ha_discovery: bool = True,
@@ -40,12 +40,26 @@ class ConfigHelper:
         web_port: int = 8090,
         proxy_port: int | None = None,
         config_file_path: str | None = None,
+        send_boneio_autodiscovery: bool = True,
+        receive_boneio_autodiscovery: bool = True,
     ):
         self._name = name
-        sanitized_topic_prefix = sanitize_mqtt_topic(topic_prefix) if topic_prefix else sanitize_mqtt_topic(name)
-        self._topic_prefix = sanitized_topic_prefix
+        
+        # Generate serial number from MAC - always required for topic prefix
+        self._serial_no = get_serial_from_mac(network_info)
+        
+        # Build fixed topic prefix: boneio/blk_{serial}
+        # This is no longer configurable - always uses this format
+        if self._serial_no:
+            self._topic_prefix = f"boneio/{self._serial_no}"
+        else:
+            # Fallback if MAC not available (should rarely happen)
+            self._topic_prefix = "boneio/blk_unknown"
+            _LOGGER.warning("Could not determine serial number from MAC, using fallback topic prefix")
         self._ha_discovery = ha_discovery
         self._ha_discovery_prefix = ha_discovery_prefix
+        self._send_boneio_autodiscovery = send_boneio_autodiscovery
+        self._receive_boneio_autodiscovery = receive_boneio_autodiscovery
         self._device_type = device_type
         self._web_port = web_port
         self._proxy_port = proxy_port
@@ -115,11 +129,19 @@ class ConfigHelper:
     def web_port(self) -> int:
         return self._web_port
 
+    @property
+    def serial_number(self) -> str:
+        return self._serial_no
+
     @property
     def proxy_port(self) -> int | None:
         """Get nginx proxy port if configured."""
         return self._proxy_port
 
+    @property
+    def http_proto(self) -> str:
+        return "https" if self._proxy_port else "http"
+
     @property
     def ha_configuration_port(self) -> int:
         """Get port for HA discovery URL. Uses proxy_port if set, otherwise web_port."""
@@ -129,6 +151,11 @@ class ConfigHelper:
     def topic_prefix(self) -> str:
         return self._topic_prefix
 
+    @property
+    def serial_no(self) -> str:
+        """Get device serial number (e.g., 'blk_abc123')."""
+        return self._serial_no or "blk_unknown"
+
     @property
     def name(self) -> str:
         return self._name
@@ -141,6 +168,16 @@ class ConfigHelper:
     def ha_discovery_prefix(self) -> str:
         return self._ha_discovery_prefix
 
+    @property
+    def send_boneio_autodiscovery(self) -> bool:
+        """Check if BoneIO autodiscovery publishing is enabled."""
+        return self._send_boneio_autodiscovery
+
+    @property
+    def receive_boneio_autodiscovery(self) -> bool:
+        """Check if BoneIO autodiscovery receiving is enabled."""
+        return self._receive_boneio_autodiscovery
+
     @property
     def device_type(self) -> str:
         return self._device_type