boneIO 1.4.0__tar.gz → 1.4.0.dev1__tar.gz

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

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

{boneio-1.4.0 → boneio-1.4.0.dev1}/boneio/components/cover/cover.py

@@ -192,12 +192,6 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._movement_thread = None
         self._stop_event = threading.Event()
 
-        # Flag set by action executor to signal this call originates from a button action.
-        # Used by VenetianCover to conditionally skip tilt restore.
-        self._from_action: bool = False
-        # When True, tilt restore is explicitly requested by the action definition.
-        self._action_tilt_restore: bool = False
-
         self._event_bus.add_sigterm_listener(self.on_exit)
 
         with suppress(RuntimeError):

{boneio-1.4.0 → boneio-1.4.0.dev1}/boneio/components/cover/venetian.py

@@ -25,18 +25,8 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         tilt_duration: TimePeriod,  # ms
         actuator_activation_duration: TimePeriod,  # ms
         restored_state: dict = DEFAULT_RESTORED_STATE,
-        tilt_restore_after_close: bool = False,
         **kwargs,
     ) -> None:
-        """Initialize venetian cover.
-
-        Args:
-            tilt_duration: Duration for full tilt movement.
-            actuator_activation_duration: Actuator activation time (unused).
-            restored_state: Persisted position/tilt from disk.
-            tilt_restore_after_close: If True, restore previous tilt
-                position after closing the cover (UI/HA calls).
-        """
         self._tilt_duration = tilt_duration.total_milliseconds  # Czas trwania ruchu lameli
         self._initial_tilt_position = float(restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"]))
 
@@ -44,9 +34,9 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         # --- TILT ---
         self._tilt_position = float(restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"]))
 
-        self._tilt_restore_after_close = tilt_restore_after_close
-        self._tilt_before_close: float | None = None
-
+        # self._actuator_activation_duration = (
+        #     actuator_activation_duration.total_milliseconds
+        # )  # ms
         self._last_tilt_update = 0.0
 
         super().__init__(
@@ -54,15 +44,13 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             **kwargs,
         )
         _LOGGER.debug(
-            "VenetianCover %s initialized: open_time=%dms, close_time=%dms, tilt_duration=%dms, "
-            "position=%d%%, tilt=%d%%, tilt_restore=%s",
+            "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._tilt_restore_after_close,
         )
 
     def _move_cover(
@@ -180,30 +168,6 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         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
 
-        # Tilt restore: schedule tilt recovery on the event loop.
-        # Skip when position reached 0% (fully closed) or 100% (fully open)
-        # — at extremes, restoring tilt contradicts user intent.
-        if self._tilt_restore_after_close and self._tilt_before_close is not None:
-            restore_tilt = self._tilt_before_close
-            self._tilt_before_close = None
-            at_extreme = self._position <= 0 or self._position >= 100
-            if not at_extreme and restore_tilt > 0 and abs(self._tilt_position - restore_tilt) >= 1:
-                _LOGGER.info(
-                    "VenetianCover %s: restoring tilt from %d%% to %d%%",
-                    self._id,
-                    round(self._tilt_position),
-                    round(restore_tilt),
-                )
-                self._loop.call_soon_threadsafe(
-                    lambda t=restore_tilt: asyncio.ensure_future(self.set_tilt(int(round(t))))
-                )
-            elif at_extreme:
-                _LOGGER.debug(
-                    "VenetianCover %s: skipping tilt restore at extreme position %d%%",
-                    self._id,
-                    round(self._position),
-                )
-
     async def set_tilt(self, tilt_position: int) -> None:
         """Setting tilt position."""
         if not 0 <= tilt_position <= 100:
@@ -297,69 +261,12 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         )
         await self.set_tilt(tilt_position=0)
 
-    def _save_tilt_for_restore(self) -> None:
-        """Save current tilt position for later restoration.
-
-        Called before any closing movement. Determines whether to save
-        based on the call source:
-        - UI/HA calls: uses tilt_restore_after_close setting
-        - Action calls: uses _action_tilt_restore flag (set by executor)
-        """
-        if self._from_action:
-            should_restore = self._action_tilt_restore
-        else:
-            should_restore = self._tilt_restore_after_close
-
-        if should_restore and self._tilt_position > 0:
-            self._tilt_before_close = self._tilt_position
-            _LOGGER.debug(
-                "VenetianCover %s: saving tilt=%d%% before close",
-                self._id,
-                round(self._tilt_position),
-            )
-        else:
-            self._tilt_before_close = None
-
-    async def close(self) -> None:
-        """Close venetian cover.
-
-        If tilt_restore_after_close is enabled, saves the current tilt
-        position so it can be restored after the closing movement finishes.
-        """
-        self._save_tilt_for_restore()
-        await super().close()
-
-    async def set_cover_position(self, position: int) -> None:
-        """Set cover position with tilt restore support.
-
-        When moving to a lower position (closing direction) and
-        tilt_restore_after_close is enabled, saves the current tilt
-        so it can be restored after the movement finishes.
-
-        Args:
-            position: Target position (0-100).
-        """
-        if position < self._position:
-            self._save_tilt_for_restore()
-        else:
-            self._tilt_before_close = None
-        await super().set_cover_position(position)
-
-    async def open(self) -> None:
-        """Open venetian cover.
-
-        Clears any saved tilt-before-close value since opening
-        resets the tilt to 100% naturally.
-        """
-        self._tilt_before_close = None
-        await super().open()
-
     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, tilt_restore_after_close
+                   Keys: open_time, close_time, tilt_duration
         """
         if "open_time" in config:
             self._open_time = config["open_time"].total_milliseconds
@@ -367,8 +274,6 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             self._close_time = config["close_time"].total_milliseconds
         if "tilt_duration" in config and config["tilt_duration"]:
             self._tilt_duration = config["tilt_duration"].total_milliseconds
-        if "tilt_restore_after_close" in config:
-            self._tilt_restore_after_close = bool(config["tilt_restore_after_close"])
 
     async def run_cover(
         self,

{boneio-1.4.0 → boneio-1.4.0.dev1}/boneio/components/group/output_group.py

@@ -84,7 +84,7 @@ class OutputGroup(BasicOutput):
             self._state = state
             self._loop.create_task(self.async_send_state())
 
-    async def async_turn_on(self, timestamp=None) -> bool:
+    async def async_turn_on(self, timestamp=None) -> None:
         """Turn on all members in the group.
         
         Executes turn_on sequentially to prevent I2C bus contention
@@ -92,16 +92,9 @@ class OutputGroup(BasicOutput):
         
         Args:
             timestamp: Optional timestamp for the operation
-
-        Returns:
-            True if all members were turned on, False if any was blocked.
         """
-        all_ok = True
         for x in self._group_members:
-            result = await x.async_turn_on(timestamp=timestamp)
-            if not result:
-                all_ok = False
-        return all_ok
+            await x.async_turn_on(timestamp=timestamp)
 
     async def async_turn_off(self, timestamp=None) -> None:
         """Turn off all members in the group.