boneio 1.6.0.dev32__tar.gz → 1.6.0.dev34__tar.gz

{boneio-1.6.0.dev32/boneio.egg-info → boneio-1.6.0.dev34}/PKG-INFO

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

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/components/output/remote.py

@@ -300,6 +300,7 @@ class RemoteOutputBase:
 
         success = await self._device_manager.control_output(
             output_id=self._output_id,
+            message_bus=self._message_bus,
             action="ON",
         )
         if success:
@@ -326,6 +327,7 @@ class RemoteOutputBase:
 
         success = await self._device_manager.control_output(
             output_id=self._output_id,
+            message_bus=self._message_bus,
             action="OFF",
         )
         if success:
@@ -417,6 +419,7 @@ class RemoteOutputBase:
 
         success = await self._device_manager.control_output(
             output_id=self._output_id,
+            message_bus=self._message_bus,
             action="ON",
             brightness=brightness,
         )
@@ -484,6 +487,7 @@ class RemoteOutputBase:
         )
         success = await self._device_manager.control_output(
             output_id=self._output_id,
+            message_bus=self._message_bus,
             action="OFF",
         )
         if not success:
@@ -646,6 +650,7 @@ class RemoteOutputBase:
             return
         success = await self._device_manager.control_output(
             output_id=self._output_id,
+            message_bus=self._message_bus,
             action="OFF",
         )
         if success:

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/components/sensor/virtual_energy.py

@@ -25,6 +25,10 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+# How long to wait, once the broker has the subscription, for a stored total.
+# None arriving means the counter has never been published.
+RESTORE_GRACE_SECONDS = 15.0
+
 
 class VirtualEnergySensor:
     """Virtual energy/water sensor linked to an output.
@@ -72,6 +76,7 @@ class VirtualEnergySensor:
         self._area = area
 
         self._virtual_sensors_task = None
+        self._restore_task: asyncio.Task | None = None
 
         # Counters
         self._energy_consumed_Wh = 0.0
@@ -145,7 +150,8 @@ class VirtualEnergySensor:
 
     def start_tracking(self):
         """Start tracking consumption (called when output turns ON)."""
-        self._last_on_timestamp = time.time()
+        if self._last_on_timestamp is None:  # ON while already on keeps the stretch
+            self._last_on_timestamp = time.time()
         if self._virtual_sensors_task is not None and not self._virtual_sensors_task.done():
             return  # Already running
         self._virtual_sensors_task = self._loop.create_task(self._tracking_loop())
@@ -169,20 +175,9 @@ class VirtualEnergySensor:
     async def _tracking_loop(self):
         """Periodically update and send state every 30 seconds while output is ON."""
         try:
-            # Wait for state restore before sending any state.
-            # This prevents overwriting the retained MQTT value with 0.
-            # Timeout of 5s ensures we don't hang if MQTT is down.
-            try:
-                await asyncio.wait_for(self._restore_done.wait(), timeout=5.0)
-            except TimeoutError:
-                _LOGGER.warning(
-                    "State restore timeout for %s, starting with energy=%.4f Wh", self._id, self._energy_consumed_Wh
-                )
-                self._restore_done.set()
-
-            # Reset on_timestamp after restore so we don't count
-            # the time elapsed during the restore wait.
-            self._last_on_timestamp = time.time()
+            # Publishing before the stored total is known would replace it
+            # with what was counted since boot.
+            await self._restore_done.wait()
 
             while self._output.state == ON:
                 self._update_consumption()
@@ -194,7 +189,9 @@ class VirtualEnergySensor:
     def _update_consumption(self):
         """Update consumption counters based on elapsed time."""
         now = time.time()
-        if self._output.state == ON and self._last_on_timestamp is not None:
+        # Not the output's state: by the time OFF is handled it is already
+        # off, and the stretch since the last update would be lost.
+        if self._last_on_timestamp is not None:
             elapsed = now - self._last_on_timestamp
 
             if self._sensor_type == "power" and self._power_usage is not None:
@@ -215,14 +212,17 @@ class VirtualEnergySensor:
         """
 
         async def on_message(_topic, payload):
+            if self._restore_done.is_set():
+                return  # Late, after giving up: the counter is already published.
             try:
                 data = json.loads(payload)
                 if isinstance(data, dict):
+                    # Added, not assigned: the output may have been on since boot.
                     if "energy" in data:
-                        self._energy_consumed_Wh = float(data["energy"])
+                        self._energy_consumed_Wh += float(data["energy"])
                         _LOGGER.info("Restored energy state for %s: %.4f Wh", self._id, self._energy_consumed_Wh)
                     if "water" in data:
-                        self._water_consumed_L = float(data["water"])
+                        self._water_consumed_L += float(data["water"])
                         _LOGGER.info("Restored water state for %s: %.4f L", self._id, self._water_consumed_L)
             except Exception as e:
                 _LOGGER.warning("Failed to restore state for %s: %s", self._id, e)
@@ -230,8 +230,20 @@ class VirtualEnergySensor:
                 self._restore_done.set()
                 await self._message_bus.unsubscribe_and_stop_listen(self._sensor_topic)
 
+        async def restore():
+            await self._message_bus.subscribe_and_listen(self._sensor_topic, on_message)
+            # The grace starts once the broker has the subscription, not at
+            # boot: connecting can take longer than any fixed timeout.
+            await self._message_bus.wait_until_subscribed()
+            try:
+                await asyncio.wait_for(self._restore_done.wait(), timeout=RESTORE_GRACE_SECONDS)
+            except TimeoutError:
+                _LOGGER.info("No stored state for %s, counting from boot", self._id)
+                self._restore_done.set()
+                await self._message_bus.unsubscribe_and_stop_listen(self._sensor_topic)
+
         if self._message_bus is not None:
-            asyncio.create_task(self._message_bus.subscribe_and_listen(self._sensor_topic, on_message))
+            self._restore_task = asyncio.create_task(restore())
 
     def get_current_power(self) -> float:
         """Get current power usage in W (0 if output is OFF)."""

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/core/config/config_helper.py

@@ -3,6 +3,7 @@ Module to provide basic config options.
 """
 from __future__ import annotations
 
+import copy
 import logging
 from typing import TYPE_CHECKING, Any
 import time as _time
@@ -24,16 +25,27 @@ from boneio.const import (
     LIGHT,
     NONE,
     NUMERIC,
+    OUTPUT,
     SELECT,
     SENSOR,
     SWITCH,
     TEXT_SENSOR,
     VALVE,
 )
+from boneio.core.config.yaml_util import (
+    load_config_from_file,
+    load_yaml_file,
+    merge_board_config,
+    strip_default_values,
+)
 from boneio.core.system import get_serial_from_mac
+from boneio.exceptions import ConfigurationException
 
 _LOGGER = logging.getLogger(__name__)
 
+# Sections merge_board_config fills in from the board (pins, expanders).
+_BOARD_SECTIONS = (EVENT_ENTITY, BINARY_SENSOR, OUTPUT)
+
 
 class ConfigHelper:
     def __init__(
@@ -494,7 +506,6 @@ class ConfigHelper:
             raise ValueError("config_file_path not set in ConfigHelper")
         
         if self._config_cache is None or force_reload:
-            from boneio.core.config.yaml_util import load_config_from_file
             _LOGGER.debug("Loading config from file: %s", self._config_file_path)
             config = load_config_from_file(self._config_file_path)
             if config is None:
@@ -532,8 +543,6 @@ class ConfigHelper:
         _t0 = _time.monotonic()
         _LOGGER.info("Fast-reloading config from: %s", self._config_file_path)
 
-        from boneio.core.config.yaml_util import load_yaml_file, merge_board_config
-
         config_yaml = load_yaml_file(self._config_file_path)
         if config_yaml is None:
             raise ValueError(f"Failed to load config from: {self._config_file_path}")
@@ -563,9 +572,34 @@ class ConfigHelper:
                 section,
             )
             return
-        self._config_cache[section] = data
+        self._config_cache[section] = self._section_as_reloaded(section, data)
         _LOGGER.debug("Updated config section '%s' in-place", section)
 
+    def _section_as_reloaded(self, section: str, data: object) -> object:
+        """What a reload from the file would hold for a section just saved.
+
+        The file gets the section with empty fields and default action values
+        dropped, and a reload merges the board's pins and expanders back into
+        inputs and outputs. Patching the cache with the data as sent left
+        inputs without a pin until the next reload.
+
+        Args:
+            section: Top-level config key.
+            data: The section as it was saved.
+
+        Returns:
+            The section the way the reload path would see it.
+        """
+        cleaned = strip_default_values(copy.deepcopy(data), {}, section)
+        boneio = self._config_cache.get(BONEIO) if self._config_cache else None
+        if section not in _BOARD_SECTIONS or not isinstance(boneio, dict):
+            return cleaned
+        try:
+            return merge_board_config({BONEIO: dict(boneio), section: cleaned})[section]
+        except ConfigurationException as err:
+            _LOGGER.warning("Section '%s' kept unmerged in the config cache: %s", section, err)
+            return cleaned
+
     def get_section(self, section_name: str, force_reload: bool = False) -> Any:
         """Get a specific configuration section.
         

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/core/config/provenance.py

@@ -75,9 +75,12 @@ def looks_factory_fresh(
         return True
 
     root = Path(template_dir) if template_dir is not None else FACTORY_TEMPLATE_DIR
-    try:
-        variants = sorted(p for p in root.iterdir() if p.is_dir())
-    except OSError:
+    # <variant>/ on older images, <revision>/<variant>/ since one image serves
+    # every board.
+    variants = sorted(
+        p.parent for p in [*root.glob("*/config.yaml"), *root.glob("*/*/config.yaml")]
+    )
+    if not variants:
         # No templates to compare against: the honest answer is "cannot tell",
         # and the safe reading of that is "assume it has been configured".
         _LOGGER.debug("No factory templates under %s — assuming configured", root)
@@ -85,7 +88,7 @@ def looks_factory_fresh(
 
     for variant in variants:
         if current == _digest(variant / "config.yaml"):
-            _LOGGER.debug("Configuration matches the %s template", variant.name)
+            _LOGGER.debug("Configuration matches the %s template", variant.relative_to(root))
             return True
 
     return False

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/core/config/yaml_util.py

@@ -158,55 +158,6 @@ _CACHE_FOREIGN_BUILD_ERRORS = (
 # ── YAML write serialization & background save tracking ──────────────────
 # Shared with yaml_patch: both rewrite the same files.
 _yaml_write_lock = CONFIG_WRITE_LOCK
-_yaml_pending_saves = 0
-_yaml_pending_lock = threading.Lock()
-
-
-def yaml_saves_pending() -> bool:
-    """Return True if background YAML saves are still in progress."""
-    return _yaml_pending_saves > 0
-
-
-def get_pending_yaml_saves_count() -> int:
-    """Return count of pending background YAML saves."""
-    return _yaml_pending_saves
-
-
-def wait_for_pending_yaml_saves(timeout: float = 30.0) -> bool:
-    """Block until all pending YAML saves complete (or timeout).
-
-    Args:
-        timeout: Maximum seconds to wait.
-
-    Returns:
-        True if all saves completed, False if timed out.
-    """
-    deadline = time.monotonic() + timeout
-    while yaml_saves_pending():
-        if time.monotonic() > deadline:
-            _LOGGER.warning(
-                "Timed out waiting for %d pending YAML save(s)",
-                _yaml_pending_saves,
-            )
-            return False
-        time.sleep(0.1)
-    return True
-
-
-def increment_pending_yaml_saves() -> None:
-    """Increment pending YAML save counter."""
-    global _yaml_pending_saves
-    with _yaml_pending_lock:
-        _yaml_pending_saves += 1
-
-
-def decrement_pending_yaml_saves() -> None:
-    """Decrement pending YAML save counter."""
-    global _yaml_pending_saves
-    with _yaml_pending_lock:
-        _yaml_pending_saves = max(0, _yaml_pending_saves - 1)
-
-
 # Cache for schema to avoid loading it multiple times (saves ~2-3s per config load)
 _SCHEMA_CACHE = None
 # Cache for board configs to avoid loading them multiple times
@@ -2359,6 +2310,42 @@ def update_config_section(config_file: str, section: str, data: dict | list) ->
             return {"status": "error", "message": f"Error saving section: {str(e)}"}
 
 
+def edit_config_section(
+    config_file: str, mutate: Callable[[dict], tuple[str | None, Any]]
+) -> tuple[str | None, Any, Any]:
+    """Change one section starting from what the user's file holds.
+
+    Edits begin from the file, not from the running config: that one has the
+    board's pins and the schema's defaults filled in, and writing it back put
+    them into the user's file. The read, the change and the write happen under
+    the write lock, so a save in between cannot be lost.
+
+    Args:
+        config_file: Path to the main config.yaml file.
+        mutate: Gets the whole config as the files hold it (includes followed,
+            secrets resolved), changes one section in place and returns that
+            section's name and whatever its caller wants back. A name of None
+            means there was nothing to change and nothing is written. Anything
+            it raises aborts the edit before anything is written.
+
+    Returns:
+        The section's name, the section as written, and what ``mutate``
+        returned; None and None in front of that when nothing was written.
+
+    Raises:
+        ConfigurationException: When the section could not be written.
+    """
+    with _yaml_write_lock:
+        config = load_yaml_file(config_file) or {}
+        section, result = mutate(config)
+        if section is None:
+            return None, None, result
+        status = update_config_section(config_file, section, config[section])
+        if status["status"] == "error":
+            raise ConfigurationException(status["message"])
+        return section, strip_default_values(config[section], {}, section), result
+
+
 def update_yaml_field(config_file: str, section: str, field: str, value: str) -> dict:
     """Update a single field within a YAML section without overwriting other fields.
 

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/core/containers.py

@@ -349,8 +349,8 @@ def restart_nodered(timeout: int = 120) -> Result:
     return run("restart-nodered", timeout=timeout)
 
 
-def pull_nodered(timeout: int = 600) -> Result:
-    """Pull the Node-RED image."""
+def pull_nodered(timeout: int = 960) -> Result:
+    """Pull the Node-RED image; outlasts the helper's own 900 s limit."""
     return run("pull-nodered", timeout=timeout)
 
 

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/core/events/bus.py

@@ -372,8 +372,14 @@ class EventBus:
         return listener_job
 
     def remove_event_listener(self, event_type: str | None = None, entity_id: str | None = None, listener_id: str | None = None) -> None:
-        """Remove event listener. Can remove by event_type, listener_id, or both."""
-        if listener_id and listener_id in self._listener_id_index:
+        """Remove event listener. Can remove by event_type, listener_id, or both.
+
+        A ``listener_id`` the bus does not know removes nothing; it never
+        widens to every listener of ``event_type``.
+        """
+        if listener_id:
+            if listener_id not in self._listener_id_index:
+                return
             # Remove by listener_id
             for evt_type, ent_id in self._listener_id_index[listener_id]:
                 if event_type and evt_type != event_type:

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/core/manager/inputs.py

@@ -577,8 +577,15 @@ class InputManager:
                     continue
                 new_input_map[input_id] = {"pin": pin, "area": gpio.get("area"), "ha_type": ha_type}
 
-        # Find inputs to remove (in current config but not in new config)
-        current_input_ids = set(self._inputs.keys())
+        # Find inputs to remove (in current config but not in new config).
+        # Only the inputs these two sections own: remote inputs and the OLED
+        # button share the map but come from elsewhere, and dropping them here
+        # took their HA entities away on the first reload after start.
+        current_input_ids = {
+            input_id
+            for input_id, device in self._inputs.items()
+            if input_id != "oled_button" and not isinstance(device, RemoteInputBase)
+        }
         new_input_ids = set(new_input_map.keys())
 
         inputs_to_remove = current_input_ids - new_input_ids
@@ -619,7 +626,8 @@ class InputManager:
                 _LOGGER.info("Removed input %s (type_changed=%s)", input_id, input_id in inputs_type_changed)
 
         # Check for area changes on remaining inputs
-        for input_id, input_device in self._inputs.items():
+        for input_id in current_input_ids - inputs_to_remove - inputs_type_changed:
+            input_device = self._inputs[input_id]
             old_area = getattr(input_device, "area", None)
             new_area = new_input_map.get(input_id, {}).get("area")
 

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/core/manager/manager.py

@@ -172,6 +172,9 @@ class Manager:
         self._config_helper = config_helper
         self._config_file_path = config_file_path
         self._topic_prefix = config_helper.topic_prefix
+        # One reload at a time: they re-read the file and rebuild entity maps
+        # across awaits, so two interleaved runs corrupt each other's state.
+        self._reload_lock = asyncio.Lock()
 
         # Where the Sun is. Built even when `location:` is absent: an
         # unconfigured provider answers "not ready" and says so once, which is
@@ -827,7 +830,7 @@ class Manager:
 
                 elif action == OUTPUT_OVER_MQTT:
                     boneio_id = action_definition.get("boneio_id")
-                    action_output = action_definition.get("action_output")
+                    action_output = action_definition.get("action_output", TOGGLE)
                     action_to_execute = output_actions.get(action_output.upper())
                     if boneio_id and action_to_execute:
                         parsed_action = {
@@ -842,7 +845,7 @@ class Manager:
 
                 elif action == COVER_OVER_MQTT:
                     boneio_id = action_definition.get("boneio_id")
-                    action_cover = action_definition.get("action_cover")
+                    action_cover = action_definition.get("action_cover", TOGGLE)
                     action_to_execute = cover_actions.get(action_cover.upper())
                     if boneio_id and action_to_execute:
                         parsed_action = {
@@ -1491,11 +1494,12 @@ class Manager:
 
         _LOGGER.info("Reloading remote devices configuration")
         # Clean up old remote inputs and outputs before reload
+        await self.inputs._remote_registrar.stop()
         self.inputs.unregister_remote_inputs()
         self.unregister_remote_outputs()
         await self.remote_devices.reload(remote_devices_config)
         # Re-register remote inputs and outputs from config
-        self.register_remote_inputs()
+        await self.register_remote_inputs()
         self.register_remote_outputs()
         # Broadcast all input states so frontend picks up new/removed remote inputs
         self.inputs._broadcast_all_input_states()
@@ -1512,13 +1516,12 @@ class Manager:
         # previous callbacks would run the old actions alongside the new ones.
         await self.inputs._remote_registrar.stop()
         self.inputs.unregister_remote_inputs()
-        self.register_remote_inputs()
-        await self.inputs._remote_registrar.start()
+        await self.register_remote_inputs()
         # Broadcast all input states so frontend picks up new/removed remote inputs
         self.inputs._broadcast_all_input_states()
         _LOGGER.info("Remote inputs configuration reloaded successfully")
 
-    def register_remote_inputs(self) -> None:
+    async def register_remote_inputs(self) -> None:
         """Register remote inputs from the ``remote_inputs`` config section.
 
         Delegates to :meth:`InputManager.register_remote_inputs`.
@@ -1527,6 +1530,11 @@ class Manager:
         config = self._config_helper.get_config()
         remote_inputs_config = config.get("remote_inputs", [])
         self.inputs.register_remote_inputs(self.remote_devices, remote_inputs_config)
+        # Subscribe here rather than wait for the next MQTT connect: at startup
+        # the broker is usually connected long before remote inputs register,
+        # and the inputs would stay deaf until the connection dropped. Before
+        # the connect the bus only records the listener and subscribes it then.
+        await self.inputs._remote_registrar.start()
 
     # Keep backward-compatible alias
     register_esphome_binary_sensors = register_remote_inputs
@@ -1842,6 +1850,16 @@ class Manager:
                 - reloaded_sections: List of successfully reloaded sections
                 - failed_sections: List of sections that failed to reload
         """
+        async with self._reload_lock:
+            return await self._reload_config_locked(reload_sections)
+
+    async def reload_inputs_serialized(self) -> None:
+        """Reload inputs without racing a config reload already running."""
+        async with self._reload_lock:
+            await self.inputs.reload_inputs()
+
+    async def _reload_config_locked(self, reload_sections: list[str] | None) -> dict:
+        """Body of :meth:`reload_config`; the caller holds ``_reload_lock``."""
         from boneio.const import BINARY_SENSOR, EVENT_ENTITY
 
         _LOGGER.info("Starting config reload")
@@ -2221,7 +2239,7 @@ class Manager:
         if msg_type == BUTTON and command == "set":
             if device_id == "inputs_reload" and message == "inputs_reload":
                 _LOGGER.info("Reloading events and binary sensors actions")
-                asyncio.create_task(self.inputs.reload_inputs())
+                asyncio.create_task(self.reload_inputs_serialized())
             elif device_id == "cover_reload" and message == "cover_reload":
                 _LOGGER.info("Reloading covers actions")
                 self.covers.reload_covers()

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/core/manager/templates/alarm.py

@@ -20,6 +20,27 @@ if TYPE_CHECKING:
 _LOGGER = logging.getLogger(__name__)
 
 
+def _hash_plain_codes(template_list: list) -> bool:
+    """Hash the plain-text PIN codes of alarm panels in a template list.
+
+    Args:
+        template_list: ``template`` section entries, changed in place.
+
+    Returns:
+        True if any code was hashed.
+    """
+    changed = False
+    for entry in template_list:
+        if not isinstance(entry, dict) or entry.get("platform") != "alarm_control_panel":
+            continue
+        for code_cfg in entry.get("codes", []):
+            raw = str(code_cfg.get("code", ""))
+            if raw and not AlarmPinCode._is_sha256(raw):
+                code_cfg["code"] = AlarmPinCode.hash_code(raw)
+                changed = True
+    return changed
+
+
 class AlarmManager:
     """Manages alarm panel template entities.
 
@@ -276,26 +297,24 @@ class AlarmManager:
         """
         try:
             config_helper = self._manager._config_helper
-            config = config_helper.get_config()
-            template_list: list[dict] = config.get("template", [])
-            changed = False
-
-            for entry in template_list:
-                if entry.get("platform") != "alarm_control_panel":
-                    continue
-                for code_cfg in entry.get("codes", []):
-                    raw = str(code_cfg.get("code", ""))
-                    if raw and not AlarmPinCode._is_sha256(raw):
-                        code_cfg["code"] = AlarmPinCode.hash_code(raw)
-                        changed = True
-
-            if changed:
-                from boneio.core.config.yaml_util import update_config_section
-                config_file = config_helper._config_file_path
-                if config_file is None:
-                    _LOGGER.warning("Cannot migrate PIN codes: config_file_path not set")
-                    return
-                update_config_section(config_file, "template", template_list)
+            # The running config, so what is in memory matches the file.
+            if not _hash_plain_codes(config_helper.get_config().get("template", [])):
+                return
+
+            from boneio.core.config.yaml_util import edit_config_section
+            config_file = config_helper._config_file_path
+            if config_file is None:
+                _LOGGER.warning("Cannot migrate PIN codes: config_file_path not set")
+                return
+
+            # The file from its own section: the running one has the schema's
+            # defaults filled in, and writing it back put them into the file.
+            def hash_in_file(file_config: dict) -> tuple[str | None, None]:
+                changed = _hash_plain_codes(file_config.get("template") or [])
+                return ("template" if changed else None), None
+
+            written, _, _ = edit_config_section(config_file, hash_in_file)
+            if written:
                 _LOGGER.info(
                     "Migrated plain-text alarm PIN codes to SHA-256 hashes in YAML"
                 )

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/core/messaging/basic.py

@@ -78,3 +78,9 @@ class MessageBus(ABC):
         """Unsubscribe from a topic and stop listening."""
         pass
 
+    async def wait_until_subscribed(self) -> None:
+        """Return once the broker holds this bus's subscriptions.
+
+        Until then a retained message cannot have arrived yet, so its absence
+        means nothing. Buses without a broker return at once.
+        """

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/core/messaging/composite.py

@@ -97,3 +97,7 @@ class CompositeMessageBus(MessageBus):
         """Unsubscribe from a topic and stop listening on all buses."""
         for bus in self._buses:
             await bus.unsubscribe_and_stop_listen(topic)
+
+    async def wait_until_subscribed(self) -> None:
+        """Wait for every bus: one being up says nothing about another."""
+        await asyncio.gather(*(bus.wait_until_subscribed() for bus in self._buses))

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/core/messaging/mqtt.py

@@ -76,6 +76,7 @@ class MQTTClient(MessageBus):
         self.asyncio_client = self.create_client()
         self.reconnect_interval = 1
         self._connection_established = False
+        self._subscribed = asyncio.Event()
         self.publish_queue: UniqueQueue = UniqueQueue()
         self._mqtt_energy_listeners: dict[str, Callable[..., Awaitable[None]]] = {}
         # Listeners that are told whether a message is a retained replay.
@@ -227,6 +228,10 @@ class MQTTClient(MessageBus):
         if self._connection_established:
             await self.subscribe(topics=[topic])
 
+    @override
+    async def wait_until_subscribed(self) -> None:
+        await self._subscribed.wait()
+
     @override
     async def unsubscribe_and_stop_listen(self, topic: str) -> None:
         await self.unsubscribe([topic])
@@ -476,6 +481,7 @@ class MQTTClient(MessageBus):
 
                 topics = self._topics + list(self._mqtt_energy_listeners.keys()) + self._discovery_topics
                 await self.subscribe(topics=topics)
+                self._subscribed.set()
                 # Connected: the next outage starts the backoff from scratch
                 # instead of waiting as long as the worst one before it.
                 self.reconnect_interval = 1

{boneio-1.6.0.dev32 → boneio-1.6.0.dev34}/boneio/core/system_ops.py

@@ -379,3 +379,13 @@ def os_update_log(timeout: int = 30) -> Result:
 def os_autoupdate_set(enabled: bool, timeout: int = 60) -> Result:
     """Switch automatic security updates on or off. Never reboots either way."""
     return run("os-autoupdate-set", "on" if enabled else "off", timeout=timeout)
+
+
+def disk_usage(timeout: int = 120) -> Result:
+    """Docker images, the journal and the apt cache, in bytes, as JSON."""
+    return run("disk-usage", timeout=timeout)
+
+
+def disk_clean(target: str, timeout: int = 360) -> Result:
+    """Free space in ``docker`` (unused images) or ``apt`` (the package cache)."""
+    return run("disk-clean", target, timeout=timeout)