boneio 1.6.0.dev13__tar.gz → 1.6.0.dev15__tar.gz

{boneio-1.6.0.dev13 → boneio-1.6.0.dev15}/MANIFEST.in

@@ -5,6 +5,7 @@ recursive-include boneio *.yaml
 recursive-include boneio *.json
 recursive-include boneio *.ttf
 recursive-include boneio/webui/frontend-dist *
+recursive-include boneio/webui/recovery/static *
 # Signing key and migration plan signatures — the helper refuses to run
 # without them, so a wheel built without these is useless on a device.
 recursive-include boneio *.pem

{boneio-1.6.0.dev13/boneio.egg-info → boneio-1.6.0.dev15}/PKG-INFO

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

{boneio-1.6.0.dev13 → boneio-1.6.0.dev15}/boneio/bonecli.py

@@ -213,10 +213,11 @@ def run(
     """Run BoneIO."""
     import time as _time
 
-    from yaml import MarkedYAMLError
+    from yaml import YAMLError
 
     from boneio.core.config import load_config_from_file
     from boneio.core.events import GracefulExit
+    from boneio.core.recovery import RecoveryReason, StartupFailures, describe_config_error
     from boneio.core.utils.logger import configure_logger, setup_logging
     from boneio.exceptions import ConfigurationException
     _t0 = _time.monotonic()
@@ -246,6 +247,22 @@ def run(
         def draw_config_error(msg: str) -> None: pass  # noqa: E731
         def draw_crash(exc: BaseException) -> None: pass  # noqa: E731
 
+    def _recover(reason: RecoveryReason) -> int:
+        # Imported only here: the panel's web stack costs seconds to import,
+        # and a controller that starts normally never needs it.
+        from boneio.webui.recovery import run_recovery
+
+        return run_recovery(config, reason)
+
+    failures = StartupFailures(config)
+    if failures.in_crash_loop():
+        _LOGGER.error(
+            "boneIO crashed during startup %d times in a row. Starting the "
+            "recovery panel instead, so the error can be seen and fixed.",
+            failures.count,
+        )
+        return _recover(failures.last_reason())
+
     try:
         _t1 = _time.monotonic()
         _config = load_config_from_file(
@@ -253,9 +270,11 @@ def run(
         )
         _LOGGER.debug("[STARTUP TIMING] load_config_from_file: %.2fs", _time.monotonic() - _t1)
         if not _config:
-            _LOGGER.error("Config not loaded. Exiting.")
+            _LOGGER.error("Config not loaded.")
             draw_config_error("Config file is empty or missing")
-            return 1
+            return _recover(
+                RecoveryReason(kind="config", message="Config file is empty or missing", file=config)
+            )
         configure_logger(log_config=_config.get("logger") or {}, debug=debug)
         draw_status("Importing modules...")
         # Granular timing of runner sub-imports to find the bottleneck
@@ -294,13 +313,14 @@ def run(
     except GracefulExit as err:
         _LOGGER.info("Message: %s", err)
         return 0
-    except (ConfigurationException, MarkedYAMLError) as err:
-        _LOGGER.error("Failed to load config. %s Exiting.", err)
+    except (ConfigurationException, YAMLError) as err:
+        _LOGGER.error("Failed to load config. %s", err)
         draw_config_error(str(err)[:100])
-        return 1
+        return _recover(describe_config_error(err, config))
     except Exception as err:
         _LOGGER.error("Unexpected error during startup: %s", err, exc_info=True)
         draw_crash(err)
+        failures.record(err)
         return 1
 
 

{boneio-1.6.0.dev13 → boneio-1.6.0.dev15}/boneio/components/input/binary_sensor.py

@@ -53,7 +53,6 @@ class GpioInputBinarySensor(GpioBaseClass):
             name=self._name,
             pin=self._pin,
             detector=self._detector,
-            gpio_mode=kwargs.get("gpio_mode", "gpio"),
         )
         
         _LOGGER.debug("Configured binary sensor %s on pin %s (inverted=%s)", 

{boneio-1.6.0.dev13 → boneio-1.6.0.dev15}/boneio/components/input/event.py

@@ -140,7 +140,6 @@ class GpioEventButton(GpioBaseClass):
             name=self._name,
             pin=self._pin,
             detector=self._detector,
-            gpio_mode=kwargs.get("gpio_mode", "gpio"),
         )
 
         _LOGGER.debug("Configured event input %s on pin %s", self._name, self._pin)

{boneio-1.6.0.dev13 → boneio-1.6.0.dev15}/boneio/components/template/alarm_panel.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import hashlib
+import hmac
 import json
 import logging
 import time
@@ -49,6 +50,22 @@ OUTPUT_NOTIFICATION = "notification"
 OUTPUT_LIGHT = "light"
 OUTPUT_CUSTOM = "custom"
 
+# Outcome of a command that needed a code; the web API maps these to HTTP.
+CODE_OK = "ok"
+CODE_INVALID = "invalid_code"
+CODE_MISSING = "code_required"
+CODE_LOCKED = "locked"
+
+# Wrong-code throttling (PLAN_OSDP §7.2 pt 1). A four-digit PIN is 10 000
+# guesses; unthrottled, a script over the API or MQTT runs through them in
+# minutes. After this many wrong codes in a row every code is refused, the
+# right one included, for a pause that doubles with each further run of
+# failures. It throttles and never locks for good — the same rule as
+# webui/rate_limit.py: the worst a guesser can do is make the owner wait.
+CODE_MAX_FAILURES = 5
+CODE_LOCKOUT_BASE_S = 30.0
+CODE_LOCKOUT_MAX_S = 900.0
+
 # Input wiring types
 NORMALLY_CLOSED = "normally_closed"
 NORMALLY_OPEN = "normally_open"
@@ -199,7 +216,9 @@ class AlarmPinCode:
         Returns:
             True if the PIN matches.
         """
-        return self._hash == self.hash_code(plain_code)
+        # Constant-time: `==` on the digests leaks, through timing, how much of
+        # a guess matched (PLAN_OSDP §7.2 pt 3).
+        return hmac.compare_digest(self._hash, self.hash_code(plain_code))
 
     @staticmethod
     def hash_code(plain: str) -> str:
@@ -291,11 +310,21 @@ class BoneIOAlarmPanel:
         self._state_topic = f"{topic_prefix}/alarm/{id}/{STATE}"
         self._cmd_topic = f"{topic_prefix}/cmd/alarm/{id}/set"
         self._attributes_topic = f"{topic_prefix}/alarm/{id}/attributes"
+        # The "codes locked" binary_sensor in HA, for automations.
+        self._code_lock_topic = f"{topic_prefix}/alarm/{id}/code_lock"
 
         # Track triggered inputs for logging
         self._triggered_zone: str | None = None
         self._triggered_input: str | None = None
 
+        # Wrong-code throttling. One counter for the panel, whatever the code
+        # came through — HA, the web UI, a keypad — so switching paths does
+        # not buy a guesser a fresh allowance.
+        self._code_failures = 0
+        self._code_lockouts = 0
+        self._code_locked_until: float | None = None
+        self._code_unlock_timer: asyncio.TimerHandle | None = None
+
         _LOGGER.info(
             "Initialized BoneIOAlarmPanel: id=%s, zones=%d, outputs=%d, "
             "codes=%d, arming=%.0fs, delay=%.0fs, trigger=%.0fs",
@@ -359,6 +388,21 @@ class BoneIOAlarmPanel:
         remaining = self._arming_time_s - elapsed
         return max(0.0, round(remaining, 1))
 
+    @property
+    def code_failed_attempts(self) -> int:
+        """Wrong codes entered in a row since the last right one."""
+        return self._code_failures
+
+    @property
+    def code_locked_remaining_s(self) -> float | None:
+        """Seconds until codes are checked again, or None when not locked."""
+        if self._code_locked_until is None:
+            return None
+        remaining = self._code_locked_until - time.monotonic()
+        if remaining <= 0:
+            return None
+        return round(remaining, 1)
+
     # -- State persistence ----------------------------------------------------
 
     _PERSIST_ATTR_TYPE = ALARM_CONTROL_PANEL
@@ -396,34 +440,98 @@ class BoneIOAlarmPanel:
 
     # -- PIN code validation -------------------------------------------------
 
-    def _validate_code(self, code: str | None, action: str) -> tuple[bool, str | None]:
-        """Validate a PIN code against configured codes.
+    def _validate_code(self, code: str | None, action: str) -> tuple[str, str | None]:
+        """Validate a PIN code against configured codes, with throttling.
 
         Args:
             code: The PIN code to validate (None if not provided).
             action: The action being performed (for logging).
 
         Returns:
-            Tuple of (is_valid, user_name). If no codes are configured,
-            always returns (True, None).
+            Tuple of (outcome, user_name): outcome is CODE_OK, CODE_MISSING,
+            CODE_INVALID or CODE_LOCKED. If no codes are configured, always
+            (CODE_OK, None).
         """
         if not self._codes:
-            return True, None
+            return CODE_OK, None
+
+        # Refused unchecked while locked — checking would let a guesser keep
+        # going and only hide which guess was right.
+        locked_s = self.code_locked_remaining_s
+        if locked_s is not None:
+            _LOGGER.warning(
+                "Alarm %s: %s rejected — codes locked for %.0fs after %d wrong codes",
+                self._id, action, locked_s, self._code_failures,
+            )
+            return CODE_LOCKED, None
 
         if not code:
+            # Not a guess, so not counted: HA sends a bare command when the
+            # user taps a button before typing anything.
             _LOGGER.warning("Alarm %s: %s rejected — no code provided", self._id, action)
-            return False, None
+            return CODE_MISSING, None
 
         for pin in self._codes:
-            if pin.verify(code):
-                return True, pin.name
+            if pin.verify(str(code)):
+                if self._code_failures:
+                    self._code_failures = 0
+                    self._code_lockouts = 0
+                    self._code_locked_until = None
+                    self._publish_attributes()
+                return CODE_OK, pin.name
+
+        self._code_failures += 1
+        _LOGGER.warning(
+            "Alarm %s: %s rejected — invalid code (%d in a row)",
+            self._id, action, self._code_failures,
+        )
+        if self._code_failures % CODE_MAX_FAILURES == 0:
+            lock_s = min(CODE_LOCKOUT_MAX_S, CODE_LOCKOUT_BASE_S * (2 ** self._code_lockouts))
+            self._code_lockouts += 1
+            self._code_locked_until = time.monotonic() + lock_s
+            _LOGGER.warning(
+                "Alarm %s: %d wrong codes in a row — codes locked for %.0fs",
+                self._id, self._code_failures, lock_s,
+            )
+            self._publish_code_lock(True)
+            self._schedule_code_unlock(lock_s)
+            self._publish_attributes()
+            return CODE_LOCKED, None
+        self._publish_attributes()
+        return CODE_INVALID, None
+
+    def _publish_code_lock(self, locked: bool) -> None:
+        """Publish the "codes locked" binary_sensor state (retained)."""
+        self._message_bus.send_message(
+            topic=self._code_lock_topic,
+            payload="ON" if locked else "OFF",
+            retain=True,
+        )
+
+    def _schedule_code_unlock(self, delay_s: float) -> None:
+        """Turn the binary_sensor off again when the lockout runs out.
+
+        The lockout itself needs no timer — it is a deadline checked on the
+        next code — but HA only learns it ended if something says so.
+        """
+        if self._code_unlock_timer is not None:
+            self._code_unlock_timer.cancel()
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            return
+        self._code_unlock_timer = loop.call_later(delay_s, self._on_code_unlock)
 
-        _LOGGER.warning("Alarm %s: %s rejected — invalid code", self._id, action)
-        return False, None
+    def _on_code_unlock(self) -> None:
+        """Lockout over: tell HA, and refresh the attributes it reads."""
+        self._code_unlock_timer = None
+        _LOGGER.info("Alarm %s: code lockout ended", self._id)
+        self._publish_code_lock(False)
+        self._publish_attributes()
 
     # -- MQTT command handler ------------------------------------------------
 
-    async def handle_command(self, _topic: str, payload: str) -> None:
+    async def handle_command(self, _topic: str, payload: str) -> str:
         """Handle alarm command from HA.
 
         Payload can be a plain command string (ARM_HOME, DISARM, etc.)
@@ -433,6 +541,11 @@ class BoneIOAlarmPanel:
         Args:
             _topic: MQTT topic (unused).
             payload: Command string or JSON payload.
+
+        Returns:
+            CODE_OK when the command was accepted, otherwise why the code was
+            refused (CODE_MISSING, CODE_INVALID, CODE_LOCKED). MQTT ignores
+            it; the web API turns it into a status code.
         """
         code: str | None = None
         command: str
@@ -452,17 +565,17 @@ class BoneIOAlarmPanel:
                       self._id, command, self._state)
 
         if command == CMD_DISARM:
-            valid, user_name = self._validate_code(code, "DISARM")
-            if not valid:
-                return
+            outcome, user_name = self._validate_code(code, "DISARM")
+            if outcome != CODE_OK:
+                return outcome
             if user_name:
                 _LOGGER.info("Alarm %s disarmed by %s", self._id, user_name)
             await self._disarm()
         elif command in (CMD_ARM_HOME, CMD_ARM_AWAY, CMD_ARM_NIGHT):
             if self._code_arm_required:
-                valid, user_name = self._validate_code(code, command)
-                if not valid:
-                    return
+                outcome, user_name = self._validate_code(code, command)
+                if outcome != CODE_OK:
+                    return outcome
                 if user_name:
                     _LOGGER.info("Alarm %s armed (%s) by %s", self._id, command, user_name)
             target = {
@@ -475,6 +588,7 @@ class BoneIOAlarmPanel:
             await self._trigger("manual", "manual")
         else:
             _LOGGER.warning("Unknown alarm command: %s", command)
+        return CODE_OK
 
     # -- Input event handler -------------------------------------------------
 
@@ -776,6 +890,9 @@ class BoneIOAlarmPanel:
         attrs: dict[str, Any] = {
             "triggered_zone": self._triggered_zone,
             "triggered_input": self._triggered_input,
+            # For an HA automation that tells someone their PIN is being guessed.
+            "code_failed_attempts": self._code_failures,
+            "code_locked_s": self.code_locked_remaining_s,
         }
         if blocking_inputs is not None:
             attrs["blocking_inputs"] = blocking_inputs
@@ -793,11 +910,18 @@ class BoneIOAlarmPanel:
             self._cmd_topic, self.handle_command
         )
         self._publish_state()
+        # A lockout lives in memory only, so after a restart codes are open —
+        # say so, rather than leave a retained ON from before the restart.
+        if self._codes:
+            self._publish_code_lock(False)
         _LOGGER.info("Alarm panel %s started", self._id)
 
     async def stop(self) -> None:
         """Stop alarm panel — cancel timers and unsubscribe."""
         self._cancel_all_timers()
+        if self._code_unlock_timer is not None:
+            self._code_unlock_timer.cancel()
+            self._code_unlock_timer = None
         await self._deactivate_outputs()
         with contextlib.suppress(Exception):
             await self._message_bus.unsubscribe_and_stop_listen(self._cmd_topic)

{boneio-1.6.0.dev13 → boneio-1.6.0.dev15}/boneio/const.py

@@ -14,12 +14,12 @@ SET_BRIGHTNESS = "set_brightness"
 ENABLED = "enabled"
 OUTPUT = "output"
 VIRTUAL_SWITCH = "virtual_switch"
+SCHEDULE = "schedule"
 PIN = "pin"
 ID = "id"
 KIND = "kind"
 GPIO = "gpio"
 PCA = "pca"
-GPIO_MODE = "gpio_mode"
 ACTIONS = "actions"
 ACTION = "action"
 OUTPUT_OVER_MQTT = "output_over_mqtt"
@@ -194,6 +194,7 @@ cover_actions = {
     "TOGGLE_OPEN": "toggle_open",
     "TOGGLE_CLOSE": "toggle_close",
     "SMART_TOGGLE": "smart_toggle",
+    "SET_POSITION": "set_cover_position",
     "TILT": "set_tilt",
     "TILT_OPEN": "tilt_open",
     "TILT_CLOSE": "tilt_close",

boneio-1.6.0.dev15/boneio/core/atomic_file.py

@@ -0,0 +1,113 @@
+"""Replace a file's content without ever leaving half of it on disk.
+
+The controller has no UPS and runs from an SD card or eMMC. A plain
+``open(path, "w")`` truncates the file first, so power lost during the write
+leaves ``config.yaml`` cut short — and a controller that no longer boots.
+Writing next to the target and renaming over it means a reader, or the next
+boot, sees either the old file or the new one, never a mix.
+
+Kept free of heavy imports: the recovery app uses it too.
+"""
+
+from __future__ import annotations
+
+import glob
+import os
+import tempfile
+import time
+from pathlib import Path
+
+
+#: A temp file this old was left by a writer that died: a save takes well
+#: under a second, and one still running must not lose its file.
+_STALE_TEMP_SECONDS = 60
+#: What tempfile.mkstemp appends to the prefix.
+_TEMP_SUFFIX_LEN = 8
+
+
+def _remove_stale_temps(target: Path) -> None:
+    """Delete temp files left by writes that never reached the rename.
+
+    Nothing can clean up after a power cut or SIGKILL mid-write, so without
+    this they pile up in the config directory, one per interrupted save.
+    """
+    prefix = f".{target.name}."
+    cutoff = time.time() - _STALE_TEMP_SECONDS
+    try:
+        candidates = list(target.parent.glob(f"{glob.escape(prefix)}*"))
+    except OSError:
+        return
+    for candidate in candidates:
+        if len(candidate.name) != len(prefix) + _TEMP_SUFFIX_LEN:
+            continue
+        try:
+            if candidate.lstat().st_mtime < cutoff:
+                candidate.unlink()
+        except OSError:
+            continue
+
+
+def _new_file_mode() -> int:
+    """What ``open(path, "w")`` would have given a new file under our umask.
+
+    Read from /proc rather than with os.umask(), which can only be read by
+    setting it, and would briefly change it for every other thread.
+    """
+    try:
+        with open("/proc/self/status", encoding="ascii") as f:
+            for line in f:
+                if line.startswith("Umask:"):
+                    return 0o666 & ~int(line.split()[1], 8)
+    except (OSError, ValueError, IndexError):
+        pass
+    return 0o644
+
+
+def write_atomically(
+    path: str | os.PathLike[str], content: str | bytes, mode: int | None = None
+) -> None:
+    """Write ``content`` to ``path`` atomically.
+
+    Keeps the original's permission bits: an included file that holds a broker
+    password is often 0600, and a rewrite must not widen that. A symlink is
+    followed, so the file it points to is replaced rather than the link.
+
+    Args:
+        path: File to write. Its directory must exist.
+        content: New content; ``str`` is written as UTF-8.
+        mode: Permission bits to set. Defaults to the existing file's, or what
+            the process umask gives a new one.
+    """
+    target = Path(os.path.realpath(path))
+    if mode is None:
+        try:
+            mode = target.stat().st_mode & 0o777
+        except FileNotFoundError:
+            mode = _new_file_mode()
+
+    fd, tmp = tempfile.mkstemp(dir=target.parent, prefix=f".{target.name}.")
+    try:
+        with os.fdopen(fd, "wb") as f:
+            f.write(content.encode("utf-8") if isinstance(content, str) else content)
+            f.flush()
+            os.fsync(f.fileno())
+        os.chmod(tmp, mode)
+        os.replace(tmp, target)
+    except BaseException:
+        Path(tmp).unlink(missing_ok=True)
+        raise
+
+    _remove_stale_temps(target)
+
+    # The rename lives in the directory entry; without this a power cut right
+    # after it can still bring back the old file.
+    try:
+        dir_fd = os.open(target.parent, os.O_RDONLY)
+    except OSError:
+        return
+    try:
+        os.fsync(dir_fd)
+    except OSError:
+        pass
+    finally:
+        os.close(dir_fd)

boneio-1.6.0.dev15/boneio/core/auth/jwt_secret.py

@@ -0,0 +1,59 @@
+"""The secret the panel signs its login tokens with.
+
+Kept in ``jwt_secret`` next to config.yaml so a token outlives a restart. Here
+rather than in the web server so recovery mode signs with the same secret
+without importing the web server, which pulls in the whole Manager: a token
+issued in recovery keeps working once the controller is back, and the other
+way round.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import secrets
+from pathlib import Path
+
+_LOGGER = logging.getLogger(__name__)
+
+JWT_SECRET_FILENAME = "jwt_secret"
+
+
+def load_or_create_jwt_secret(config_dir: str | os.PathLike[str]) -> str:
+    """Read the token secret, creating it on first use.
+
+    Never raises: a secret that cannot be persisted is replaced by one that
+    lives as long as the process, which logs everybody out on the next restart
+    but does not keep the panel from starting.
+
+    Args:
+        config_dir: The directory config.yaml is in.
+
+    Returns:
+        The secret.
+    """
+    jwt_secret_file = Path(config_dir) / JWT_SECRET_FILENAME
+
+    try:
+        if jwt_secret_file.exists():
+            # Read existing secret
+            with open(jwt_secret_file) as f:
+                jwt_secret = f.read().strip()
+                if jwt_secret:  # Verify it's not empty
+                    return jwt_secret
+
+        # Generate new secret if file doesn't exist or is empty
+        jwt_secret = secrets.token_hex(32)  # 256-bit random secret
+
+        # Save the secret
+        with open(jwt_secret_file, "w") as f:
+            f.write(jwt_secret)
+
+        # Secure the file permissions (read/write only for owner)
+        os.chmod(jwt_secret_file, 0o600)
+
+    except Exception as e:
+        # If we can't persist the secret, generate a temporary one
+        _LOGGER.error(f"Failed to handle JWT secret file: {e}")
+        jwt_secret = secrets.token_hex(32)
+    return jwt_secret

{boneio-1.6.0.dev13/boneio/migrations/assets/docker/nodered → boneio-1.6.0.dev15/boneio/core/cloud/data}/docker-compose.yaml

@@ -17,7 +17,7 @@ services:
     networks:
       - edge
   caddy:
-    image: caddy:2-alpine
+    image: caddy:2.11.4-alpine@sha256:6aeddd44c3078b0f9a35206472a11420648a79c184603ef95957d0a20044cb2b
     restart: unless-stopped
     hostname: ${HOSTNAME:-boneio}
     ports:

{boneio-1.6.0.dev13 → boneio-1.6.0.dev15}/boneio/core/config/migrations/__init__.py

@@ -14,10 +14,12 @@ import re
 from collections.abc import Callable
 from dataclasses import dataclass, field
 
+from boneio.core.atomic_file import write_atomically
+
 _LOGGER = logging.getLogger(__name__)
 
 # Current schema version — bump this when adding new migrations
-CURRENT_SCHEMA_VERSION = 5
+CURRENT_SCHEMA_VERSION = 6
 
 # Minimum app version that introduced each schema version.
 # Used by the WebUI to warn before rolling back to an incompatible version.
@@ -28,6 +30,7 @@ SCHEMA_VERSION_APP_MAP: dict[int, str] = {
     3: "1.3.0dev7",   # irrigation section
     4: "1.5.0dev13",  # WLED effects/palettes → JSON cache
     5: "1.5.0dev35",  # OLED screen name: ina219 → ina
+    6: "1.6.0dev15",  # gpio_mode, clear_message removed from inputs
 }
 
 
@@ -153,6 +156,15 @@ def _has_legacy_fields(doc: dict) -> bool:
         if isinstance(screens, list) and "ina219" in screens:
             return True
 
+    # v6: dead gpio_mode / clear_message keys on inputs
+    for section_key in ("event", "binary_sensor"):
+        items = doc.get(section_key)
+        if isinstance(items, list) and any(
+            isinstance(item, dict) and ("gpio_mode" in item or "clear_message" in item)
+            for item in items
+        ):
+            return True
+
     return False
 
 
@@ -298,8 +310,7 @@ def _persist_config_version(config_file: str, version: int) -> None:
         indent = " " * (boneio_indent + 2)
         updated_lines.append(f"{indent}config_version: {version}\n")
 
-    with open(config_file, "w", encoding="utf-8") as f:
-        f.writelines(updated_lines)
+    write_atomically(config_file, "".join(updated_lines))
 
     _LOGGER.info("Persisted config_version: %d to %s", version, config_file)
 
@@ -310,4 +321,5 @@ from boneio.core.config.migrations import (
     v2_transition,  # noqa: E402, F401
     v4_wled_cache,  # noqa: E402, F401
     v5_ina_screen,  # noqa: E402, F401
+    v6_input_keys,  # noqa: E402, F401
 )

{boneio-1.6.0.dev13 → boneio-1.6.0.dev15}/boneio/core/config/migrations/v1_proxy_port.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import logging
 import re
 
+from boneio.core.atomic_file import write_atomically
 from boneio.core.config.migrations import register_migration
 
 _LOGGER = logging.getLogger(__name__)
@@ -41,8 +42,7 @@ def _persist_proxy_port(config_file: str) -> None:
             updated_lines.append(line)
 
     if updated:
-        with open(config_file, "w", encoding="utf-8") as f:
-            f.writelines(updated_lines)
+        write_atomically(config_file, "".join(updated_lines))
 
 
 @register_migration(

{boneio-1.6.0.dev13 → boneio-1.6.0.dev15}/boneio/core/config/migrations/v2_transition.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import logging
 import re
 
+from boneio.core.atomic_file import write_atomically
 from boneio.core.config.migrations import register_migration
 
 _LOGGER = logging.getLogger(__name__)
@@ -52,8 +53,7 @@ def _persist_transition(config_file: str) -> None:
             updated_lines.append(line)
 
     if updated:
-        with open(config_file, "w", encoding="utf-8") as f:
-            f.writelines(updated_lines)
+        write_atomically(config_file, "".join(updated_lines))
 
 
 @register_migration(