boneio 1.4.0.dev1__tar.gz → 1.4.0.dev3__tar.gz

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

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

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

@@ -25,8 +25,18 @@ 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.
+        """
         self._tilt_duration = tilt_duration.total_milliseconds  # Czas trwania ruchu lameli
         self._initial_tilt_position = float(restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"]))
 
@@ -34,9 +44,9 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         # --- TILT ---
         self._tilt_position = float(restored_state.get("tilt", DEFAULT_RESTORED_STATE["tilt"]))
 
-        # self._actuator_activation_duration = (
-        #     actuator_activation_duration.total_milliseconds
-        # )  # ms
+        self._tilt_restore_after_close = tilt_restore_after_close
+        self._tilt_before_close: float | None = None
+
         self._last_tilt_update = 0.0
 
         super().__init__(
@@ -44,13 +54,15 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             **kwargs,
         )
         _LOGGER.debug(
-            "VenetianCover %s initialized: open_time=%dms, close_time=%dms, tilt_duration=%dms, position=%d%%, tilt=%d%%",
+            "VenetianCover %s initialized: open_time=%dms, close_time=%dms, tilt_duration=%dms, "
+            "position=%d%%, tilt=%d%%, tilt_restore=%s",
             self._id,
             self._open_time,
             self._close_time,
             self._tilt_duration,
             position,
             self._tilt_position,
+            self._tilt_restore_after_close,
         )
 
     def _move_cover(
@@ -168,6 +180,30 @@ 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:
@@ -261,12 +297,62 @@ 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 when tilt_restore_after_close
+        is enabled. Clears saved value if tilt is already at 0%.
+        """
+        if self._tilt_restore_after_close 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
+                   Keys: open_time, close_time, tilt_duration, tilt_restore_after_close
         """
         if "open_time" in config:
             self._open_time = config["open_time"].total_milliseconds
@@ -274,6 +360,8 @@ 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.dev1 → boneio-1.4.0.dev3}/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) -> None:
+    async def async_turn_on(self, timestamp=None) -> bool:
         """Turn on all members in the group.
         
         Executes turn_on sequentially to prevent I2C bus contention
@@ -92,9 +92,16 @@ 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:
-            await x.async_turn_on(timestamp=timestamp)
+            result = await x.async_turn_on(timestamp=timestamp)
+            if not result:
+                all_ok = False
+        return all_ok
 
     async def async_turn_off(self, timestamp=None) -> None:
         """Turn off all members in the group.

{boneio-1.4.0.dev1 → boneio-1.4.0.dev3}/boneio/components/irrigation/controller.py

@@ -107,15 +107,15 @@ class IrrigationController:
         self._schedule = schedule or []
         self._water_sources = water_sources or []
         self._active_water_source_idx: int = 0
-        self._valve_open_delay_s = max(0, int(valve_open_delay_s))
-        self._valve_overlap_s = max(0, int(valve_overlap_s))
+        self._valve_open_delay_s = max(0, valve_open_delay_s)
+        self._valve_overlap_s = max(0, valve_overlap_s)
         self._standby = standby
 
         self._state = ControllerState.IDLE
         self._auto_advance = auto_advance
         self._reverse = reverse
-        self._multiplier = max(0.1, float(multiplier))
-        self._repeat = max(0, int(repeat))
+        self._multiplier = max(0.1, multiplier)
+        self._repeat = max(0, repeat)
         self._skip_next_run = False
 
         self._zone_timer_cancel = None
@@ -526,7 +526,7 @@ class IrrigationController:
                 await self._stop_current_zone()
                 self._active_zone_idx = next_idx
                 duration = self._scaled_duration(next_zone.run_duration)
-                self._active_zone_remaining_s = max(1, int(duration))
+                self._active_zone_remaining_s = max(1, duration)
                 self._run_start_utc = utcnow()
                 self._arm_zone_timer(self._active_zone_remaining_s)
                 await self.publish_all_states()
@@ -564,6 +564,9 @@ class IrrigationController:
 
         Activates the water source outputs (if any), then opens the zone valve,
         respecting per-source pump timing delays.
+
+        If any output is blocked by an interlock, the controller shuts down
+        and publishes an interlock fault notification.
         """
         if idx < 0 or idx >= len(self._zones):
             _LOGGER.error("Irrigation %s _start_zone: invalid index %d (zones=%d)", self.id, idx, len(self._zones))
@@ -571,7 +574,7 @@ class IrrigationController:
 
         zone = self._zones[idx]
         duration = override_duration if override_duration is not None else self._scaled_duration(zone.run_duration)
-        duration = max(1, int(duration))
+        duration = max(1, duration)
         src = self.active_water_source
 
         _LOGGER.debug(
@@ -594,7 +597,10 @@ class IrrigationController:
                 _LOGGER.debug(
                     "Irrigation %s: source '%s' ON, then wait %ds", self.id, src.id, src.pump_start_valve_delay_s
                 )
-                await self._activate_source()
+                source_ok = await self._activate_source()
+                if not source_ok:
+                    await self._handle_interlock_fault(zone.id, src.id)
+                    return
                 await asyncio.sleep(src.pump_start_valve_delay_s)
             elif src.pump_start_pump_delay_s > 0:
                 # Zone valve first, then source after delay
@@ -605,13 +611,21 @@ class IrrigationController:
                     src.pump_start_pump_delay_s,
                 )
                 try:
-                    await zone.valve.async_turn_on(timestamp=time.time())
+                    valve_ok = await zone.valve.async_turn_on(timestamp=time.time())
+                    if not valve_ok:
+                        await self._handle_interlock_fault(zone.id, src.id)
+                        return
                 except Exception as err:
                     _LOGGER.error("Failed to turn on zone %s: %s", zone.id, err)
                     await self.shutdown()
                     return
                 await asyncio.sleep(src.pump_start_pump_delay_s)
-                await self._activate_source()
+                source_ok = await self._activate_source()
+                if not source_ok:
+                    # Valve was already ON — turn it off before shutting down
+                    await zone.valve.async_turn_off(timestamp=time.time())
+                    await self._handle_interlock_fault(zone.id, src.id)
+                    return
                 try:
                     self._run_start_utc = utcnow()
                     self._arm_zone_timer(duration)
@@ -629,13 +643,20 @@ class IrrigationController:
             else:
                 # No delay — activate source, then optional valve_open_delay
                 _LOGGER.debug("Irrigation %s: source '%s' ON (no delay)", self.id, src.id)
-                await self._activate_source()
+                source_ok = await self._activate_source()
+                if not source_ok:
+                    await self._handle_interlock_fault(zone.id, src.id)
+                    return
                 if self._valve_open_delay_s > 0:
                     await asyncio.sleep(self._valve_open_delay_s)
 
         try:
             _LOGGER.debug("Irrigation %s: turning ON valve %s", self.id, zone.valve.id)
-            await zone.valve.async_turn_on(timestamp=time.time())
+            valve_ok = await zone.valve.async_turn_on(timestamp=time.time())
+            if not valve_ok:
+                await self._deactivate_source()
+                await self._handle_interlock_fault(zone.id, src.id if src else None)
+                return
             _LOGGER.debug("Irrigation %s: valve %s turned ON successfully", self.id, zone.valve.id)
         except Exception as err:
             _LOGGER.error("Failed to turn on zone %s valve %s: %s", zone.id, zone.valve.id, err, exc_info=True)
@@ -667,16 +688,21 @@ class IrrigationController:
         except Exception as err:
             _LOGGER.error("Failed to turn off zone %s: %s", zone.id, err)
 
-    async def _activate_source(self) -> None:
-        """Turn ON all outputs of the active water source."""
+    async def _activate_source(self) -> bool:
+        """Turn ON all outputs of the active water source.
+
+        Returns:
+            True if source was activated, False if blocked by interlock.
+        """
         src = self.active_water_source
         if src is None:
-            return
+            return True
         try:
             _LOGGER.debug("Irrigation %s: activating source '%s' outputs=%s", self.id, src.id, src.output_ids)
-            await src.activate(timestamp=time.time())
+            return await src.activate(timestamp=time.time())
         except Exception as err:
             _LOGGER.error("Failed to activate water source '%s' for %s: %s", src.id, self.id, err)
+            return False
 
     async def _deactivate_source(self) -> None:
         """Turn OFF all outputs of the active water source."""
@@ -689,6 +715,42 @@ class IrrigationController:
         except Exception as err:
             _LOGGER.error("Failed to deactivate water source '%s' for %s: %s", src.id, self.id, err)
 
+    async def _handle_interlock_fault(self, zone_id: str, source_id: str | None) -> None:
+        """Handle interlock-blocked activation.
+
+        Shuts down the controller and publishes a fault notification via MQTT
+        so that Home Assistant (or other consumers) can alert the user.
+
+        Args:
+            zone_id: ID of the zone that was being started.
+            source_id: ID of the water source (if any) whose output was blocked.
+        """
+        source_info = f" (source '{source_id}')" if source_id else ""
+        _LOGGER.error(
+            "Irrigation %s: INTERLOCK FAULT — could not start zone '%s'%s. "
+            "Another controller or output in the same interlock group is active. Shutting down.",
+            self.id,
+            zone_id,
+            source_info,
+        )
+
+        # Publish fault notification on MQTT
+        fault_payload = {
+            "fault": "interlock_blocked",
+            "controller": self.id,
+            "zone": zone_id,
+            "source": source_id or "",
+            "message": f"Irrigation '{self.name}' stopped: output blocked by interlock (zone: {zone_id})",
+        }
+        self._publish(
+            f"{self._topic_prefix}/{IRRIGATION}/{self.id}/fault",
+            fault_payload,
+            retain=False,
+        )
+
+        await self.shutdown()
+        await self.publish_all_states()
+
     async def _handle_pump_stop_sequence(self) -> None:
         """Handle pump stop timing according to active water source's delays."""
         src = self.active_water_source
@@ -706,7 +768,7 @@ class IrrigationController:
             await self._deactivate_source()
 
     def _scaled_duration(self, seconds: int) -> int:
-        return int(max(1, round(seconds * self._multiplier)))
+        return max(1, round(seconds * self._multiplier))
 
     def _current_zone_duration_seconds(self) -> int:
         if self._active_zone_idx is None:
@@ -727,7 +789,7 @@ class IrrigationController:
 
     def _arm_zone_timer(self, seconds: int) -> None:
         self._cancel_zone_timer()
-        point = utcnow() + timedelta(seconds=max(1, int(seconds)))
+        point = utcnow() + timedelta(seconds=max(1, seconds))
         self._zone_timer_cancel = async_track_point_in_time(
             loop=self._event_bus._loop,
             job=self._zone_timer_callback,
@@ -781,42 +843,42 @@ class IrrigationController:
         await self.publish_all_states()
 
     async def set_auto_advance(self, value: bool) -> None:
-        self._auto_advance = bool(value)
+        self._auto_advance = value
         self._save("auto_advance", self._auto_advance)
         await self.publish_all_states()
 
     async def set_reverse(self, value: bool) -> None:
-        self._reverse = bool(value)
+        self._reverse = value
         self._save("reverse", self._reverse)
         await self.publish_all_states()
 
     async def set_standby(self, value: bool) -> None:
-        self._standby = bool(value)
+        self._standby = value
         self._save("standby", self._standby)
         if self._standby and self._state in (ControllerState.RUNNING, ControllerState.PAUSED):
             await self.shutdown()
         await self.publish_all_states()
 
     async def set_multiplier(self, value: float) -> None:
-        self._multiplier = max(0.1, float(value))
+        self._multiplier = max(0.1, value)
         self._save("multiplier", self._multiplier)
         await self.publish_all_states()
 
     async def set_repeat(self, value: int) -> None:
-        self._repeat = max(0, int(value))
+        self._repeat = max(0, value)
         self._save("repeat", self._repeat)
         await self.publish_all_states()
 
     async def set_zone_enabled(self, zone_id: str, value: bool) -> None:
         for zone in self._zones:
             if zone.id == zone_id:
-                zone.enabled = bool(value)
+                zone.enabled = value
                 self._save(f"zone/{zone.id}/enabled", zone.enabled)
                 break
         await self.publish_all_states()
 
     async def set_skip_next_run(self, value: bool) -> None:
-        self._skip_next_run = bool(value)
+        self._skip_next_run = value
         self._save("skip_next_run", self._skip_next_run)
         await self.publish_all_states()
 
@@ -838,8 +900,8 @@ class IrrigationController:
     async def set_schedule_skip(self, schedule_idx: int, value: bool) -> None:
         if schedule_idx < 0 or schedule_idx >= len(self._schedule):
             return
-        self._schedule[schedule_idx]["skip"] = bool(value)
-        self._save(f"schedule/{schedule_idx}/skip", bool(value))
+        self._schedule[schedule_idx]["skip"] = value
+        self._save(f"schedule/{schedule_idx}/skip", value)
         await self.publish_all_states()
 
     def start_schedules(self) -> None:

{boneio-1.4.0.dev1 → boneio-1.4.0.dev3}/boneio/components/irrigation/water_source.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
+import asyncio
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from boneio.components.template import BasicOutput
+    from boneio.components.output.basic import BasicOutput
 
 
 @dataclass
@@ -16,14 +17,20 @@ class WaterSource:
     A water source defines which physical outputs (valves, pumps) need to be
     activated to supply water from this particular source.
 
+    When multiple outputs are defined and output_start_delay_s > 0,
+    outputs are activated sequentially (in order) with the specified delay
+    between each. On deactivation, outputs are turned off in reverse order.
+
     Example sources:
     - City water: single valve (OUT_06)
-    - Rainwater: valve (OUT_07) + pump (OUT_08) with pump delays
+    - Rainwater: valve (OUT_07) + pump (OUT_08) with 2s sequential delay
 
     Attributes:
         id: Unique identifier for this water source.
         name: Human-readable name.
         outputs: List of outputs to activate when this source is selected.
+        output_start_delay_s: Seconds to wait between activating each output (sequential ON).
+        output_stop_delay_s: Seconds to wait between deactivating each output (sequential OFF, reverse order).
         pump_start_pump_delay_s: Seconds to wait after opening valve before starting pump.
         pump_start_valve_delay_s: Seconds to wait after starting pump before opening zone valve.
         pump_stop_pump_delay_s: Seconds to wait after closing zone valve before stopping pump.
@@ -34,31 +41,57 @@ class WaterSource:
     id: str
     name: str
     outputs: list[BasicOutput] = field(default_factory=list)
+    output_start_delay_s: int = 0
+    output_stop_delay_s: int = 0
     pump_start_pump_delay_s: int = 0
     pump_start_valve_delay_s: int = 0
     pump_stop_pump_delay_s: int = 0
     pump_stop_valve_delay_s: int = 0
     pump_switch_off_during_valve_open_delay: bool = False
 
-    async def activate(self, timestamp: float) -> None:
+    async def activate(self, timestamp: float) -> bool:
         """Turn ON all outputs for this water source.
 
+        When output_start_delay_s > 0, outputs are activated sequentially
+        (first to last) with the configured delay between each one.
+
+        If any output is blocked by an interlock, all already-activated
+        outputs are rolled back (turned off in reverse order).
+
         Args:
             timestamp: Current timestamp for relay control.
+
+        Returns:
+            True if all outputs were activated, False if any was blocked.
         """
-        for output in self.outputs:
-            await output.async_turn_on(timestamp=timestamp)
+        for i, output in enumerate(self.outputs):
+            result = await output.async_turn_on(timestamp=timestamp)
+            if not result:
+                # Rollback: turn off already-activated outputs in reverse
+                for j in range(i - 1, -1, -1):
+                    await self.outputs[j].async_turn_off(timestamp=timestamp)
+                return False
+            if self.output_start_delay_s > 0 and i < len(self.outputs) - 1:
+                await asyncio.sleep(self.output_start_delay_s)
+        return True
 
     async def deactivate(self, timestamp: float) -> None:
         """Turn OFF all outputs for this water source.
 
+        When output_stop_delay_s > 0, outputs are deactivated in reverse
+        order (last to first) with the configured delay between each one.
+
         Args:
             timestamp: Current timestamp for relay control.
         """
-        for output in self.outputs:
+        reversed_outputs = list(reversed(self.outputs))
+        for i, output in enumerate(reversed_outputs):
             await output.async_turn_off(timestamp=timestamp)
+            if self.output_stop_delay_s > 0 and i < len(reversed_outputs) - 1:
+                await asyncio.sleep(self.output_stop_delay_s)
 
     @property
     def output_ids(self) -> list[str]:
         """Return list of output IDs for display/logging."""
         return [o.id for o in self.outputs]
+