boneio 1.5.0.dev41__tar.gz → 1.5.2.dev1__tar.gz

{boneio-1.5.0.dev41/boneio.egg-info → boneio-1.5.2.dev1}/PKG-INFO

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

{boneio-1.5.0.dev41 → boneio-1.5.2.dev1}/boneio/bonecli.py

@@ -258,9 +258,6 @@ def run(
         from boneio.const import ACTION
         _LOGGER.debug("[RUNNER IMPORT] boneio.const: %.2fs", _time.monotonic() - _t_a)
         _t_a = _time.monotonic()
-        from boneio.core.cloud import CloudRegistration
-        _LOGGER.debug("[RUNNER IMPORT] boneio.core.cloud: %.2fs", _time.monotonic() - _t_a)
-        _t_a = _time.monotonic()
         from boneio.core.manager import Manager
         _LOGGER.debug("[RUNNER IMPORT] boneio.core.manager: %.2fs", _time.monotonic() - _t_a)
         _t_a = _time.monotonic()

{boneio-1.5.0.dev41 → boneio-1.5.2.dev1}/boneio/components/cover/time_based.py

@@ -61,6 +61,20 @@ class TimeBasedCover(BaseCover):
         else:
             return
 
+        if duration == 0:
+            # A zero open_time/close_time makes movement impossible: the guard
+            # below returns before relay.turn_on(), so the relay is never
+            # energised and the motor never gets voltage — while the cover still
+            # reports IDLE and publishes state, so the UI looks like it worked.
+            # This is always a misconfiguration, never a normal outcome.
+            _LOGGER.error(
+                "Cover %s cannot move %s: %s_time is 0. The relay will NOT be "
+                "switched. Set a non-zero time in the cover configuration.",
+                self._id,
+                direction,
+                "open" if direction == OPEN else "close",
+            )
+
         if total_steps == 0 or duration == 0:
             self._current_operation = IDLE
             with suppress(RuntimeError):

{boneio-1.5.0.dev41 → boneio-1.5.2.dev1}/boneio/components/cover/venetian.py

@@ -93,6 +93,20 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
             else:
                 total_steps = 1
 
+        if duration == 0:
+            # A zero open_time/close_time makes movement impossible: the guard
+            # below returns before relay.turn_on(), so the relay is never
+            # energised and the motor never gets voltage — while the cover still
+            # reports IDLE and publishes state, so the UI looks like it worked.
+            # This is always a misconfiguration, never a normal outcome.
+            _LOGGER.error(
+                "Cover %s cannot move %s: %s_time is 0. The relay will NOT be "
+                "switched. Set a non-zero time in the cover configuration.",
+                self._id,
+                direction,
+                "open" if direction == OPEN else "close",
+            )
+
         if total_steps == 0 or duration == 0:
             self._current_operation = IDLE
             self._loop.call_soon_threadsafe(self.send_state, self.state, self.json_position)

{boneio-1.5.0.dev41 → boneio-1.5.2.dev1}/boneio/components/irrigation/controller.py

@@ -1010,6 +1010,13 @@ class IrrigationController:
             await self.next_valve()
 
     async def handle_zone_command(self, zone_id: str, payload: str) -> None:
+        """Handle ON/OFF command for a specific zone.
+
+        ON starts the zone in single-zone mode (shutting down any running cycle first).
+        OFF only shuts down the controller if ``zone_id`` matches the currently
+        active zone — this prevents HA state-sync messages (OFF for inactive
+        zones) from killing a running cycle.
+        """
         upper = payload.strip().upper()
         _LOGGER.debug(
             "Irrigation %s handle_zone_command: zone='%s' payload='%s' → upper='%s'", self.id, zone_id, payload, upper
@@ -1017,7 +1024,28 @@ class IrrigationController:
         if upper == ON:
             await self.start_single_zone(zone_id)
         elif upper == OFF:
-            await self.shutdown()
+            # Only shutdown if this zone is the one currently running.
+            # HA sends OFF to all zone switches when one is activated,
+            # so we must NOT shutdown the controller for inactive zones.
+            if self._state == ControllerState.IDLE:
+                return
+            active_zone = (
+                self._zones[self._active_zone_idx]
+                if self._active_zone_idx is not None and self._active_zone_idx < len(self._zones)
+                else None
+            )
+            if active_zone is not None and active_zone.id == zone_id:
+                _LOGGER.info(
+                    "Irrigation %s: OFF received for active zone '%s' — shutting down",
+                    self.id, zone_id,
+                )
+                await self.shutdown()
+            else:
+                _LOGGER.debug(
+                    "Irrigation %s: ignoring OFF for zone '%s' (active zone is '%s')",
+                    self.id, zone_id,
+                    active_zone.id if active_zone else "none",
+                )
 
     async def handle_zone_duration_command(self, zone_id: str, payload: str) -> None:
         """Handle duration change from HA (value in minutes)."""

{boneio-1.5.0.dev41 → boneio-1.5.2.dev1}/boneio/core/config/yaml_util.py

@@ -720,13 +720,17 @@ class CustomValidator(Validator):
         return result
 
     def _normalize_coerce_positive_time_period(self, value) -> TimePeriod:
-        """Validate and transform time period with time unit and integer value."""
-        if isinstance(value, int):
+        """Validate and transform time period with time unit and integer value.
+
+        Bare integers (e.g. ``30``) are treated as **milliseconds** for
+        backward compatibility — the frontend and earlier configs sometimes
+        omit the unit for bounce_time / duration fields.
+        """
+        if isinstance(value, (int, float)):
             if value == 0:
                 return TimePeriod(seconds=0)
-            raise ConfigurationException(
-                f"Don't know what '{value}' means as it has no time *unit*! Did you mean '{value}s'?"
-            )
+            # Treat bare numbers as milliseconds for backward compatibility
+            return TimePeriod(milliseconds=float(value))
         if isinstance(value, TimePeriod):
             value = str(value)
         if not isinstance(value, str):
@@ -759,7 +763,14 @@ class CustomValidator(Validator):
         match = re.match(r"^([-+]?[0-9]*\.?[0-9]*)\s*(\w*)$", value)
         if match is None:
             raise ConfigurationException(f"Expected time period with unit, got {value}")
-        kwarg = unit_to_kwarg[one_of(*unit_to_kwarg)(match.group(2))]
+
+        unit_str = match.group(2)
+        # Bare number without unit (e.g. '30' from coerce: str on int 30)
+        # → treat as milliseconds for backward compatibility
+        if not unit_str:
+            return TimePeriod(milliseconds=float(match.group(1)))
+
+        kwarg = unit_to_kwarg[one_of(*unit_to_kwarg)(unit_str)]
         return TimePeriod(**{kwarg: float(match.group(1))})
 
     def _lookup_field(self, path: str) -> tuple:
@@ -928,6 +939,30 @@ def _run_config_migrations(doc: dict, config_file: str | None = None) -> tuple[d
     return doc, new_version > current_version
 
 
+def _strip_empty_strings_deep(obj: Any) -> Any:
+    """Recursively remove dictionary keys whose value is an empty string.
+
+    The frontend may occasionally persist ``''`` for optional fields
+    (e.g. ``bounce_time: ''``).  Cerberus ``positive_time_period``
+    coercion fails on bare empty strings, so we strip them before
+    normalization.  Only *empty* strings are removed – non-empty strings
+    and other falsy values (``0``, ``False``, ``None``) are preserved.
+    """
+    if isinstance(obj, dict):
+        return {
+            k: _strip_empty_strings_deep(v)
+            for k, v in obj.items()
+            if v != ""
+        }
+    if isinstance(obj, list):
+        return [
+            _strip_empty_strings_deep(item)
+            for item in obj
+            if item != ""
+        ]
+    return obj
+
+
 def load_config_from_string(config_str: str) -> dict:
     """Load config from string."""
     schema = _get_schema()  # Use cached schema instead of loading every time
@@ -940,6 +975,11 @@ def load_config_from_string(config_str: str) -> dict:
     # (coerce: positive_time_period would fail on bare int like transition: 2)
     migrated_doc, _ = _run_config_migrations(raw_doc, config_file=None)
 
+    # Strip empty string values that may have been saved by the frontend
+    # (e.g. bounce_time: '' instead of being omitted).  Cerberus coercion
+    # for positive_time_period chokes on bare empty strings.
+    migrated_doc = _strip_empty_strings_deep(migrated_doc)
+
     # Normalize the document (applies coercion rules)
     doc = v.normalized(migrated_doc, always_return_document=True)  # type: ignore[attr-defined]
 
@@ -1153,6 +1193,9 @@ def _full_config_validation(
     config_yaml, migrations_applied = _run_config_migrations(config_yaml, config_file=config_file)
     _LOGGER.debug("[STARTUP TIMING] migrations: %.2fs", _time.monotonic() - _t3)
 
+    # Strip empty string values that may have been saved by the frontend
+    config_yaml = _strip_empty_strings_deep(config_yaml)
+
     # Normalize the document (applies coercion rules)
     _progress("Normalizing config...")
     _t4 = _time.monotonic()

{boneio-1.5.0.dev41 → boneio-1.5.2.dev1}/boneio/core/manager/covers.py

@@ -235,6 +235,24 @@ class CoverManager:
         for time_key in ("open_time", "close_time", "actuator_activation_duration"):
             if time_key in config and config[time_key] is not None:
                 config[time_key] = ensure_time_period(config[time_key])
+
+        # A zero open_time/close_time leaves the cover permanently immobile: the
+        # movement thread bails out before energising the relay, and from
+        # position 0% even close() short-circuits, so no command can ever move
+        # it again. The WebUI form rejects sub-second values, but a hand-edited
+        # or imported config reaches here unchecked — say so at startup instead
+        # of letting the user discover it when the blinds fail to open.
+        for time_key in ("open_time", "close_time"):
+            value = config.get(time_key)
+            if value is not None and value.total_milliseconds == 0:
+                _LOGGER.error(
+                    "Cover %s has %s = 0. This cover will NOT move in that "
+                    "direction — its relay is never switched. Set a non-zero "
+                    "%s in the cover configuration.",
+                    cover_id,
+                    time_key,
+                    time_key,
+                )
         if tilt_duration is not None and not isinstance(tilt_duration, TimePeriod):
             tilt_duration = ensure_time_period(tilt_duration)
 

{boneio-1.5.0.dev41 → boneio-1.5.2.dev1}/boneio/core/manager/outputs.py

@@ -64,6 +64,14 @@ _LOGGER = logging.getLogger(__name__)
 # Expander class mapping
 _EXPANDER_CLASS = {MCP: MCP23017, PCA: PCA9685, PCF: PCF8575}
 
+# How often to re-check that MCP23017 expanders still hold their output
+# configuration. A brown-out or electrical noise can reset an expander back to
+# all-inputs, which silently stops the relays from following commanded state
+# without producing a single I2C error (see MCP23017.health_check).
+EXPANDER_HEALTH_CHECK_INTERVAL = TimePeriod(seconds=30)
+# Keep the first check off the startup critical path.
+EXPANDER_HEALTH_CHECK_INITIAL_DELAY = TimePeriod(seconds=30)
+
 
 # Map output_type -> HA availability message builder
 _OUTPUT_HA_FUNC = {
@@ -164,6 +172,43 @@ class OutputManager:
             )
         )
 
+        if self._mcp:
+            self._manager.append_task(
+                self._expander_health_watchdog,
+                name="mcp23017_health_watchdog",
+            )
+
+    async def _expander_health_watchdog(self) -> None:
+        """Periodically re-assert MCP23017 output configuration.
+
+        An expander that has been reset back to all-inputs keeps accepting
+        writes, so nothing in the write path reports a problem — the relays
+        simply stop switching until something reconfigures the chip. Without
+        this loop the only recovery is restarting boneIO.
+
+        The check is a handful of I2C reads per expander, run in the default
+        executor so the blocking bus access stays off the event loop.
+        """
+        loop = asyncio.get_running_loop()
+        await asyncio.sleep(EXPANDER_HEALTH_CHECK_INITIAL_DELAY.total_seconds)
+        while True:
+            for expander_id, mcp in list(self._mcp.items()):
+                try:
+                    repaired = await loop.run_in_executor(None, mcp.health_check)
+                except Exception as err:  # noqa: BLE001 - watchdog must never die
+                    _LOGGER.error(
+                        "Health check for MCP %s raised: %s", expander_id, err
+                    )
+                    continue
+                if repaired:
+                    _LOGGER.warning(
+                        "MCP %s (0x%02X) was reconfigured by the health watchdog; "
+                        "its outputs are driving again.",
+                        expander_id,
+                        mcp.address,
+                    )
+            await asyncio.sleep(EXPANDER_HEALTH_CHECK_INTERVAL.total_seconds)
+
     def _create_expander(
         self,
         expander_dict: dict,

{boneio-1.5.0.dev41 → boneio-1.5.2.dev1}/boneio/core/manager/update.py

@@ -43,12 +43,19 @@ class UpdateManager(AsyncUpdater):
         self,
         manager: Manager,
         update_interval: TimePeriod | None = None,
+        initial_delay: TimePeriod | None = None,
     ):
         """Initialize UpdateManager.
 
         Args:
             manager: Parent Manager instance
             update_interval: Time between update checks (default: 4 hours)
+            initial_delay: Delay before the first check (default: 5 minutes).
+                An update check is a GitHub round trip and is worthless to a
+                controller that is still starting up; running it immediately put
+                it squarely on the startup critical path. HA discovery for the
+                update entity is unaffected — Manager.send_ha_autodiscovery()
+                sends it as part of the normal discovery flow.
         """
         self.id = "update_manager"
         self._manager = manager
@@ -56,6 +63,8 @@ class UpdateManager(AsyncUpdater):
         # Update check interval (default: 4 hours)
         if update_interval is None:
             update_interval = TimePeriod(hours=4)
+        if initial_delay is None:
+            initial_delay = TimePeriod(minutes=5)
 
         # Cache for update info to avoid excessive GitHub API calls
         self._last_check_result: dict | None = None
@@ -64,9 +73,17 @@ class UpdateManager(AsyncUpdater):
         self._update_running: bool = False
 
         # Initialize AsyncUpdater (starts periodic task)
-        super().__init__(manager=manager, update_interval=update_interval)
+        super().__init__(
+            manager=manager,
+            update_interval=update_interval,
+            initial_delay=initial_delay,
+        )
 
-        _LOGGER.info("UpdateManager initialized (check interval: %s)", update_interval)
+        _LOGGER.info(
+            "UpdateManager initialized (check interval: %s, first check in %s)",
+            update_interval,
+            initial_delay,
+        )
 
     async def async_update(self, timestamp: float) -> float | None:
         """Perform periodic update check.
@@ -124,9 +141,9 @@ class UpdateManager(AsyncUpdater):
             }
 
         try:
-            from boneio.webui.routes.update import _fetch_github_releases
+            from boneio.webui.routes.update import _fetch_github_releases_async
 
-            releases, error = _fetch_github_releases()
+            releases, error = await _fetch_github_releases_async()
 
             if error:
                 return {"status": "error", "message": error, "current_version": current_version}

{boneio-1.5.0.dev41 → boneio-1.5.2.dev1}/boneio/core/system/monitor.py

@@ -60,7 +60,7 @@ def display_time(seconds: int | float) -> str:
 
 
 def get_network_info() -> dict[str, str]:
-    """Fetch network information for eth0 interface.
+    """Fetch network information for Ethernet interface (eth0 or end0).
     
     Returns:
         Dictionary with keys: 'ip', 'mask', 'mac'
@@ -71,7 +71,8 @@ def get_network_info() -> dict[str, str]:
         {'ip': '192.168.1.100', 'mask': '255.255.255.0', 'mac': 'aa:bb:cc:dd:ee:ff'}
     """
     try:
-        addrs = psutil.net_if_addrs().get("eth0", [])
+        net_addrs = psutil.net_if_addrs()
+        addrs = net_addrs.get("eth0") or net_addrs.get("end0") or []
         out = {IP: NONE, MASK: NONE, MAC: NONE}
         
         for addr in addrs:
@@ -80,6 +81,21 @@ def get_network_info() -> dict[str, str]:
                 out["mask"] = addr.netmask if addr.netmask is not None else ""
             elif addr.family == psutil.AF_LINK:
                 out["mac"] = addr.address
+
+        # Fallback for MAC address via /sys if AF_LINK didn't populate it
+        if out["mac"] == NONE:
+            import os
+            for iface in ("eth0", "end0"):
+                mac_file = f"/sys/class/net/{iface}/address"
+                if os.path.exists(mac_file):
+                    try:
+                        with open(mac_file, "r") as f:
+                            mac_val = f.read().strip()
+                            if mac_val:
+                                out["mac"] = mac_val
+                                break
+                    except Exception:
+                        pass
         
         return out
     except (KeyError, AttributeError):

{boneio-1.5.0.dev41 → boneio-1.5.2.dev1}/boneio/core/utils/async_updater.py

@@ -28,12 +28,23 @@ class AsyncUpdater:
     Implementation is validated at initialization time.
     """
 
-    def __init__(self, manager: Manager, update_interval: TimePeriod, **kwargs):
+    def __init__(
+        self,
+        manager: Manager,
+        update_interval: TimePeriod,
+        initial_delay: TimePeriod | None = None,
+        **kwargs,
+    ):
         """Initialize async updater.
 
         Args:
             manager: Manager instance to register the update task
             update_interval: Time period between updates
+            initial_delay: Optional delay before the *first* update. Without it
+                the refresh loop fires immediately, which puts the component on
+                the application's startup critical path. Use this for anything
+                that is not needed for the controller to serve I/O — network
+                calls in particular.
             **kwargs: Additional arguments (passed to parent classes)
 
         Raises:
@@ -64,6 +75,7 @@ class AsyncUpdater:
 
         self.manager = manager
         self._update_interval = update_interval or TimePeriod(seconds=60)
+        self._initial_delay = initial_delay
         self._wakeup_event = asyncio.Event()  # Event to wake up from sleep early
         self._requested_update_interval: float | None = None  # Custom interval for next update
         self.manager.append_task(coro=self._refresh, name=self.id)  # type: ignore[attr-defined]
@@ -111,7 +123,23 @@ class AsyncUpdater:
             # Determine which update method to use (check once, not every loop)
             use_async = self.__class__.async_update is not AsyncUpdater.async_update
 
-            # Perform first update immediately on startup
+            # Optional delay before the first update. Components that only
+            # report status (rather than drive hardware) use this so they do not
+            # compete with startup. Interruptible via request_update(), so an
+            # explicit refresh from the WebUI is still immediate.
+            if self._initial_delay is not None:
+                delay = self._initial_delay.total_in_seconds
+                if delay > 0:
+                    _LOGGER.debug(
+                        "%s: deferring first update by %ss",
+                        getattr(self, "id", "unknown"),
+                        delay,
+                    )
+                    try:
+                        await asyncio.wait_for(self._wakeup_event.wait(), timeout=delay)
+                        self._wakeup_event.clear()
+                    except TimeoutError:
+                        pass
 
             while True:
                 timestamp = time.time()

boneio-1.5.2.dev1/boneio/core/utils/overlay.py

@@ -0,0 +1,159 @@
+"""Device tree overlay locations and applied-state detection.
+
+Single source of truth for *where* boneIO overlay ``.dtbo`` files must live and
+*whether* an overlay actually took effect. This knowledge used to be duplicated
+in ``boneio.migrations.runner`` and ``boneio.webui.routes.system``, and both
+copies carried the same defect: they only ever looked at
+``/boot/dtbs/$uname_r/overlays/``.
+
+Two directories matter, for different consumers:
+
+``/boot/dtbs/$uname_r/``
+    U-Boot resolves bare filenames from ``uEnv.txt`` here, e.g.
+    ``uboot_overlay_addr0=BONEIO-BLACK-PINS-v1.0.dtbo``. **This is the only
+    path that decides whether the overlay is actually applied at boot.**
+
+``/boot/dtbs/$uname_r/overlays/``
+    Used by kernel/userspace overlay tooling.
+
+Stock BeagleBoard overlays (``BB-ADC-00A0.dtbo`` and friends) ship in both.
+Installing only into ``overlays/`` makes U-Boot log
+
+    uboot_overlays: unable to find [mmc 0:3 BONEIO-BLACK-PINS-v1.0.dtbo]
+
+and continue with the stock BeagleBone pinmux. Nothing in userspace reports an
+error, so file-presence checks against ``overlays/`` report success while the
+board silently runs unconfigured pins.
+
+The authoritative answer to "is an overlay applied" is therefore not the
+filesystem at all but ``/proc/device-tree/chosen/overlays/``, which the kernel
+populates from what U-Boot actually merged into the device tree.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import platform
+from pathlib import Path
+
+_LOGGER = logging.getLogger(__name__)
+
+OVERLAY_GLOB = "BONEIO-BLACK-PINS*.dtbo"
+"""Glob matching every boneIO pin overlay binary."""
+
+DT_CHOSEN_OVERLAYS = Path("/proc/device-tree/chosen/overlays")
+"""Kernel-reported list of overlays merged into the live device tree."""
+
+DTBS_ROOT = Path("/boot/dtbs")
+"""Root of the per-kernel device tree blob directories."""
+
+
+def kernel_release() -> str:
+    """Return the running kernel release, or an empty string if unavailable."""
+    try:
+        return platform.uname().release
+    except Exception:  # pragma: no cover - platform call is effectively safe
+        return ""
+
+
+def overlay_dirs_for_kernel(kernel_version: str) -> tuple[Path, Path]:
+    """Return both overlay destinations for a kernel version.
+
+    Args:
+        kernel_version: Kernel release string, e.g. ``6.18.45-bone48``.
+
+    Returns:
+        Tuple of ``(uboot_dir, tooling_dir)``. ``uboot_dir`` is the directory
+        U-Boot reads; ``tooling_dir`` is its ``overlays/`` subdirectory.
+    """
+    base = DTBS_ROOT / kernel_version
+    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.
+
+    Args:
+        kernel_version: Kernel release string.
+
+    Returns:
+        List of directories (possibly empty) that need to be populated. An
+        empty list means both destinations already hold overlays.
+    """
+    uboot_dir, tooling_dir = overlay_dirs_for_kernel(kernel_version)
+    # No DTB directory for this kernel means the kernel package is not
+    # installed here; there is nothing for us to repair.
+    if not uboot_dir.is_dir():
+        return []
+
+    missing: list[Path] = []
+    for directory in (uboot_dir, tooling_dir):
+        # glob() on a non-existent directory yields nothing rather than raising,
+        # which is the behaviour we want for a not-yet-created overlays/ dir.
+        if not any(directory.glob(OVERLAY_GLOB)):
+            missing.append(directory)
+    return missing
+
+
+def applied_overlay_names() -> list[str]:
+    """Return the overlay names the kernel reports as merged into the DT.
+
+    Reads ``/proc/device-tree/chosen/overlays/``. Entries are named after the
+    overlay that produced them, e.g. ``BB-ADC-00A0.kernel``.
+
+    Returns:
+        List of entry names, or an empty list if the node is absent (which
+        happens when U-Boot merged no overlays at all).
+    """
+    if not DT_CHOSEN_OVERLAYS.is_dir():
+        return []
+    try:
+        # 'name' is a property of the node itself, not an applied overlay.
+        return sorted(e for e in os.listdir(DT_CHOSEN_OVERLAYS) if e != "name")
+    except OSError as exc:
+        _LOGGER.debug("Cannot read %s: %s", DT_CHOSEN_OVERLAYS, exc)
+        return []
+
+
+def is_boneio_overlay_applied() -> bool:
+    """Return whether a boneIO pin overlay is live in the device tree.
+
+    This is the authoritative check. File presence under ``/boot/dtbs`` proves
+    nothing about what U-Boot actually loaded.
+    """
+    return any(name.startswith("BONEIO-BLACK-PINS") for name in applied_overlay_names())

{boneio-1.5.0.dev41 → boneio-1.5.2.dev1}/boneio/hardware/display/oled.py

@@ -7,7 +7,6 @@ import subprocess
 from itertools import cycle
 from typing import TYPE_CHECKING
 
-import qrcode
 from luma.core.error import DeviceNotFoundError
 from luma.core.interface.serial import i2c
 from luma.core.render import canvas
@@ -212,6 +211,12 @@ class Oled:
         if not url:
             return
 
+        # Imported here rather than at module level: qrcode costs 0.38 s to
+        # import on an AM335x and is only needed for this one screen, which the
+        # user has to navigate to. At module level it was paid on every startup,
+        # pulled in via early_oled -> display -> oled.
+        import qrcode
+
         # Create QR code with box_size 2 and scale down later
         qr = qrcode.QRCode(version=1, box_size=2, border=1)
         qr.add_data(url)