boneio 1.5.0.dev8__tar.gz → 1.5.0.dev10__tar.gz

{boneio-1.5.0.dev8/boneio.egg-info → boneio-1.5.0.dev10}/PKG-INFO

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

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/components/cover/time_based.py

@@ -12,6 +12,7 @@ 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}
@@ -151,6 +152,6 @@ class TimeBasedCover(BaseCover):
                    Keys: open_time, close_time
         """
         if "open_time" in config:
-            self._open_time = config["open_time"].total_milliseconds
+            self._open_time = ensure_time_period(config["open_time"]).total_milliseconds
         if "close_time" in config:
-            self._close_time = config["close_time"].total_milliseconds
+            self._close_time = ensure_time_period(config["close_time"]).total_milliseconds

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/components/cover/venetian.py

@@ -8,6 +8,7 @@ import time
 from boneio.components.cover.cover import BaseCover, BaseVenetianCoverABC
 from boneio.const import CLOSE, CLOSING, IDLE, OPEN, OPENING, STOP
 from boneio.core.utils import TimePeriod
+from boneio.core.utils.timeperiod import ensure_time_period
 from boneio.models import PositionDict, SavedPositionDict
 
 _LOGGER = logging.getLogger(__name__)
@@ -362,11 +363,11 @@ class VenetianCover(BaseCover, BaseVenetianCoverABC):
                    Keys: open_time, close_time, tilt_duration, tilt_restore_after_close
         """
         if "open_time" in config:
-            self._open_time = config["open_time"].total_milliseconds
+            self._open_time = ensure_time_period(config["open_time"]).total_milliseconds
         if "close_time" in config:
-            self._close_time = config["close_time"].total_milliseconds
+            self._close_time = ensure_time_period(config["close_time"]).total_milliseconds
         if "tilt_duration" in config and config["tilt_duration"]:
-            self._tilt_duration = config["tilt_duration"].total_milliseconds
+            self._tilt_duration = ensure_time_period(config["tilt_duration"]).total_milliseconds
         if "tilt_restore_after_close" in config:
             self._tilt_restore_after_close = bool(config["tilt_restore_after_close"])
 

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/core/config/config_helper.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 import logging
 from _collections_abc import dict_values
 from typing import TYPE_CHECKING, Any
+import time as _time
 
 if TYPE_CHECKING:
     from boneio.integration.homeassistant import HomeAssistantDiscoveryMessage
@@ -28,7 +29,6 @@ from boneio.const import (
     VALVE,
 )
 from boneio.core.system import get_serial_from_mac
-from boneio.core.utils.util import sanitize_mqtt_topic
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -53,21 +53,29 @@ class ConfigHelper:
         pwa_name: str | None = None,
         ha_child_devices: bool = False,
         ha_child_devices_naming: str = "default",
+        serial_override: str | None = None,
     ):
         self._name = name
         self._version = version
         
-        # Generate serial number from MAC - always required for topic prefix
-        self._serial_no = get_serial_from_mac(network_info or {})
+        # Generate real serial number from MAC - always required for physical identification
+        self._real_serial = get_serial_from_mac(network_info or {})
         
-        # Build fixed topic prefix: boneio/blk_{serial}
+        # If override is provided, use it as effective serial, otherwise use real MAC-based serial
+        if serial_override:
+            self._serial_no = serial_override
+            _LOGGER.warning("Serial override active: effective=%s, real=%s", serial_override, self._real_serial)
+        else:
+            self._serial_no = self._real_serial
+        
+        # Build fixed topic prefix: boneio/blk_{serial} using effective serial
         # This is no longer configurable - always uses this format
         if self._serial_no:
             self._topic_prefix = f"boneio/{self._serial_no}"
         else:
             # Fallback if MAC not available (should rarely happen)
             self._topic_prefix = "boneio/blk_unknown"
-            _LOGGER.warning("Could not determine serial number from MAC, using fallback topic prefix")
+            _LOGGER.warning("Could not determine serial number, using fallback topic prefix")
 
         # PWA short name for Android home screen (max 12 chars)
         if pwa_name:
@@ -165,7 +173,8 @@ class ConfigHelper:
 
     @property
     def serial_number(self) -> str:
-        return self._serial_no
+        """Get effective device serial number (e.g., 'blk_abc123')."""
+        return self._serial_no or "blk_unknown"
 
     @property
     def proxy_port(self) -> int | None:
@@ -186,9 +195,16 @@ class ConfigHelper:
         return self._topic_prefix
 
     @property
-    def serial_no(self) -> str:
-        """Get device serial number (e.g., 'blk_abc123')."""
-        return self._serial_no or "blk_unknown"
+    def real_serial(self) -> str:
+        """Real serial from MAC — for HA device_info and UI display."""
+        return self._real_serial or "blk_unknown"
+
+    @property
+    def serial_override(self) -> str | None:
+        """Return override value if active, None otherwise."""
+        if self._serial_no != self._real_serial:
+            return self._serial_no
+        return None
 
     @property
     def pwa_name(self) -> str:
@@ -390,16 +406,20 @@ class ConfigHelper:
         return self._config_cache
 
     def reload_config(self) -> dict[str, Any]:
-        """Reload configuration from file and update cache.
+        """Reload configuration from YAML file (fast path for hot-reload).
         
-        Loads config from file using load_config_from_file() which tries the
-        disk cache first (~0.5s) and falls back to full Cerberus validation
-        (~20s) on cache miss. This method does NOT wait for any background
-        cache rebuild — it's independent.
+        Uses load_yaml_file() + merge_board_config() to read the config
+        directly from YAML without running Cerberus validation. This is
+        much faster (~0.5-1s) than the full validation path (~20s on BB).
         
-        NOTE: This method may take up to ~20s on BeagleBone if disk cache
-        is not available. Callers should run it via asyncio.to_thread() to
-        avoid blocking the event loop.
+        Full Cerberus validation is only needed at:
+        - Application startup (via load_config_from_file)
+        - Background disk cache rebuild (debounced after config changes)
+        - Monaco YAML editor validation (load_config_from_string)
+        
+        NOTE: Migrations are not applied here — they run at startup and
+        are idempotent (version-gated). Config saved via the UI always
+        has current schema version.
         
         Returns:
             dict: Reloaded configuration dictionary
@@ -407,8 +427,26 @@ class ConfigHelper:
         Raises:
             ValueError: If config_file_path is not set
         """
-        _LOGGER.info("Reloading config from file: %s", self._config_file_path)
-        return self.get_config(force_reload=True)
+
+        if self._config_file_path is None:
+            raise ValueError("config_file_path not set in 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}")
+
+        merged = merge_board_config(config_yaml)
+        self._config_cache = merged
+
+        elapsed = _time.monotonic() - _t0
+        _LOGGER.info("Fast config reload completed in %.2fs", elapsed)
+
+        return merged
 
     def get_section(self, section_name: str, force_reload: bool = False) -> Any:
         """Get a specific configuration section.

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/core/discovery.py

@@ -62,9 +62,9 @@ class BlackDiscoveryPublisher:
 
         config_helper = self._manager._config_helper
         device_info = {
-            "id": config_helper._serial_no or "unknown",
+            "id": config_helper.serial_number,
             "name": config_helper.name,
-            "serial_number": config_helper._serial_no or "unknown",
+            "serial_number": config_helper.serial_number,
             "type": "black",
             "firmware": __version__,
             "topic_prefix": config_helper.topic_prefix,

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/core/manager/covers.py

@@ -14,7 +14,7 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 from boneio.const import COVER, DEVICE_CLASS, ID, NAME, RESTORE_STATE, SHOW_HA, cover_actions, filter_cover_extra_data
-from boneio.core.utils import TimePeriod, strip_accents
+from boneio.core.utils import TimePeriod, ensure_time_period, strip_accents
 from boneio.exceptions import CoverConfigurationException
 from boneio.integration import ha_cover_availabilty_message
 from boneio.integration.homeassistant import ha_cover_with_tilt_availabilty_message
@@ -230,6 +230,14 @@ class CoverManager:
 
         platform = config.get("platform", "time_based")
 
+        # 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"):
+            if time_key in config and config[time_key] is not None:
+                config[time_key] = ensure_time_period(config[time_key])
+        if tilt_duration is not None and not isinstance(tilt_duration, TimePeriod):
+            tilt_duration = ensure_time_period(tilt_duration)
+
         def state_save(value: dict[str, float]):
             if config[RESTORE_STATE]:
                 self._manager._state_manager.save_attribute(

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/core/manager/inputs.py

@@ -255,13 +255,17 @@ class InputManager:
 
             # Reload: update existing input's actions and name
             if existing_input:
-                # Check if HA-relevant fields changed (name, area, mqtt_sequences)
+                # Check if HA-relevant fields changed (name, area, device_class, mqtt_sequences)
                 old_name = existing_input._name if hasattr(existing_input, "_name") else None
                 old_area = getattr(existing_input, "area", None)
+                old_device_class = getattr(existing_input, "_device_class", None)
+                new_device_class = gpio.get(DEVICE_CLASS)
                 old_mqtt_sequences = existing_input.mqtt_sequences if hasattr(existing_input, "mqtt_sequences") else {}
                 new_mqtt_sequences = gpio.get("mqtt_sequences", {})
                 ha_fields_changed = (
-                    (old_name != name) or (old_area != area) or (old_mqtt_sequences != new_mqtt_sequences)
+                    (old_name != name) or (old_area != area)
+                    or (old_device_class != new_device_class)
+                    or (old_mqtt_sequences != new_mqtt_sequences)
                 )
 
                 # Update actions (always - this is internal to the controller)
@@ -383,10 +387,15 @@ class InputManager:
 
             # Reload: update existing input's actions and name
             if existing_input:
-                # Check if HA-relevant fields changed (name, area)
+                # Check if HA-relevant fields changed (name, area, device_class)
                 old_name = existing_input._name if hasattr(existing_input, "_name") else None
                 old_area = getattr(existing_input, "area", None)
-                ha_fields_changed = (old_name != name) or (old_area != area)
+                old_device_class = getattr(existing_input, "_device_class", None)
+                new_device_class = gpio.get(DEVICE_CLASS)
+                ha_fields_changed = (
+                    (old_name != name) or (old_area != area)
+                    or (old_device_class != new_device_class)
+                )
 
                 # Update actions (always - this is internal to the controller)
                 existing_input.set_actions(actions=actions)

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/core/manager/irrigation.py

@@ -309,7 +309,7 @@ class IrrigationManager:
         Sends empty payload to discovery topics to remove entities from HA.
         """
         cfg = self._manager.config_helper
-        serial = cfg.serial_no
+        serial = cfg.serial_number
 
         # Build list of discovery IDs to remove
         discovery_ids: list[tuple[str, str]] = [

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/core/manager/manager.py

@@ -52,6 +52,7 @@ from boneio.core.manager.templates import TemplateManager
 from boneio.core.manager.update import UpdateManager
 from boneio.core.messaging import MessageBus
 from boneio.core.state import StateManager
+from boneio.core.utils.timeperiod import parse_time_to_ms, parse_time_to_seconds
 from boneio.hardware.i2c.bus import SMBus2I2C
 from boneio.migrations import MigrationRunner, MigrationStatus
 
@@ -243,7 +244,7 @@ class Manager:
         self.remote_devices = RemoteDeviceManager(
             message_bus=message_bus,
             remote_devices_config=remote_devices,
-            own_serial=config_helper.serial_no,
+            own_serial=config_helper.serial_number,
             name=self.config_helper.name,
         )
 
@@ -625,7 +626,7 @@ class Manager:
             ha_type: Home Assistant entity type (sensor, light, cover …).
             payload: Ready-to-publish discovery payload dict.
         """
-        topic = f"{self._config_helper.ha_discovery_prefix}/{ha_type}/{self._config_helper.serial_no}/{id}/config"
+        topic = f"{self._config_helper.ha_discovery_prefix}/{ha_type}/{self._config_helper.serial_number}/{id}/config"
         _LOGGER.debug("Sending HA discovery for %s entity %s.", ha_type, id)
         self._config_helper.add_autodiscovery_msg(topic=topic, ha_type=ha_type, payload=payload)
         self.send_message(topic=topic, payload=payload, retain=True)
@@ -657,23 +658,19 @@ class Manager:
             """Copy long press meta fields (duration thresholds, repeat), delay, and conditions to parsed action."""
             for key in ("min_duration", "max_duration"):
                 if action_definition.get(key) is not None:
-                    parsed_action[key] = action_definition[key]
+                    parsed_action[key] = parse_time_to_ms(action_definition[key], None)
             if action_definition.get("repeat"):
                 parsed_action["repeat"] = True
                 ri = action_definition.get("repeat_interval", 1000)
-                # TimePeriod object from schema validation -> convert to ms
-                if hasattr(ri, "total_milliseconds"):
-                    parsed_action["repeat_interval"] = ri.total_milliseconds
-                else:
-                    parsed_action["repeat_interval"] = ri
+                # Safely convert TimePeriod, string ("1s"), or number to ms
+                parsed_action["repeat_interval"] = parse_time_to_ms(ri, 1000)
             # Copy delay fields for cancelable timer support
             delay_val = action_definition.get("delay")
             if delay_val is not None:
-                if hasattr(delay_val, "total_in_seconds"):
-                    parsed_action["delay"] = delay_val.total_in_seconds
-                elif isinstance(delay_val, (int, float)):
-                    parsed_action["delay"] = float(delay_val)
-                _LOGGER.debug("Action has delay: %.1fs", parsed_action.get("delay", 0))
+                # Safely convert TimePeriod, string ("5s"), or number to seconds
+                parsed_delay = parse_time_to_seconds(delay_val, 0.0)
+                parsed_action["delay"] = parsed_delay
+                _LOGGER.debug("Action has delay: %.1fs", parsed_delay)
             cancel_on = action_definition.get("delay_cancel_on")
             if cancel_on:
                 parsed_action["delay_cancel_on"] = cancel_on
@@ -818,13 +815,11 @@ class Manager:
                             val = action_definition.get(opt_key)
                             if val is not None:
                                 parsed_action[opt_key] = val
-                        # Convert transition TimePeriod to float seconds
+                        # Convert transition TimePeriod/string to float seconds
                         if "transition" in parsed_action:
-                            t_val = parsed_action["transition"]
-                            if hasattr(t_val, "total_in_seconds"):
-                                parsed_action["transition"] = t_val.total_in_seconds
-                            elif not isinstance(t_val, (int, float)):
-                                parsed_action["transition"] = 0.0
+                            parsed_action["transition"] = parse_time_to_seconds(
+                                parsed_action["transition"], 0.0
+                            )
                         _copy_long_press_meta(parsed_action, action_definition)
                         parsed_actions[click_type].append(parsed_action)
                         continue
@@ -1089,11 +1084,7 @@ class Manager:
             if transition_val and action_definition.get("repeat"):
                 repeat_interval = action_definition.get("repeat_interval")
                 if repeat_interval:
-                    ri_seconds = (
-                        repeat_interval.total_in_seconds
-                        if hasattr(repeat_interval, "total_in_seconds")
-                        else repeat_interval / 1000.0
-                    )
+                    ri_seconds = parse_time_to_seconds(repeat_interval, 1.0)
                     if transition_val > ri_seconds:
                         _LOGGER.debug(
                             "Clamping transition %.3fs to repeat_interval %.3fs",
@@ -1590,9 +1581,9 @@ class Manager:
         _LOGGER.info("Starting config reload")
 
         # Reload config cache in ConfigHelper
-        # NOTE: reload_config() calls load_config_from_file() which may run
-        # full Cerberus validation (~20s) on disk cache miss. Run in a thread
-        # executor to keep the event loop responsive (MQTT, WS, modbus).
+        # Uses fast path: load_yaml_file() + merge_board_config() (~0.5-1s)
+        # instead of full Cerberus validation (~20s). Run in thread executor
+        # because it still does file I/O (reading YAML files from disk).
         try:
             config = await asyncio.to_thread(self._config_helper.reload_config)
             # Update areas mapping from reloaded config

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/core/manager/update.py

@@ -737,7 +737,7 @@ class UpdateManager(AsyncUpdater):
         # --- Remove legacy event entity discovery (if any) ---
         old_event_topic = (
             f"{config.ha_discovery_prefix}/event/"
-            f"{config.serial_no}/migration_alert/config"
+            f"{config.serial_number}/migration_alert/config"
         )
         self._manager.send_message(topic=old_event_topic, payload="", retain=True)
         _LOGGER.debug("Removed legacy migration_alert event entity discovery")

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/core/messaging/mqtt.py

@@ -59,7 +59,7 @@ class MQTTClient(MessageBus):
         self._mqtt_energy_listeners: dict[str, Callable[[str, str], Awaitable[None]]] = {}
         self._discovery_topics = (
             [
-                f"{self._config_helper.ha_discovery_prefix}/{ha_type}/{self._config_helper.serial_no}/#"
+                f"{self._config_helper.ha_discovery_prefix}/{ha_type}/{self._config_helper.serial_number}/#"
                 for ha_type in self._config_helper.ha_types
             ]
             if self._config_helper.ha_discovery

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/core/utils/__init__.py

@@ -3,12 +3,13 @@
 from boneio.core.utils.async_updater import AsyncUpdater
 from boneio.core.utils.filter import Filter
 from boneio.core.utils.logger import configure_logger
-from boneio.core.utils.timeperiod import TimePeriod
+from boneio.core.utils.timeperiod import TimePeriod, ensure_time_period
 from boneio.core.utils.util import callback, open_json, strip_accents
 
 __all__ = [
     "Filter",
     "TimePeriod",
+    "ensure_time_period",
     "callback",
     "configure_logger",
     "strip_accents",

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/core/utils/timeperiod.py

@@ -1,5 +1,6 @@
 import logging
 import math
+import re
 from collections import OrderedDict
 from datetime import timedelta
 from typing import Any
@@ -238,3 +239,69 @@ def parse_time_to_ms(value: Any, default: int | None) -> int | None:
     except (ValueError, TypeError):
         _LOGGER.warning("Invalid time value: %s, using default %s ms", value, default)
         return default
+
+
+_TIME_UNIT_MAP = {
+    "us": "microseconds",
+    "microseconds": "microseconds",
+    "ms": "milliseconds",
+    "milliseconds": "milliseconds",
+    "s": "seconds",
+    "sec": "seconds",
+    "secs": "seconds",
+    "seconds": "seconds",
+    "min": "minutes",
+    "mins": "minutes",
+    "minutes": "minutes",
+    "h": "hours",
+    "hours": "hours",
+    "d": "days",
+    "days": "days",
+}
+
+
+_TIME_PERIOD_RE = re.compile(r"^([-+]?[0-9]*\.?[0-9]+)\s*([a-zA-Z]+)$")
+
+
+def ensure_time_period(value: "TimePeriod | str | int | float") -> "TimePeriod":
+    """Ensure a value is a TimePeriod object.
+
+    Converts strings like '5s', '1000ms', '2min' and raw numeric values
+    (treated as seconds) to TimePeriod. Passes through existing TimePeriod
+    objects unchanged. This is the defensive layer for hot-reload scenarios
+    where YAML values may arrive as raw strings instead of pre-parsed
+    TimePeriod objects.
+
+    Args:
+        value: A TimePeriod, time string with unit, or numeric seconds.
+
+    Returns:
+        A TimePeriod instance.
+
+    Raises:
+        ValueError: If the string format is invalid or the unit is unknown.
+    """
+    if isinstance(value, TimePeriod):
+        return value
+
+    if isinstance(value, (int, float)):
+        return TimePeriod(seconds=float(value))
+
+    if not isinstance(value, str):
+        raise ValueError(f"Cannot convert {type(value).__name__} to TimePeriod: {value!r}")
+
+    value = value.strip()
+    if not value:
+        raise ValueError("Empty string cannot be converted to TimePeriod")
+
+    match = _TIME_PERIOD_RE.match(value)
+    if match is None:
+        raise ValueError(f"Invalid time period format: {value!r}")
+
+    num_str, unit = match.group(1), match.group(2).lower()
+    kwarg = _TIME_UNIT_MAP.get(unit)
+    if kwarg is None:
+        raise ValueError(f"Unknown time unit '{unit}' in: {value!r}")
+
+    return TimePeriod(**{kwarg: float(num_str)})
+

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/integration/homeassistant.py

@@ -123,9 +123,9 @@ def ha_availabilty_message(
             "identifiers": [child_identifier],
             "manufacturer": manufacturer,
             "model": model,
-            "model_id": config_helper.serial_number,
+            "model_id": config_helper.real_serial,
             "name": child_device_name,
-            "serial_number": config_helper.serial_number,
+            "serial_number": config_helper.real_serial,
             "sw_version": __version__,
             "via_device": topic,  # Link to main BoneIO device
             **web_url_dict,
@@ -144,9 +144,9 @@ def ha_availabilty_message(
             "identifiers": [f"{topic}_{area}"],  # Use area ID for consistent grouping
             "manufacturer": manufacturer,
             "model": model,
-            "model_id": config_helper.serial_number,
+            "model_id": config_helper.real_serial,
             "name": sub_device_name,
-            "serial_number": config_helper.serial_number,
+            "serial_number": config_helper.real_serial,
             "sw_version": __version__,
             "via_device": topic,  # Link to main BoneIO device
             "suggested_area": area_name,  # Use area ID (lowercase) - HA converts area names to lowercase
@@ -158,9 +158,9 @@ def ha_availabilty_message(
             "identifiers": [topic],
             "manufacturer": manufacturer,
             "model": model,
-            "model_id": config_helper.serial_number,
+            "model_id": config_helper.real_serial,
             "name": device_name,
-            "serial_number": config_helper.serial_number,
+            "serial_number": config_helper.real_serial,
             "sw_version": __version__,
             **web_url_dict
         }
@@ -297,9 +297,9 @@ def _ha_irrigation_device(
         "identifiers": [f"{topic}_{IRRIGATION}_{ctrl_id}"],
         "manufacturer": "boneIO",
         "model": model,
-        "model_id": config_helper.serial_number,
+        "model_id": config_helper.real_serial,
         "name": ctrl_name,
-        "serial_number": config_helper.serial_number,
+        "serial_number": config_helper.real_serial,
         "sw_version": __version__,
         "via_device": topic,
     }
@@ -880,7 +880,7 @@ def modbus_polling_switch_message(
 
     discovery_topic = (
         f"{config_helper.ha_discovery_prefix}/switch/"
-        f"{config_helper.serial_no}/{entity_id}/config"
+        f"{config_helper.serial_number}/{entity_id}/config"
     )
 
     area_name = config_helper.get_area_name(area) if area else None

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/integration/lox_template.py

@@ -52,7 +52,7 @@ def generate_lox_template(manager: Manager) -> str:
     Returns:
         XML string ready to be saved as a .xml template file.
     """
-    serial = manager.config_helper.serial_no or "boneio"
+    serial = manager.config_helper.serial_number or "boneio"
     device_name = manager.config_helper.name or serial
 
     # Get Lox UDP config (host/ports) from running config
@@ -275,7 +275,7 @@ def generate_lox_summary(manager: Manager) -> dict[str, Any]:
     Returns:
         Dictionary with 'commands' and 'status' sections.
     """
-    serial = manager.config_helper.serial_no or "boneio"
+    serial = manager.config_helper.serial_number or "boneio"
     device_name = manager.config_helper.name or serial
 
     commands: list[dict[str, str]] = []

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/modbus/devices/sensors/boneio-edge-temp.json

@@ -4,7 +4,7 @@
   "description": "boneIO temperature sensor extension board",
   "category": "sensors",
   "default_address": 1,
-  "default_update_interval": "10s",
+  "default_update_interval": "30s",
   "set_base": {
     "set_address_address": 100,
     "set_baudrate": {

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/modbus/entities/base.py

@@ -60,7 +60,7 @@ class BaseEntity(Filter):
         self._timestamp = time.time()
         self._id = f"{self._parent[ID]}_{self._decoded_name_low.replace('_', '')}"
         self._topic = (
-            f"{self._config_helper.ha_discovery_prefix}/{self._entity_type}/{self._config_helper.serial_no}"
+            f"{self._config_helper.ha_discovery_prefix}/{self._entity_type}/{self._config_helper.serial_number}"
             f"/{self._id}/config"
         )
 

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/runner.py

@@ -170,6 +170,7 @@ async def async_run(
         pwa_name=web_config.get("cloud", {}).get("pwa_name"),
         ha_child_devices=main_config.get("ha_child_devices", False),
         ha_child_devices_naming=main_config.get("ha_child_devices_naming", "default"),
+        serial_override=main_config.get("serial_override"),
     )
 
     # Load areas configuration
@@ -358,7 +359,7 @@ async def async_run(
     cloud_reg = None
     if _config_helper.cloud_registration:
         local_ip = network_state.get("ip", "")
-        serial = _config_helper.serial_no
+        serial = _config_helper.serial_number
         if local_ip and serial:
             cloud_reg = CloudRegistration(
                 serial_number=serial,

{boneio-1.5.0.dev8 → boneio-1.5.0.dev10}/boneio/schema/schema.yaml

@@ -2255,3 +2255,16 @@ boneio:
           - default: Entity name only (e.g., "OUT 17"). May cause duplicates if multiple boneIO devices share output names.
           - device_name: Adds boneIO device name prefix (e.g., "boneIO Black - OUT 17").
           - device_name_area: Adds device name and area (e.g., "boneIO Black - Living Room - OUT 17"). Falls back to device_name if no area is assigned.
+    serial_override:
+      required: False
+      type: string
+      nullable: True
+      regex: '^blk[a-f0-9]{6}$'
+      meta:
+        label: Serial number override
+        description: |
+          Override the auto-detected serial number (based on MAC address).
+          Use this when restoring config from a different device (e.g., RMA replacement).
+          Format: blk followed by 6 hex characters (e.g., blk8c7df0).
+          WARNING: Two devices with the same serial on the same MQTT broker will conflict!
+

boneio-1.5.0.dev10/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "1.5.0dev10"