boneio 1.6.0.dev18__tar.gz → 1.6.0.dev20__tar.gz

{boneio-1.6.0.dev18/boneio.egg-info → boneio-1.6.0.dev20}/PKG-INFO

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

{boneio-1.6.0.dev18 → boneio-1.6.0.dev20}/boneio/components/cover/cover.py

@@ -21,10 +21,21 @@ from boneio.const import (
 from boneio.core.events import EventBus
 from boneio.core.messaging import BasicMqtt
 from boneio.core.utils import TimePeriod
+from boneio.core.utils.timeperiod import ensure_time_period
 from boneio.models import CoverState, PositionDict, SavedPositionDict
 from boneio.models.events import CoverEvent
 
 _LOGGER = logging.getLogger(__name__)
+# How often a moving cover recomputes its position. The relay is not switched
+# off on this grid — the last wait is cut short to end exactly at the target.
+MOVE_POLL_INTERVAL = 0.05  # s
+# Extra relay time on a movement ending fully open or closed, as a percent of
+# open_time/close_time. Time-based position drifts; running into the motor's
+# own endstop brings it back to a known 0% / 100%.
+DEFAULT_ENDSTOP_OVERRUN = 10  # %
+# Pause before energising the opposite relay, so a capacitor motor comes to
+# rest before it is driven the other way.
+DEFAULT_DIRECTION_CHANGE_WAIT_MS = 500
 
 
 class BaseCoverABC(ABC):
@@ -159,6 +170,9 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         event_bus: EventBus,
         position: float = 100.0,
         name: str | None = None,
+        actuator_activation_duration: TimePeriod | None = None,
+        endstop_overrun: int = DEFAULT_ENDSTOP_OVERRUN,
+        direction_change_wait_time: TimePeriod | None = None,
         **kwargs,
     ) -> None:
         # Use provided name or fall back to id
@@ -172,6 +186,21 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._event_bus = event_bus
         self._open_time = open_time.total_milliseconds
         self._close_time = close_time.total_milliseconds
+        # Time from energising the relay until the motor actually moves. Some
+        # drives (Somfy J4 WT) ignore orders shorter than ~200ms, so a short
+        # tilt step would never happen without it.
+        self._actuator_activation_ms = (
+            actuator_activation_duration.total_milliseconds if actuator_activation_duration is not None else 0.0
+        )
+        self._endstop_overrun = float(endstop_overrun)
+        self._direction_change_wait_ms = (
+            direction_change_wait_time.total_milliseconds
+            if direction_change_wait_time is not None
+            else DEFAULT_DIRECTION_CHANGE_WAIT_MS
+        )
+        # (relay, monotonic time) of the last relay this cover switched off —
+        # a reversal waits out direction_change_wait_time from that moment.
+        self._last_relay_off: tuple[BasicOutput, float] | None = None
         self._position = position
         self._initial_position: float = position
         self._current_operation = IDLE
@@ -203,6 +232,112 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         with suppress(RuntimeError):
             self._loop.call_soon_threadsafe(self._loop.call_later, 0.5, self.send_state, self.state, self.json_position)
 
+    def _drive_relay(self, relay: BasicOutput, travel_ms: float, apply_movement: Callable[[float], None]) -> None:
+        """Hold ``relay`` on until the cover has travelled ``travel_ms``, or until stopped.
+
+        Runs in the movement thread. The motor is assumed to stand still for
+        the first ``actuator_activation_duration`` after the relay closes, so
+        the relay stays on for that long *plus* ``travel_ms``.
+
+        When the other relay was switched off less than
+        ``direction_change_wait_time`` ago, it first waits out the rest of that
+        time. A stop during the wait leaves the relay untouched.
+
+        ``apply_movement`` gets how long the motor has really been moving (ms)
+        and updates the position from it. It is called on every poll and once
+        more after the relay has dropped, timed at the turn-off — so a stop
+        between polls, or the I2C write itself, is not lost from the position.
+
+        Args:
+            relay: The open or close relay to drive.
+            travel_ms: Motor movement time needed to reach the target.
+            apply_movement: Callback converting moving time to position.
+        """
+        activation_ms = self._actuator_activation_ms
+        deadline_ms = activation_ms + travel_ms
+
+        if self._last_relay_off is not None and self._last_relay_off[0] is not relay:
+            since_off_ms = (time.monotonic() - self._last_relay_off[1]) * 1000
+            wait_ms = self._direction_change_wait_ms - since_off_ms
+            if wait_ms > 0:
+                _LOGGER.debug("Cover %s reverses direction, waiting %dms first", self._id, wait_ms)
+                if self._stop_event.wait(wait_ms / 1000):
+                    return
+
+        relay.turn_on()
+        # Send relay state to WebSocket (not MQTT - that's handled by output_type check)
+        with suppress(RuntimeError):
+            self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
+        # Both timestamps are taken after the relay write returns, so the I2C
+        # latency of turn_on and turn_off cancels out.
+        start_time = time.monotonic()
+
+        while True:
+            current_time = time.monotonic()
+            elapsed_ms = (current_time - start_time) * 1000
+            if elapsed_ms >= deadline_ms:
+                break
+            apply_movement(max(0.0, elapsed_ms - activation_ms))
+            self._last_timestamp = time.time()  # Wall clock for display
+            if current_time - self._last_update_time >= 1:
+                with suppress(RuntimeError):
+                    self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
+                self._last_update_time = current_time
+            # Waiting on the event instead of sleeping lets stop() cut in at once.
+            if self._stop_event.wait(min(deadline_ms - elapsed_ms, MOVE_POLL_INTERVAL * 1000) / 1000):
+                break
+
+        relay.turn_off()
+        off_time = time.monotonic()
+        self._last_relay_off = (relay, off_time)
+        elapsed_ms = (off_time - start_time) * 1000
+        apply_movement(max(0.0, elapsed_ms - activation_ms))
+        self._last_timestamp = time.time()
+        with suppress(RuntimeError):
+            self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
+
+    def _endstop_overrun_ms(self, duration: float, start: float, end: float) -> float:
+        """Relay time to add so a movement ending at 0% or 100% hits the endstop.
+
+        Only a movement that really travels to an end gets it: an already
+        closed cover is not driven into its endstop again.
+
+        Args:
+            duration: Full 0-100% time of this direction, in ms.
+            start: Position the movement starts from.
+            end: Position the movement ends at.
+        """
+        if end not in (0, 100) or abs(end - start) <= 0:
+            return 0.0
+        return duration * self._endstop_overrun / 100.0
+
+    def _is_fully_open(self) -> bool:
+        """Whether open() has nothing left to do."""
+        return self._position >= 100
+
+    def _is_fully_closed(self) -> bool:
+        """Whether close() has nothing left to do."""
+        return self._position <= 0
+
+    def update_config_times(self, config: dict) -> None:
+        """Update timing shared by all cover platforms.
+
+        Args:
+            config: Cover configuration; time values as TimePeriod or strings.
+        """
+        if "open_time" in config:
+            self._open_time = ensure_time_period(config["open_time"]).total_milliseconds
+        if "close_time" in config:
+            self._close_time = ensure_time_period(config["close_time"]).total_milliseconds
+        # Optional field: a removed value means "no activation delay" again.
+        activation = config.get("actuator_activation_duration")
+        self._actuator_activation_ms = ensure_time_period(activation).total_milliseconds if activation else 0.0
+        self._endstop_overrun = float(config.get("endstop_overrun", DEFAULT_ENDSTOP_OVERRUN))
+        wait = config.get("direction_change_wait_time")
+        self._direction_change_wait_ms = (
+            ensure_time_period(wait).total_milliseconds if wait is not None else DEFAULT_DIRECTION_CHANGE_WAIT_MS
+        )
+
     async def on_exit(self) -> None:
         """Stop on exit."""
         await self.stop(on_exit=True)
@@ -238,7 +373,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
                 self.send_state(self.state, self.json_position)
 
     async def open(self) -> None:
-        if self._position >= 100:
+        if self._is_fully_open():
             return
         estimated_time_s = (100 - self._position) / 100 * self._open_time / 1000
         _LOGGER.info(
@@ -253,7 +388,7 @@ class BaseCover(BaseCoverABC, BasicMqtt):
         self._message_bus.send_message(topic=f"{self._send_topic}/state", payload=OPENING)
 
     async def close(self) -> None:
-        if self._position <= 0:
+        if self._is_fully_closed():
             return
         estimated_time_s = self._position / 100 * self._close_time / 1000
         _LOGGER.info(

{boneio-1.6.0.dev18 → boneio-1.6.0.dev20}/boneio/components/cover/time_based.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import logging
 import threading
 import time
@@ -12,7 +11,6 @@ from boneio.components.output import BasicOutput
 from boneio.const import CLOSE, CLOSING, IDLE, OPEN, OPENING, STOP
 from boneio.core.events import EventBus
 from boneio.core.utils import TimePeriod
-from boneio.core.utils.timeperiod import ensure_time_period
 
 _LOGGER = logging.getLogger(__name__)
 DEFAULT_RESTORED_STATE = {"position": 100}
@@ -81,48 +79,17 @@ class TimeBasedCover(BaseCover):
                 self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
             return
 
-        # Calculate actual duration based on remaining distance
         # duration is full time for 100% movement, scale it by actual distance to travel
-        actual_duration = duration * (total_steps / 100.0)
+        end_position = target_position if target_position is not None else (100 if direction == OPEN else 0)
+        travel_ms = duration * abs(end_position - self._initial_position) / 100.0
+        travel_ms += self._endstop_overrun_ms(duration, self._initial_position, end_position)
+        sign = 1 if direction == OPEN else -1
 
-        relay.turn_on()
-        # Send relay state to WebSocket (not MQTT - that's handled by output_type check)
-        with suppress(RuntimeError):
-            self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
-        start_time = time.monotonic()
-
-        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
-            progress = elapsed_time / actual_duration if actual_duration > 0 else 1.0
-
-            if direction == OPEN:
-                self._position = min(100.0, self._initial_position + progress * total_steps)
-            elif direction == CLOSE:
-                self._position = max(0.0, self._initial_position - progress * total_steps)
-
-            self._last_timestamp = time.time()  # Wall clock for display
-            if current_time - self._last_update_time >= 1:
-                try:
-                    self._loop.call_soon_threadsafe(lambda: self.send_state(self.state, self.json_position))
-                except RuntimeError:
-                    break
-                self._last_update_time = current_time
-
-            if target_position is not None and (
-                (direction == OPEN and self._position >= target_position)
-                or (direction == CLOSE and self._position <= target_position)
-            ):
-                break
-
-            if progress >= 1.0:
-                break
-
-            time.sleep(0.05)  # Małe opóźnienie, aby nie blokować CPU
-        relay.turn_off()
-        # Send relay state to WebSocket (not MQTT - that's handled by output_type check)
-        with suppress(RuntimeError):
-            self._loop.call_soon_threadsafe(lambda r=relay: asyncio.ensure_future(r.async_send_state()))
+        def apply_movement(moving_ms: float) -> None:
+            moved = moving_ms / duration * 100.0
+            self._position = min(100.0, max(0.0, self._initial_position + sign * moved))
+
+        self._drive_relay(relay, travel_ms, apply_movement)
         self._current_operation = IDLE
         with suppress(RuntimeError):
             self._loop.call_soon_threadsafe(lambda: self.send_state_and_save(self.json_position))
@@ -157,15 +124,3 @@ class TimeBasedCover(BaseCover):
     @property
     def kind(self) -> str:
         return "time"
-
-    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
-        """
-        if "open_time" in config:
-            self._open_time = ensure_time_period(config["open_time"]).total_milliseconds
-        if "close_time" in config:
-            self._close_time = ensure_time_period(config["close_time"]).total_milliseconds

{boneio-1.6.0.dev18 → boneio-1.6.0.dev20}/boneio/components/cover/venetian.py

@@ -33,7 +33,8 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
         Args:
             tilt_duration: Duration for full tilt movement.
-            actuator_activation_duration: Actuator activation time (unused).
+            actuator_activation_duration: Time from energising the relay until
+                the motor moves; added to every movement.
             restored_state: Persisted position/tilt from disk.
             tilt_restore_after_close: If True, restore previous tilt
                 position after closing the cover (UI/HA calls).
@@ -52,15 +53,17 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
         super().__init__(
             position=position,
+            actuator_activation_duration=actuator_activation_duration,
             **kwargs,
         )
         _LOGGER.debug(
             "VenetianCover %s initialized: open_time=%dms, close_time=%dms, tilt_duration=%dms, "
-            "position=%d%%, tilt=%d%%, tilt_restore=%s",
+            "actuator_activation=%dms, position=%d%%, tilt=%d%%, tilt_restore=%s",
             self._id,
             self._open_time,
             self._close_time,
             self._tilt_duration,
+            self._actuator_activation_ms,
             position,
             self._tilt_position,
             self._tilt_restore_after_close,
@@ -79,12 +82,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
-
         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
+            if total_steps == 0 and target_position is None:
+                # Down at 0% with the slats still open: closing turns them shut.
+                total_steps = self._initial_tilt_position
         else:
             return
         if target_tilt_position is not None:
@@ -112,85 +115,27 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             self._loop.call_soon_threadsafe(self.send_state, self.state, self.json_position)
             return
 
-        # Calculate actual duration based on remaining distance
-        # duration is full time for 100% movement, scale it by actual distance to travel
-        actual_duration = duration * (total_steps / 100.0)
-
-        relay.turn_on()
-        # 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()))
-        start_time = time.monotonic()
-        progress = 0.0
-        tilt_progress = 0.0
-        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
-
-            if elapsed_time < needed_tilt_duration:
-                tilt_progress = elapsed_time / needed_tilt_duration if needed_tilt_duration > 0 else 1.0
-                progress = 0.0
-            else:
-                tilt_progress = 1.0
-                progress = (elapsed_time - needed_tilt_duration) / actual_duration if actual_duration > 0 else 1.0
-
-            if direction == OPEN:
-                # Obliczanie _position dla kierunku OPEN
-                self._position = min(100.0, self._initial_position + progress * total_steps)
-
-                # 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(
-                        100.0, self._initial_tilt_position + tilt_progress * (100 - self._initial_tilt_position)
-                    )
-            elif direction == CLOSE:
-                # Obliczanie _position dla kierunku CLOSE
-                self._position = max(0.0, self._initial_position - progress * total_steps)
-
-                # 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(
-                        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._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)
-            ):
-                break
-
-            if target_position is not None and (
-                (direction == OPEN and self._position >= target_position)
-                or (direction == CLOSE and self._position <= target_position)
-            ):
-                break
-
-            if progress >= 1.0 or (target_tilt_position and tilt_progress >= 1.0):
-                break
-
-            if target_tilt_position is not None and abs(self._tilt_position - target_tilt_position) < 5:
-                time.sleep(0.01)
-            else:
-                time.sleep(0.05)
-        relay.turn_off()
-        # 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()))
+        # Slats turn first, over the tilt range left in this direction; only
+        # once they are fully turned does the cover itself travel.
+        sign = 1 if direction == OPEN else -1
+        tilt_room = 100 - self._initial_tilt_position if direction == OPEN else self._initial_tilt_position
+        tilt_room_ms = tilt_duration * tilt_room / 100.0
+        if target_tilt_position is not None:
+            travel_ms = tilt_duration * tilt_delta / 100.0
+        else:
+            end_position = target_position if target_position is not None else (100 if direction == OPEN else 0)
+            travel_ms = tilt_room_ms + duration * abs(end_position - self._initial_position) / 100.0
+            travel_ms += self._endstop_overrun_ms(duration, self._initial_position, end_position)
+
+        def apply_movement(moving_ms: float) -> None:
+            tilt_moved = min(tilt_room, moving_ms / tilt_duration * 100.0) if tilt_duration > 0 else tilt_room
+            self._tilt_position = self._initial_tilt_position + sign * tilt_moved
+            # Movement past the tilt range is cover travel — also when a tilt
+            # step overruns, since the motor really did keep going.
+            moved = max(0.0, moving_ms - tilt_room_ms) / duration * 100.0
+            self._position = min(100.0, max(0.0, self._initial_position + sign * moved))
+
+        self._drive_relay(relay, travel_ms, apply_movement)
         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
@@ -315,6 +260,10 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
         )
         await self.set_tilt(tilt_position=0)
 
+    def _is_fully_closed(self) -> bool:
+        """Closed means down at 0% *and* the slats shut, not just 0%."""
+        return self._position <= 0 and self._tilt_position <= 0
+
     def _save_tilt_for_restore(self) -> None:
         """Save current tilt position for later restoration.
 
@@ -373,12 +322,10 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
 
         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, actuator_activation_duration,
+                   tilt_duration, tilt_restore_after_close
         """
-        if "open_time" in config:
-            self._open_time = ensure_time_period(config["open_time"]).total_milliseconds
-        if "close_time" in config:
-            self._close_time = ensure_time_period(config["close_time"]).total_milliseconds
+        super().update_config_times(config)
         if "tilt_duration" in config and config["tilt_duration"]:
             self._tilt_duration = ensure_time_period(config["tilt_duration"]).total_milliseconds
         if "tilt_restore_after_close" in config:

{boneio-1.6.0.dev18 → boneio-1.6.0.dev20}/boneio/core/auth/migration.py

@@ -69,12 +69,21 @@ def migrate_legacy_auth(
     if store.is_provisioned():
         return MigrationResult(False, reason="already_provisioned")
 
-    if not isinstance(legacy_auth, dict) or not legacy_auth:
+    if not isinstance(legacy_auth, dict):
         return MigrationResult(False, reason="no_legacy_auth")
 
     username = str(legacy_auth.get("username") or "").strip()
     password = str(legacy_auth.get("password") or "")
 
+    # Only the login pair makes this a pre-1.6 block. The schema fills
+    # web.auth with its defaults (allow_anonymous: false) on every device, so
+    # "non-empty" was true everywhere: each fresh controller was reported as
+    # incomplete legacy auth and, through that, as configured before — and the
+    # wizard hid the import and device steps from exactly the devices that
+    # need them.
+    if not username and not password:
+        return MigrationResult(False, reason="no_legacy_auth")
+
     if not username or not password:
         _LOGGER.warning(
             "web.auth in config.yaml is incomplete (username and password are "

{boneio-1.6.0.dev18 → boneio-1.6.0.dev20}/boneio/core/manager/covers.py

@@ -232,7 +232,7 @@ class CoverManager:
 
         # Normalize time period fields — during hot-reload YAML values may
         # arrive as raw strings (e.g. "5s") instead of TimePeriod objects.
-        for time_key in ("open_time", "close_time", "actuator_activation_duration"):
+        for time_key in ("open_time", "close_time", "actuator_activation_duration", "direction_change_wait_time"):
             if time_key in config and config[time_key] is not None:
                 config[time_key] = ensure_time_period(config[time_key])
 

{boneio-1.6.0.dev18 → boneio-1.6.0.dev20}/boneio/core/manager/display.py

@@ -269,6 +269,45 @@ class DisplayManager:
         if self._host_data is not None:
             self._host_data.refresh_mqtt_status()
 
+    def show_migration_progress(self, pct: int, message: str) -> None:
+        """Say on the display that system migrations are running.
+
+        They run before the web server starts and can take minutes — an apt
+        install on a controller several releases behind. Until now the display
+        froze on the host/version screen, the panel did not answer, and the
+        controller looked hung to whoever had just updated it: exactly when
+        somebody pulls the plug.
+
+        Args:
+            pct: Share of the pending migrations already done.
+            message: The runner's line for the migration now running.
+        """
+        step = message.removeprefix("Applying migration ")
+        try:
+            if self._oled is not None:
+                self._oled.show_notice(
+                    "Updating",
+                    lambda: ["Do not power off.", f"{pct}% {step}"],
+                    still_needed=lambda: True,
+                )
+            else:
+                # No oled: section, so early_oled still owns the screen.
+                from boneio.hardware.display.early_oled import draw_status
+
+                draw_status(f"Updating system {pct}%", device=self._early_oled_device)
+        except Exception as err:  # noqa: BLE001 - never stop a migration over the display
+            _LOGGER.debug("Could not show migration progress on the OLED: %s", err)
+
+    def clear_migration_progress(self) -> None:
+        """Take the migration notice down once the migrations are over."""
+        if self._oled is None:
+            return
+        try:
+            if self._oled.notice is not None and self._oled.notice[0] == "Updating":
+                self._oled.clear_notice()
+        except Exception as err:  # noqa: BLE001
+            _LOGGER.debug("Could not clear migration progress on the OLED: %s", err)
+
     def reload_oled(self) -> None:
         """Hot-reload OLED configuration from file.
         

{boneio-1.6.0.dev18 → boneio-1.6.0.dev20}/boneio/core/manager/manager.py

@@ -333,7 +333,9 @@ class Manager:
         # Run system migration startup check (discovers pending migrations,
         # detects bootstrap_required, applies if helper is installed).
         try:
-            migration_status = self.migration_runner.startup_check()
+            migration_status = self.migration_runner.startup_check(
+                progress_callback=self.display.show_migration_progress
+            )
             _LOGGER.info(
                 "Migration startup_check finished: status=%s, pending=%d, bootstrap_required=%s",
                 migration_status.value,
@@ -342,6 +344,8 @@ class Manager:
             )
         except Exception as exc:
             _LOGGER.error("Migration startup_check failed: %s", exc, exc_info=True)
+        finally:
+            self.display.clear_migration_progress()
 
         _LOGGER.info("Manager initialization complete")
 

{boneio-1.6.0.dev18 → boneio-1.6.0.dev20}/boneio/core/system_ops.py

@@ -162,6 +162,15 @@ def overlay_set(overlay: str, timeout: int = 30) -> Result:
     return run("overlay-set", overlay, timeout=timeout)
 
 
+def overlay_repair(timeout: int = 60) -> Result:
+    """Copy a missing boneIO overlay into the boot kernel's directories.
+
+    Files only: the helper leaves uEnv.txt as it is. The output is the kernel
+    check's report — ``status`` ok, repaired or problem, and ``message``.
+    """
+    return run("overlay-repair", timeout=timeout)
+
+
 def mqtt_password(account: str, password: str, timeout: int = 60) -> Result:
     """Set a broker password for one of the managed accounts.
 

{boneio-1.6.0.dev18 → boneio-1.6.0.dev20}/boneio/core/utils/overlay.py

@@ -71,40 +71,6 @@ def overlay_dirs_for_kernel(kernel_version: str) -> tuple[Path, Path]:
     return base, base / "overlays"
 
 
-def find_overlay_source(exclude: tuple[Path, ...] = ()) -> Path | None:
-    """Find a directory containing boneIO overlays, to copy from.
-
-    Searches every ``/boot/dtbs/*/`` directory and its ``overlays/``
-    subdirectory, newest kernel first, so a repair prefers the most recent
-    known-good set.
-
-    Args:
-        exclude: Directories to skip (typically the repair destinations).
-
-    Returns:
-        Directory containing at least one boneIO overlay, or ``None``.
-    """
-    if not DTBS_ROOT.is_dir():
-        return None
-
-    excluded = {p.resolve() for p in exclude if p.exists()}
-
-    for kdir in sorted(DTBS_ROOT.iterdir(), reverse=True):
-        if not kdir.is_dir():
-            continue
-        for candidate in (kdir, kdir / "overlays"):
-            if not candidate.is_dir():
-                continue
-            try:
-                if candidate.resolve() in excluded:
-                    continue
-            except OSError:
-                continue
-            if any(candidate.glob(OVERLAY_GLOB)):
-                return candidate
-    return None
-
-
 def missing_overlay_dirs(kernel_version: str) -> list[Path]:
     """Return the overlay destinations that lack boneIO overlays.
 

{boneio-1.6.0.dev18 → boneio-1.6.0.dev20}/boneio/migrations/assets/MANIFEST.sha256

@@ -13,7 +13,7 @@ bff00753c72fb17609a6f7b3a58ef78b7b394da12d19fd65b875f2889695e2b4  docker/nodered
 3f41bcf2311bef4042f8082b7ae769fe298f05f46739e47f14e661a3c47733b0  helpers/boneio-containers
 dff0cd02daad2cbd525a0535f8f3562bb742e7e737b24c69e5afa986415e67e4  helpers/boneio-helpers-heal
 7615397aa52a3cb34cda4b3831d1306121844e2cc0403c114e95d8731075dd3b  helpers/boneio-migrate-v2
-bf2f72174edb3ccc7edef69b29792ad3885879c249ba6c50e1ec22d7bbca85b6  helpers/boneio-system
+08614f7672b7c469c5b2d981284477586a911d1a947a06d2a70ccf0c4f1a444e  helpers/boneio-system
 f316c778b3125e4e992942c889c4082f8a12f578a6d68c4e7c79fa80e4cc94a1  issue.d/10-boneio.issue
 83260e860f5431f3240617e88dba456ba39c52dbe4625e832d00fd241bad7701  journald/boneio-console.conf
 e6013f4fbf11693f39123b1e6159c7d7224a7c832e994722120980f64039c17e  journald/journald.conf