boneIO 1.3.1.dev2__py3-none-any.whl → 1.4.0.dev1__py3-none-any.whl

boneio/components/cover/cover.py

@@ -21,7 +21,7 @@ from boneio.const import (
 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.models import CoverState, PositionDict, SavedPositionDict
 from boneio.models.events import CoverEvent
 
 _LOGGER = logging.getLogger(__name__)
@@ -40,7 +40,7 @@ class BaseCoverABC(ABC):
         open_time: TimePeriod,
         close_time: TimePeriod,
         event_bus: EventBus,
-        position: int = 100,
+        position: float = 100.0,
         **kwargs,
     ) -> None:
         pass
@@ -106,14 +106,12 @@ class BaseCoverABC(ABC):
         pass
 
     @abstractmethod
-    async def run_cover(
-        self, current_operation: str, target_position: float | None = None, target_tilt: float | None = None
-    ) -> None:
+    async def run_cover(self, current_operation: str, target_position: int | None = None, **kwargs) -> None:
         """This function is called to run cover after calling open, close, toggle, toggle_open, toggle_close, set_cover_position"""
         pass
 
     @abstractmethod
-    async def send_state(self, state: str, position: float) -> None:
+    def send_state(self, state: str, json_position: PositionDict) -> None:
         pass
 
 
@@ -159,7 +157,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         open_time: TimePeriod,
         close_time: TimePeriod,
         event_bus: EventBus,
-        position: int = 100,
+        position: float = 100.0,
         name: str | None = None,
         **kwargs,
     ) -> None:
@@ -175,7 +173,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._open_time = open_time.total_milliseconds
         self._close_time = close_time.total_milliseconds
         self._position = position
-        self._initial_position = None
+        self._initial_position: float = position
         self._current_operation = IDLE
         self._last_operation = CLOSING
         _LOGGER.debug(
@@ -188,7 +186,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
 
         self._last_timestamp = time.time()
 
-        self._last_update_time = 0
+        self._last_update_time = 0.0
         self._closed = position <= 0
 
         self._movement_thread = None
@@ -356,7 +354,8 @@ class BaseCover(BaseCoverABC, BasicMqtt):
 
     @property
     def position(self) -> int:
-        return round(self._position, 0)
+        """Return current cover position as integer (0-100)."""
+        return round(self._position)
 
     @property
     def json_position(self) -> PositionDict:
@@ -384,6 +383,12 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=state)
         self._message_bus.send_message(topic=f"{self._send_topic}/pos", payload=json.dumps(json_position))
 
+    @property
+    def saved_position(self) -> SavedPositionDict:
+        """Raw float position for disk persistence."""
+        return {"position": self._position}
+
     def send_state_and_save(self, json_position: PositionDict):
+        """Send state to MQTT/WebSocket and save raw float position to disk."""
         self.send_state(self.state, json_position)
-        self._state_save(json_position)
+        self._state_save(self.saved_position)

boneio/components/cover/time_based.py

@@ -31,7 +31,7 @@ class TimeBasedCover(BaseCover):
         restored_state: dict = DEFAULT_RESTORED_STATE,
         **kwargs,
     ) -> None:
-        position = int(restored_state.get("position", DEFAULT_RESTORED_STATE["position"]))
+        position = float(restored_state.get("position", DEFAULT_RESTORED_STATE["position"]))
         super().__init__(
             open_relay=open_relay,
             close_relay=close_relay,
@@ -113,7 +113,7 @@ class TimeBasedCover(BaseCover):
             self._loop.call_soon_threadsafe(lambda: self.send_state_and_save(self.json_position))
         self._last_update_time = time.monotonic()  # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
 
-    async def run_cover(self, current_operation: str, target_position: int | None = None) -> None:
+    async def run_cover(self, current_operation: str, target_position: int | None = None, **kwargs) -> None:
         if self._movement_thread and self._movement_thread.is_alive():
             _LOGGER.warning("Cover movement already in progress. Stopping first.")
             await self.stop()

boneio/components/cover/venetian.py

@@ -8,7 +8,7 @@ import time
 from boneio.components.cover.cover import BaseCover, BaseVenetianCoverABC
 from boneio.const import CLOSE, CLOSING, IDLE, OPEN, OPENING, STOP
 from boneio.core.utils import TimePeriod
-from boneio.models import PositionDict
+from boneio.models import PositionDict, SavedPositionDict
 
 _LOGGER = logging.getLogger(__name__)
 COVER_MOVE_UPDATE_INTERVAL = 50  # ms
@@ -27,20 +27,12 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         restored_state: dict = DEFAULT_RESTORED_STATE,
         **kwargs,
     ) -> None:
-        self._tilt_duration = (
-            tilt_duration.total_milliseconds
-        )  # Czas trwania ruchu lameli
-        self._initial_tilt_position = int(
-            restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"])
-        )
+        self._tilt_duration = tilt_duration.total_milliseconds  # Czas trwania ruchu lameli
+        self._initial_tilt_position = float(restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"]))
 
-        position = int(
-            restored_state.get("position", DEFAULT_RESTORED_STATE["position"])
-        )
+        position = float(restored_state.get("position", DEFAULT_RESTORED_STATE["position"]))
         # --- TILT ---
-        self._tilt_position = int(
-            restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"])
-        )
+        self._tilt_position = float(restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"]))
 
         # self._actuator_activation_duration = (
         #     actuator_activation_duration.total_milliseconds
@@ -53,7 +45,12 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         )
         _LOGGER.debug(
             "VenetianCover %s initialized: open_time=%dms, close_time=%dms, tilt_duration=%dms, position=%d%%, tilt=%d%%",
-            self._id, self._open_time, self._close_time, self._tilt_duration, position, self._tilt_position
+            self._id,
+            self._open_time,
+            self._close_time,
+            self._tilt_duration,
+            position,
+            self._tilt_position,
         )
 
     def _move_cover(
@@ -69,20 +66,12 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         if direction == OPEN:
             relay = self._open_relay
             total_steps = 100 - self._position
-            total_tilt_step = (
-                tilt_delta
-                if target_tilt_position is not None
-                else 100 - self._initial_tilt_position
-            )
+            total_tilt_step = tilt_delta if target_tilt_position is not None else 100 - self._initial_tilt_position
 
         elif direction == CLOSE:
             relay = self._close_relay
             total_steps = self._position
-            total_tilt_step = (
-                tilt_delta
-                if target_tilt_position is not None
-                else self._initial_tilt_position
-            )
+            total_tilt_step = tilt_delta if target_tilt_position is not None else self._initial_tilt_position
         else:
             return
         if target_tilt_position is not None:
@@ -93,9 +82,7 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
         if total_steps == 0 or duration == 0:
             self._current_operation = IDLE
-            self._loop.call_soon_threadsafe(
-                self.send_state, self.state, self.json_position
-            )
+            self._loop.call_soon_threadsafe(self.send_state, self.state, self.json_position)
             return
 
         # Calculate actual duration based on remaining distance
@@ -111,17 +98,11 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         needed_tilt_duration = tilt_duration * (total_tilt_step / 100)
         if target_tilt_position is None:
             tilt_delta = 1.0
-            
 
         while not self._stop_event.is_set():
-            current_time = (
-                time.monotonic()
-            )  # Pobierz aktualny czas tylko raz na iterację
-            elapsed_time = (
-                current_time - start_time
-            ) * 1000  # Konwersja na milisekundy
-
-           
+            current_time = time.monotonic()  # Pobierz aktualny czas tylko raz na iterację
+            elapsed_time = (current_time - start_time) * 1000  # Konwersja na milisekundy
+
             if elapsed_time < needed_tilt_duration:
                 tilt_progress = elapsed_time / needed_tilt_duration if needed_tilt_duration > 0 else 1.0
                 progress = 0.0
@@ -135,8 +116,10 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
                 # Obliczanie _tilt_position dla kierunku OPEN
                 if target_tilt_position is not None:
-                    self._tilt_position = min(target_tilt_position, self._initial_tilt_position + tilt_progress * tilt_delta)
-                else: # Fallback jeśli nie ma target_tilt_position
+                    self._tilt_position = min(
+                        target_tilt_position, self._initial_tilt_position + tilt_progress * tilt_delta
+                    )
+                else:  # Fallback jeśli nie ma target_tilt_position
                     self._tilt_position = min(
                         100.0, self._initial_tilt_position + tilt_progress * (100 - self._initial_tilt_position)
                     )
@@ -146,24 +129,23 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
                 # Obliczanie _tilt_position dla kierunku CLOSE
                 if target_tilt_position is not None:
-                    self._tilt_position = max(target_tilt_position, self._initial_tilt_position - tilt_progress * tilt_delta)
-                else: # Fallback jeśli nie ma target_tilt_position
+                    self._tilt_position = max(
+                        target_tilt_position, self._initial_tilt_position - tilt_progress * tilt_delta
+                    )
+                else:  # Fallback jeśli nie ma target_tilt_position
                     self._tilt_position = max(
                         0.0, self._initial_tilt_position - tilt_progress * self._initial_tilt_position
                     )
 
             self._last_timestamp = time.time()  # Wall clock for display
             if current_time - self._last_update_time >= 1:
-                self._loop.call_soon_threadsafe(
-                    self.send_state, self.state, self.json_position
-                )
+                self._loop.call_soon_threadsafe(self.send_state, self.state, self.json_position)
                 self._last_update_time = current_time
 
-            if target_tilt_position is not None and ((
-                direction == OPEN and self._tilt_position >= target_tilt_position
-            ) or (
-                direction == CLOSE and self._tilt_position <= target_tilt_position
-            )):
+            if target_tilt_position is not None and (
+                (direction == OPEN and self._tilt_position >= target_tilt_position)
+                or (direction == CLOSE and self._tilt_position <= target_tilt_position)
+            ):
                 break
 
             if target_position is not None and (
@@ -183,12 +165,8 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         # Send relay state to WebSocket (not MQTT - that's handled by output_type check)
         self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
         self._current_operation = IDLE
-        self._loop.call_soon_threadsafe(
-            self.send_state_and_save, self.json_position
-        )
-        self._last_update_time = (
-            time.monotonic()
-        )  # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
+        self._loop.call_soon_threadsafe(self.send_state_and_save, self.json_position)
+        self._last_update_time = time.monotonic()  # Upewnij się, że aktualizacja jest wysłana na końcu ruchu
 
     async def set_tilt(self, tilt_position: int) -> None:
         """Setting tilt position."""
@@ -200,31 +178,36 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
         tilt_diff = abs(self._tilt_position - tilt_position)
         estimated_time_s = tilt_diff / 100 * self._tilt_duration / 1000
-        
+
         if tilt_position > self._tilt_position:
             _LOGGER.info(
                 "Setting tilt %s from %d%% to %d%% (OPENING). Estimated time: %.2fs (tilt_duration=%dms)",
-                self._id, self._tilt_position, tilt_position, estimated_time_s, self._tilt_duration
-            )
-            await self.run_cover(
-                current_operation=OPENING, target_tilt_position=tilt_position
+                self._id,
+                self._tilt_position,
+                tilt_position,
+                estimated_time_s,
+                self._tilt_duration,
             )
+            await self.run_cover(current_operation=OPENING, target_tilt_position=tilt_position)
         elif tilt_position < self._tilt_position:
             _LOGGER.info(
                 "Setting tilt %s from %d%% to %d%% (CLOSING). Estimated time: %.2fs (tilt_duration=%dms)",
-                self._id, self._tilt_position, tilt_position, estimated_time_s, self._tilt_duration
-            )
-            await self.run_cover(
-                current_operation=CLOSING, target_tilt_position=tilt_position
+                self._id,
+                self._tilt_position,
+                tilt_position,
+                estimated_time_s,
+                self._tilt_duration,
             )
+            await self.run_cover(current_operation=CLOSING, target_tilt_position=tilt_position)
 
     @property
     def json_position(self) -> PositionDict:
-        return {"position": round(self.position, 0), "tilt": self.tilt}
+        """Return position dict with int values for API/MQTT/WebUI."""
+        return {"position": self.position, "tilt": self.tilt}
 
     @property
     def tilt(self) -> int:
-        return int(round(self._tilt_position, 0))
+        return round(self._tilt_position)
 
     @property
     def tilt_position(self) -> int:
@@ -245,6 +228,11 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
     def kind(self) -> str:
         return "venetian"
 
+    @property
+    def saved_position(self) -> SavedPositionDict:
+        """Raw float position for disk persistence (includes tilt)."""
+        return {"position": self._position, "tilt": self._tilt_position}
+
     async def set_cover_tilt_position(self, position: int) -> None:
         """Set cover tilt position (required by BaseVenetianCoverABC)."""
         await self.set_tilt(position)
@@ -254,7 +242,10 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         estimated_time_s = (100 - self._tilt_position) / 100 * self._tilt_duration / 1000
         _LOGGER.info(
             "Opening tilt cover %s from %d%%. Estimated time: %.2fs (tilt_duration=%dms)",
-            self._id, self._tilt_position, estimated_time_s, self._tilt_duration
+            self._id,
+            self._tilt_position,
+            estimated_time_s,
+            self._tilt_duration,
         )
         await self.set_tilt(tilt_position=100)
 
@@ -263,13 +254,16 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         estimated_time_s = self._tilt_position / 100 * self._tilt_duration / 1000
         _LOGGER.info(
             "Closing tilt cover %s from %d%%. Estimated time: %.2fs (tilt_duration=%dms)",
-            self._id, self._tilt_position, estimated_time_s, self._tilt_duration
+            self._id,
+            self._tilt_position,
+            estimated_time_s,
+            self._tilt_duration,
         )
         await self.set_tilt(tilt_position=0)
 
     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, tilt_duration
@@ -286,11 +280,12 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         current_operation: str,
         target_position: int | None = None,
         target_tilt_position: int | None = None,
+        **kwargs,
     ) -> None:
         if self._movement_thread and self._movement_thread.is_alive():
             _LOGGER.warning("Cover movement is already in progress. Stopping first.")
             await self.stop()
-        
+
         # If STOP was requested, don't start new movement
         if current_operation == STOP:
             await self.stop()
@@ -300,9 +295,7 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         self._initial_position = self._position
         self._initial_tilt_position = self._tilt_position
         self._stop_event.clear()
-        self._last_update_time = (
-            time.monotonic()
-        )  # Inicjalizacja czasu ostatniej aktualizacji
+        self._last_update_time = time.monotonic()  # Inicjalizacja czasu ostatniej aktualizacji
 
         if current_operation == OPENING:
             self._movement_thread = threading.Thread(

boneio/components/input/__init__.py

@@ -2,12 +2,18 @@
 
 This module provides high-level input components that combine
 hardware GPIO drivers with business logic, MQTT, and Home Assistant integration.
+
+Sub-packages:
+    remote: Virtual inputs from remote devices (ESPHome API, CAN bus, …)
 """
 
 from boneio.components.input.binary_sensor import GpioInputBinarySensor
 from boneio.components.input.event import GpioEventButton
+from boneio.components.input.remote import ESPHomeBinarySensorInput, RemoteInputBase
 
 __all__ = [
     "GpioInputBinarySensor",
     "GpioEventButton",
+    "ESPHomeBinarySensorInput",
+    "RemoteInputBase",
 ]

boneio/components/input/detectors.py

@@ -603,6 +603,93 @@ class MultiClickDetector:
                 )
 
 
+    def handle_raw_state(self, is_pressed: bool) -> None:
+        """Process a raw state change for virtual/remote inputs.
+
+        Uses wall-clock time instead of kernel GPIO timestamps.
+        Suitable for ESPHome binary sensors and other network-based inputs
+        that don't generate gpiod edge events.
+
+        Args:
+            is_pressed: True if the input is now active (pressed)
+        """
+        import time
+
+        timestamp_s = time.time()
+
+        if is_pressed:
+            # Debounce
+            if (
+                self._state.last_press_ts
+                and (timestamp_s - self._state.last_press_ts) < self._debounce_seconds
+            ):
+                return
+
+            _LOGGER.debug("RAW PRESSED: %s (%s)", self._name, self._pin)
+            self._state.last_press_ts = timestamp_s
+            self._state.last_press_loop_ts = self._loop.time()
+            self._state.last_release_ts = None
+
+            if self._state.finalizer:
+                self._state.finalizer.cancel()
+                self._state.finalizer = None
+                self._state.finalizer_scheduled_loop_ts = None
+
+            if self._sequence_mode == "exclusive" and self._state.pending_click_timer:
+                self._state.pending_click_timer.cancel()
+                self._state.pending_click_timer = None
+
+            self._state.long_press_scheduled_loop_ts = self._loop.time()
+            self._state.long_press_timer = self._loop.call_later(
+                self._hold_threshold,
+                self._detect_long_press,
+            )
+        else:
+            # Debounce
+            if (
+                self._state.last_release_ts
+                and (timestamp_s - self._state.last_release_ts)
+                < self._debounce_seconds
+            ):
+                return
+            if (
+                self._state.last_press_ts
+                and (timestamp_s - self._state.last_press_ts)
+                < self._debounce_seconds
+            ):
+                return
+
+            _LOGGER.debug("RAW RELEASED: %s (%s)", self._name, self._pin)
+            self._state.last_release_ts = timestamp_s
+
+            if self._state.long_hold_periodic_timer:
+                self._state.long_hold_periodic_timer.cancel()
+                self._state.long_hold_periodic_timer = None
+
+                if self._state.last_press_loop_ts:
+                    duration = self._loop.time() - self._state.last_press_loop_ts
+                    self._emit_click(LONG, duration)
+
+                def _reset():
+                    self._state.executed_long_actions = set()
+                    self._state.last_repeat_times = {}
+
+                self._loop.call_later(0.05, _reset)
+
+            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
+
+                self._state.click_count += 1
+
+                self._state.finalizer_scheduled_loop_ts = self._loop.time()
+                self._state.finalizer = self._loop.call_later(
+                    self._multiclick_window,
+                    self._finalize_clicks,
+                )
+
+
 class BinarySensorDetector:
     """Detects binary state changes (PRESSED/RELEASED) with software debounce."""
 

boneio/components/input/remote/__init__.py

@@ -0,0 +1,22 @@
+"""Remote input components — virtual inputs from external devices.
+
+This package provides remote input classes that receive state changes from
+external devices (ESPHome API, CAN bus, etc.) instead of local GPIO pins.
+All remote inputs share a common base :class:`RemoteInputBase` and implement
+the same duck-type interface as :class:`GpioBaseClass`.
+
+Subpackages:
+    base:    ``RemoteInputBase`` — shared logic (EventBus, actions, MultiClickDetector)
+    esphome: ``ESPHomeBinarySensorInput`` — ESPHome native API
+    # future:
+    # can_esphome: CAN bus → ESPHome device
+    # can_boneio:  CAN bus → another boneIO Black
+"""
+
+from boneio.components.input.remote.base import RemoteInputBase
+from boneio.components.input.remote.esphome import ESPHomeBinarySensorInput
+
+__all__ = [
+    "RemoteInputBase",
+    "ESPHomeBinarySensorInput",
+]