boneIO 1.1.0.dev6__tar.gz → 1.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.1.0.dev6
+Version: 1.2.0
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0
@@ -28,7 +28,7 @@ Requires-Dist: pydantic==2.11.9
 Requires-Dist: hypercorn==0.17.3
 Requires-Dist: websockets==15.0.1
 Requires-Dist: python-jose[cryptography]==3.5.0
-Requires-Dist: python-multipart==0.0.20
+Requires-Dist: python-multipart==0.0.22
 Requires-Dist: qrcode==8.2
 Requires-Dist: gpiod==2.3.0
 Requires-Dist: requests==2.32.5

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

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

{boneio-1.1.0.dev6 → boneio-1.2.0}/boneio/components/cover/cover.py

@@ -16,11 +16,11 @@ from boneio.const import (
     OPEN,
     OPENING,
 )
-from boneio.core.events import EventBus, async_track_point_in_time, utcnow
+from boneio.core.events import EventBus
 from boneio.core.messaging import BasicMqtt
 from boneio.core.utils import TimePeriod
 from boneio.models import CoverState, PositionDict
-from boneio.components.output import MCPOutput
+from boneio.components.output import BasicOutput
 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: MCPOutput,
-        close_relay: MCPOutput,
+        open_relay: BasicOutput,
+        close_relay: BasicOutput,
         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: MCPOutput,
-        close_relay: MCPOutput,
+        open_relay: BasicOutput,
+        close_relay: BasicOutput,
         state_save: Callable,
         open_time: TimePeriod,
         close_time: TimePeriod,
@@ -171,6 +171,7 @@ 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
@@ -207,6 +208,8 @@ 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)
@@ -219,6 +222,7 @@ 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)
 
@@ -230,6 +234,7 @@ 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)
 
@@ -258,10 +263,16 @@ class BaseCover(BaseCoverABC, BasicMqtt):
 
     async def toggle(self) -> None:
         _LOGGER.debug("Toggle cover %s from input.", self._id)
-        if self._position > 50:
+        if self._current_operation != IDLE:
+            await self.stop()
+        elif self._position >= 100:
             await self.close()
-        else:
+        elif self._position <= 0:
             await self.open()
+        elif self._last_operation == CLOSING:
+            await self.open()
+        else:
+            await self.close()
 
     async def toggle_open(self) -> None:
         _LOGGER.debug("Toggle open cover %s from input.", self._id)
@@ -277,6 +288,33 @@ 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.1.0.dev6 → boneio-1.2.0}/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 MCPOutput
+from boneio.components.output import BasicOutput
 
 _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: MCPOutput,
-        close_relay: MCPOutput,
+        open_relay: BasicOutput,
+        close_relay: BasicOutput,
         state_save: Callable,
         open_time: TimePeriod,
         close_time: TimePeriod,

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

@@ -31,6 +31,7 @@ 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
@@ -46,6 +47,7 @@ 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
@@ -76,6 +78,7 @@ class MultiClickDetector:
         enable_triple_click: bool = False,
         name: str = "unknown",
         pin: str = "unknown",
+        max_long_press_seconds: float = 120.0,
     ):
         """Initialize multiclick detector.
         
@@ -91,6 +94,7 @@ 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
@@ -103,6 +107,7 @@ 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
@@ -356,13 +361,14 @@ class MultiClickDetector:
 
     def _detect_long_press(self) -> None:
         """Detect and report a long press and start periodic updates."""
-        if not self._state.last_press_ts:
+        if not self._state.last_press_loop_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_ts
+        duration = self._loop.time() - self._state.last_press_loop_ts
         
         _LOGGER.info("Detected LONG press on %s (%s)", self._name, self._pin)
         
@@ -381,11 +387,24 @@ class MultiClickDetector:
     
     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:
+        if not self._state.last_press_loop_ts or self._state.last_release_ts:
             # Button released or invalid state
             return
         
-        duration = self._loop.time() - self._state.last_press_ts
+        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
         
         _LOGGER.debug(
             "Periodic long event on %s (%s), duration=%.3fs",
@@ -402,6 +421,34 @@ 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.
@@ -433,6 +480,7 @@ 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
@@ -468,7 +516,7 @@ class MultiClickDetector:
         elif event.event_type is event.Type.RISING_EDGE:
             # Button released (RISING_EDGE on BeagleBone with pull-up)
             
-            # Software debounce
+            # Software debounce (release-vs-release)
             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(
@@ -477,8 +525,20 @@ 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
 
-            _LOGGER.debug("RELEASED: %s (%s)", self._name, self._pin)
+            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)
             self._state.last_release_ts = timestamp_s
             
             _LOGGER.debug(
@@ -496,8 +556,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_ts:
-                    duration = timestamp_s - self._state.last_press_ts
+                if self._state.last_press_loop_ts:
+                    duration = self._loop.time() - self._state.last_press_loop_ts
                     _LOGGER.debug(
                         "Sending final long event on release for %s, duration=%.3fs, executed_actions=%s",
                         self._name,
@@ -511,6 +571,7 @@ 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)
             

{boneio-1.1.0.dev6 → boneio-1.2.0}/boneio/components/input/event.py

@@ -89,6 +89,12 @@ class GpioEventButton(GpioBaseClass):
         # Get enable_triple_click setting (default: False)
         enable_triple_click = kwargs.get('enable_triple_click', False)
         
+        # Safety timeout for long press (default: 120s)
+        max_long_press_seconds = _to_milliseconds(
+            kwargs.get('max_long_press_duration'),
+            120 * 1000  # 120s default
+        ) / 1000.0
+        
         # Create multiclick detector
         self._detector = MultiClickDetector(
             loop=self._loop,
@@ -102,6 +108,7 @@ class GpioEventButton(GpioBaseClass):
             enable_triple_click=enable_triple_click,
             name=self._name,
             pin=self._pin,
+            max_long_press_seconds=max_long_press_seconds,
         )
         
         # Register with GPIO manager
@@ -147,6 +154,8 @@ class GpioEventButton(GpioBaseClass):
         actions: dict | None = None,
         mqtt_sequences: dict | None = None,
         enable_triple_click: bool | None = None,
+        long_press_mqtt_mode: str | None = None,
+        max_long_press_duration: int | float | None = None,
     ) -> None:
         """Update timing parameters for click detection.
         
@@ -161,6 +170,8 @@ class GpioEventButton(GpioBaseClass):
             actions: Actions dict to determine enabled sequences
             mqtt_sequences: MQTT sequences dict to determine enabled sequences
             enable_triple_click: Enable triple click detection
+            long_press_mqtt_mode: 'single' or 'periodic' for MQTT long press events
+            max_long_press_duration: Safety timeout for long press in ms (default: 120000ms)
         """
         from boneio.const import CLICK_SEQUENCES
         
@@ -213,4 +224,13 @@ class GpioEventButton(GpioBaseClass):
                         if seq_name == seq:
                             self._detector._delay_click_types.add(first)
                             break
-            _LOGGER.debug("Updated enabled_sequences to %s for %s", enabled_sequences, self._name)
+            _LOGGER.debug("Updated enabled_sequences to %s for %s", enabled_sequences, self._name)
+
+        if max_long_press_duration is not None:
+            value_ms = _to_milliseconds(max_long_press_duration, 120 * 1000)
+            self._detector._max_long_press_seconds = value_ms / 1000.0
+            _LOGGER.debug("Updated max_long_press_duration to %dms for %s", value_ms, self._name)
+
+        if long_press_mqtt_mode is not None:
+            self._long_press_mqtt_mode = long_press_mqtt_mode
+            _LOGGER.debug("Updated long_press_mqtt_mode to %s for %s", long_press_mqtt_mode, self._name)

boneio-1.2.0/boneio/components/template/__init__.py

@@ -0,0 +1,15 @@
+"""Template components — composite virtual entities.
+
+Combines existing boneIO primitives (inputs, outputs, sensors) into
+higher-level Home Assistant entities (climate, alarm_control_panel, cover, etc.).
+"""
+
+from boneio.components.template.thermostat import BoneIOThermostat
+from boneio.components.template.alarm_panel import BoneIOAlarmPanel
+from boneio.components.template.gate_cover import BoneIOGateCover
+
+__all__ = [
+    "BoneIOThermostat",
+    "BoneIOAlarmPanel",
+    "BoneIOGateCover",
+]