boneio 1.5.0.dev11__tar.gz → 1.5.0.dev13__tar.gz

{boneio-1.5.0.dev11/boneio.egg-info → boneio-1.5.0.dev13}/PKG-INFO

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

{boneio-1.5.0.dev11 → boneio-1.5.0.dev13}/boneio/components/template/gate_cover.py

@@ -191,10 +191,14 @@ class BoneIOGateCover:
     # -- MQTT ----------------------------------------------------------------
 
     async def start(self) -> None:
-        """Subscribe to MQTT command topic."""
+        """Subscribe to MQTT command topic and publish current state.
+
+        Initial sensor state is already set by TemplateManager during
+        configuration, so start() just subscribes and publishes.
+        """
         await self._message_bus.subscribe_and_listen(self._cmd_topic, self.handle_command)
         self._publish_state()
-        _LOGGER.info("GateCover %s started, subscribed to %s", self._id, self._cmd_topic)
+        _LOGGER.info("GateCover %s started (state=%s), subscribed to %s", self._id, self._state, self._cmd_topic)
 
     async def stop(self) -> None:
         """Unsubscribe from MQTT and cancel timers."""

{boneio-1.5.0.dev11 → boneio-1.5.0.dev13}/boneio/core/config/migrations/__init__.py

@@ -17,7 +17,7 @@ from dataclasses import dataclass, field
 _LOGGER = logging.getLogger(__name__)
 
 # Current schema version — bump this when adding new migrations
-CURRENT_SCHEMA_VERSION = 3
+CURRENT_SCHEMA_VERSION = 4
 
 # Minimum app version that introduced each schema version.
 # Used by the WebUI to warn before rolling back to an incompatible version.
@@ -26,6 +26,7 @@ SCHEMA_VERSION_APP_MAP: dict[int, str] = {
     1: "1.2.0dev1",   # proxy_port rename
     2: "1.3.0dev1",   # transition timeperiod
     3: "1.3.0dev7",   # irrigation section
+    4: "1.5.0dev13",  # WLED effects/palettes → JSON cache
 }
 
 
@@ -230,4 +231,5 @@ def _persist_config_version(config_file: str, version: int) -> None:
 from boneio.core.config.migrations import (
     v1_proxy_port,  # noqa: E402, F401
     v2_transition,  # noqa: E402, F401
+    v4_wled_cache,  # noqa: E402, F401
 )

boneio-1.5.0.dev13/boneio/core/config/migrations/v4_wled_cache.py

@@ -0,0 +1,219 @@
+"""Migration v4: Extract WLED effects/palettes/segments from config to JSON cache.
+
+Before: WLED effects (219 items), palettes (72 items), and segments are stored
+        inline in each remote_device's ``wled`` section inside config.yaml.
+        This causes 3-5 second YAML serialization delays on ARM hardware.
+
+After:  These fields are stripped from config and saved to a lightweight
+        ``.wled_cache.json`` file.  The cache auto-regenerates from WLED API
+        on device connect, so no data is permanently lost.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from pathlib import Path
+
+from boneio.core.config.migrations import register_migration
+
+_LOGGER = logging.getLogger(__name__)
+
+# Fields to strip from each WLED device config — these are device metadata,
+# not user configuration.
+_WLED_CACHE_FIELDS = ("effects", "palettes", "segments")
+
+
+def _persist_wled_cache_strip(config_file: str) -> None:
+    """Strip effects/palettes/segments from WLED devices in the YAML file.
+
+    Reads the config file(s), extracts WLED metadata into a JSON cache,
+    and rewrites the YAML without those bulky lists.
+
+    Args:
+        config_file: Path to the main config.yaml file.
+    """
+    config_dir = Path(config_file).parent
+
+    # First, find and extract WLED data from the in-memory parse
+    # to save into .wled_cache.json before removing from YAML
+    try:
+        from yaml import SafeLoader, load
+
+        class IncludeLoader(SafeLoader):
+            """YAML loader that preserves !include tags."""
+
+        def _include_constructor(
+            loader: IncludeLoader, node: object
+        ) -> object:
+            filename = loader.construct_scalar(node)  # type: ignore[arg-type]
+            return type(
+                "Include", (), {"filename": filename, "tag": "!include"}
+            )()
+
+        IncludeLoader.add_constructor("!include", _include_constructor)
+
+        with open(config_file, encoding="utf-8") as f:
+            config = load(f, Loader=IncludeLoader)  # noqa: S506
+
+        if not config:
+            return
+
+        # Determine where remote_devices lives
+        rd_section = config.get("remote_devices")
+        if rd_section is None:
+            return
+
+        # If it's an !include, load the included file
+        if hasattr(rd_section, "tag") and rd_section.tag == "!include":
+            include_path = config_dir / rd_section.filename
+            if include_path.exists():
+                with open(include_path, encoding="utf-8") as f:
+                    rd_list = load(f, Loader=SafeLoader)  # noqa: S506
+                _strip_wled_fields_from_file(include_path, rd_list, config_dir)
+            return
+
+        # Inline remote_devices — strip from main config file
+        if isinstance(rd_section, list):
+            _strip_wled_fields_from_file(
+                Path(config_file), rd_section, config_dir
+            )
+
+    except Exception as exc:
+        _LOGGER.error("Failed to strip WLED cache fields from file: %s", exc)
+
+
+def _strip_wled_fields_from_file(
+    yaml_path: Path, devices: list[dict] | None, config_dir: Path
+) -> None:
+    """Extract WLED metadata to JSON cache, then strip from YAML file.
+
+    Args:
+        yaml_path: Path to the YAML file containing remote_devices.
+        devices: Parsed list of remote device dicts.
+        config_dir: Config directory for placing the cache file.
+    """
+    if not devices:
+        return
+
+    # Extract cache data
+    cache_data: dict[str, dict[str, list[dict[str, str | int]]]] = {}
+    has_data = False
+
+    for device in devices:
+        if not isinstance(device, dict):
+            continue
+        wled = device.get("wled")
+        if not isinstance(wled, dict):
+            continue
+
+        device_id = device.get("id", "")
+        if not device_id:
+            continue
+
+        device_cache: dict[str, list[dict[str, str | int]]] = {}
+        for field in _WLED_CACHE_FIELDS:
+            if field in wled and isinstance(wled[field], list) and wled[field]:
+                device_cache[field] = wled[field]
+                has_data = True
+        if device_cache:
+            cache_data[device_id] = device_cache
+
+    # Save extracted data to JSON cache
+    if has_data:
+        cache_path = config_dir / ".wled_cache.json"
+        try:
+            # Merge with existing cache (other migrations may have run)
+            existing: dict[str, dict[str, list[dict[str, str | int]]]] = {}
+            if cache_path.exists():
+                with open(cache_path, encoding="utf-8") as f:
+                    existing = json.load(f)
+
+            existing.update(cache_data)
+
+            with open(cache_path, "w", encoding="utf-8") as f:
+                json.dump(existing, f, indent=2, ensure_ascii=False)
+
+            _LOGGER.info(
+                "Saved WLED metadata for %d device(s) to %s",
+                len(cache_data),
+                cache_path,
+            )
+        except Exception as exc:
+            _LOGGER.warning("Failed to write WLED cache: %s", exc)
+
+    # Now strip the fields from the YAML file using regex
+    # This is safer than re-serializing the entire file
+    with open(yaml_path, encoding="utf-8") as f:
+        content = f.read()
+
+    original_content = content
+
+    # Remove effects/palettes/segments blocks from YAML
+    # Pattern: indented key followed by a list of dicts
+    for field in _WLED_CACHE_FIELDS:
+        # Match the field key line and all following lines that are more indented
+        # or are list items (- ) at deeper indent
+        pattern = re.compile(
+            rf"^( +){field}:\s*\n"        # field key line
+            rf"((?:\1 .+\n|\1- .+\n)*)",  # indented content below
+            re.MULTILINE,
+        )
+        content = pattern.sub("", content)
+
+    if content != original_content:
+        with open(yaml_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        _LOGGER.info(
+            "Stripped WLED cache fields from %s (saved %d bytes)",
+            yaml_path.name,
+            len(original_content) - len(content),
+        )
+
+
+@register_migration(
+    version=4,
+    name="Extract WLED effects/palettes/segments to JSON cache",
+    migrate_file=_persist_wled_cache_strip,
+)
+def migrate(doc: dict) -> dict:
+    """Strip effects, palettes, and segments from remote_devices in memory.
+
+    These fields are device metadata auto-discovered from the WLED API,
+    not user configuration.  Storing them in config.yaml causes slow saves
+    on ARM hardware due to YAML serialization overhead (~64KB per 7 devices).
+
+    After migration, this data lives in ``.wled_cache.json`` and is
+    auto-populated from the WLED API on device connect.
+
+    Args:
+        doc: Raw config dict.
+
+    Returns:
+        Migrated config dict with WLED metadata fields removed.
+    """
+    remote_devices = doc.get("remote_devices")
+    if not isinstance(remote_devices, list):
+        return doc
+
+    for device in remote_devices:
+        if not isinstance(device, dict):
+            continue
+        wled = device.get("wled")
+        if not isinstance(wled, dict):
+            continue
+
+        for field in _WLED_CACHE_FIELDS:
+            if field in wled:
+                items = wled[field]
+                count = len(items) if isinstance(items, list) else 0
+                _LOGGER.info(
+                    "Stripping wled.%s (%d items) from device '%s'",
+                    field,
+                    count,
+                    device.get("id", "?"),
+                )
+                del wled[field]
+
+    return doc

{boneio-1.5.0.dev11 → boneio-1.5.0.dev13}/boneio/core/config/yaml_util.py

@@ -1246,6 +1246,18 @@ def update_config_section(config_file: str, section: str, data: dict | list) ->
                         with contextlib.suppress(ValueError):
                             entry["address"] = int(addr, 10)
 
+    # Strip WLED device metadata (effects/palettes/segments) from remote_devices.
+    # These are auto-discovered from WLED API and cached in .wled_cache.json,
+    # NOT stored in config.yaml (defense in depth).
+    if section == "remote_devices" and isinstance(data, list):
+        _wled_cache_fields = ("effects", "palettes", "segments")
+        for entry in data:
+            if isinstance(entry, dict):
+                wled = entry.get("wled")
+                if isinstance(wled, dict):
+                    for field in _wled_cache_fields:
+                        wled.pop(field, None)
+
     # Strip default values to keep YAML clean
     cleaned_data = strip_default_values(data, {}, section)
     _LOGGER.info(f"Cleaned data (defaults removed): {cleaned_data}")

{boneio-1.5.0.dev11 → boneio-1.5.0.dev13}/boneio/core/manager/inputs.py

@@ -801,16 +801,18 @@ class InputManager:
         # Send event to MQTT for Home Assistant
         self._publish_input_event_to_mqtt(input_instance, event)
 
-        # Route to template entities (gate covers, alarm panels)
-        # This must happen before the publish_only check so initial state
-        # sync events reach gate covers and alarm panels.
-        self._manager.templates.on_input_event(event.entity_id, event.click_type)
-
-        # If publish_only is set, skip action execution (used for initial state sync)
+        # If publish_only is set, skip action execution AND template routing.
+        # publish_only events come from initial state sync (binary_sensor
+        # initial_send) — routing them to gate covers would cause spurious
+        # state transitions that trigger HA automations on every restart.
+        # Gate covers read sensor state silently during their own start().
         if event.publish_only:
-            _LOGGER.debug("Skipping action execution for %s (publish_only=True)", event.entity_id)
+            _LOGGER.debug("Skipping actions and template routing for %s (publish_only=True)", event.entity_id)
             return
 
+        # Route to template entities (gate covers, alarm panels)
+        self._manager.templates.on_input_event(event.entity_id, event.click_type)
+
         # Cancel pending delayed actions if this event matches delay_cancel_on
         # Check ALL click types' actions for delay_cancel_on (not just current click_type)
         self._cancel_delayed_if_matching(input_instance, event.entity_id, event.click_type)

{boneio-1.5.0.dev11 → boneio-1.5.0.dev13}/boneio/core/manager/remote.py

@@ -473,7 +473,11 @@ class RemoteDeviceManager:
                 action=action,
             )
 
-        # For WLED devices, use HTTP JSON API
+        # For WLED devices, use fire-and-forget HTTP JSON API.
+        # WLED HTTP requests can stall for seconds when the device is
+        # unreachable (DNS timeout on .local), which blocks the EventBus
+        # worker and freezes ALL input events.  Fire-and-forget schedules
+        # the request as a background task so the caller returns immediately.
         if device.protocol == RemoteDeviceProtocol.WLED:
             _LOGGER.debug("Controlling WLED '%s' segment '%s' on device '%s'", output_id, action, device_id)
             # Parse segment_id - "main" means whole device, otherwise it's segment ID
@@ -482,7 +486,9 @@ class RemoteDeviceManager:
             wled_rgb: tuple[int, int, int] | None = None
             if rgb and len(rgb) >= 3:
                 wled_rgb = (rgb[0], rgb[1], rgb[2])
-            return await cast(Any, device).control_light(
+            from boneio.core.remote.wled import WLEDRemoteDevice
+            wled_device = cast(WLEDRemoteDevice, device)
+            wled_device.control_light_fire_and_forget(
                 segment_id=segment_id,
                 action=action,
                 brightness=brightness,
@@ -494,6 +500,7 @@ class RemoteDeviceManager:
                 effect_speed=effect_speed,
                 effect_intensity=effect_intensity,
             )
+            return True  # Optimistic: task is scheduled
 
         # For MQTT devices, use standard control_output
         return await device.control_output(

{boneio-1.5.0.dev11 → boneio-1.5.0.dev13}/boneio/core/manager/templates/__init__.py

@@ -145,6 +145,9 @@ class TemplateManager:
         for alarm in self._alarms.items:
             await alarm.start()
         for gate in self._gates.items:
+            # Sync sensor state silently before start() publishes state.
+            # Done here (not in configure()) because GPIO manager is now running.
+            self._gates.sync_initial_state(gate)
             await gate.start()
         _LOGGER.info("TemplateManager started all entities")
 
@@ -242,6 +245,7 @@ class TemplateManager:
                 continue
             gate = self._gates.get(eid)
             if gate:
+                self._gates.sync_initial_state(gate)
                 await gate.start()
 
         # Re-register all sensor EventBus listeners (clean slate)

{boneio-1.5.0.dev11 → boneio-1.5.0.dev13}/boneio/core/manager/templates/gate_cover.py

@@ -143,10 +143,6 @@ class GateCoverManager:
                     self._input_map[sensor_id] = []
                 self._input_map[sensor_id].append(gate)
 
-        # Read current sensor states to set correct initial gate state.
-        # Without this, gate defaults to CLOSED which may be wrong.
-        self._sync_initial_state(closed_sensor_id, open_sensor_id)
-
         # Publish HA discovery
         self._publish_discovery(gate)
 
@@ -159,23 +155,69 @@ class GateCoverManager:
 
     def _sync_initial_state(
         self,
+        gate: BoneIOGateCover,
         closed_sensor_id: str | None,
         open_sensor_id: str | None,
     ) -> None:
-        """Sync initial gate state by asking InputManager to re-send sensor states.
+        """Read current sensor GPIO state and set gate cover's initial state.
 
-        Delegates to InputManager.send_current_state_for_input() which reads
-        live GPIO and fires an EventBus event. The gate cover's event listener
-        picks it up automatically — no direct GPIO access needed here.
+        Reads the binary sensor's ``is_active`` property directly —
+        no EventBus events are fired, no MQTT messages are published.
+        Gate cover's ``start()`` will publish the correct state later.
 
         Args:
+            gate: The gate cover instance to initialize.
             closed_sensor_id: ID of the closed contact sensor (or None).
             open_sensor_id: ID of the open contact sensor (or None).
         """
+        from boneio.components.input.binary_sensor import GpioInputBinarySensor
+        from boneio.components.template.gate_cover import CYCLE_CLOSE, CYCLE_OPEN
+        from boneio.const import CLOSED, IDLE, OPEN
+
         input_mgr = self._manager.inputs
-        for sensor_id in (closed_sensor_id, open_sensor_id):
-            if sensor_id:
-                input_mgr.send_current_state_for_input(sensor_id)
+
+        if closed_sensor_id:
+            sensor = input_mgr._inputs.get(closed_sensor_id)
+            if sensor and isinstance(sensor, GpioInputBinarySensor):
+                is_closed = sensor.is_active
+                _LOGGER.debug(
+                    "Gate %s: initial closed_sensor %s is_active=%s",
+                    gate.id, closed_sensor_id, is_closed,
+                )
+                if is_closed:
+                    gate._state = CLOSED
+                    gate._current_operation = IDLE
+                    gate._cycle_next = CYCLE_OPEN
+                elif not gate._has_open_sensor:
+                    gate._state = OPEN
+                    gate._current_operation = IDLE
+
+        if open_sensor_id:
+            sensor = input_mgr._inputs.get(open_sensor_id)
+            if sensor and isinstance(sensor, GpioInputBinarySensor):
+                is_open = sensor.is_active
+                _LOGGER.debug(
+                    "Gate %s: initial open_sensor %s is_active=%s",
+                    gate.id, open_sensor_id, is_open,
+                )
+                if is_open:
+                    gate._state = OPEN
+                    gate._current_operation = IDLE
+                    gate._cycle_next = CYCLE_CLOSE
+
+    def sync_initial_state(self, gate: BoneIOGateCover) -> None:
+        """Public entry point for setting gate's initial state from sensor GPIO.
+
+        Called by TemplateManager during start() when GPIO manager is ready.
+
+        Args:
+            gate: Gate cover to sync.
+        """
+        self._sync_initial_state(
+            gate,
+            gate._closed_sensor_id,
+            gate._open_sensor_id,
+        )
 
     # -- Removal -------------------------------------------------------------
 

{boneio-1.5.0.dev11 → boneio-1.5.0.dev13}/boneio/core/manager/templates.py

@@ -17,9 +17,9 @@ from boneio.components.template.alarm_panel import (
     BoneIOAlarmPanel,
     ZoneInput,
 )
-from boneio.components.template.gate_cover import BoneIOGateCover
+from boneio.components.template.gate_cover import BoneIOGateCover, CYCLE_CLOSE, CYCLE_OPEN
 from boneio.components.template.thermostat import BoneIOThermostat
-from boneio.const import ALARM_CONTROL_PANEL, CLIMATE, COVER
+from boneio.const import ALARM_CONTROL_PANEL, CLIMATE, CLOSED, COVER, IDLE, OPEN
 from boneio.core.utils.timeperiod import parse_time_to_ms, parse_time_to_seconds
 
 if TYPE_CHECKING:
@@ -365,7 +365,7 @@ class TemplateManager:
 
         # Read current sensor states to set correct initial gate state.
         # Without this, gate defaults to CLOSED which may be wrong.
-        self._sync_gate_initial_state(closed_sensor_id, open_sensor_id)
+        self._sync_gate_initial_state(gate, closed_sensor_id, open_sensor_id)
 
         # Publish HA discovery
         self._publish_gate_cover_discovery(gate)
@@ -379,23 +379,53 @@ class TemplateManager:
 
     def _sync_gate_initial_state(
         self,
+        gate: BoneIOGateCover,
         closed_sensor_id: str | None,
         open_sensor_id: str | None,
     ) -> None:
-        """Sync initial gate state by asking InputManager to re-send sensor states.
+        """Read current sensor GPIO state and set gate cover's initial state.
 
-        Delegates to InputManager.send_current_state_for_input() which reads
-        live GPIO and fires an EventBus event. The gate cover's event listener
-        picks it up automatically.
+        Reads the binary sensor's ``is_active`` property directly —
+        no EventBus events are fired, no MQTT messages are published.
+        Gate cover's ``start()`` will publish the correct state later.
 
         Args:
+            gate: The gate cover instance to initialize.
             closed_sensor_id: ID of the closed contact sensor (or None).
             open_sensor_id: ID of the open contact sensor (or None).
         """
+        from boneio.components.input.binary_sensor import GpioInputBinarySensor
+
         input_mgr = self._manager.inputs
-        for sensor_id in (closed_sensor_id, open_sensor_id):
-            if sensor_id:
-                input_mgr.send_current_state_for_input(sensor_id)
+
+        if closed_sensor_id:
+            sensor = input_mgr._inputs.get(closed_sensor_id)
+            if sensor and isinstance(sensor, GpioInputBinarySensor):
+                is_closed = sensor.is_active
+                _LOGGER.debug(
+                    "Gate %s: initial closed_sensor %s is_active=%s",
+                    gate.id, closed_sensor_id, is_closed,
+                )
+                if is_closed:
+                    gate._state = CLOSED
+                    gate._current_operation = IDLE
+                    gate._cycle_next = CYCLE_OPEN
+                elif not gate._has_open_sensor:
+                    gate._state = OPEN
+                    gate._current_operation = IDLE
+
+        if open_sensor_id:
+            sensor = input_mgr._inputs.get(open_sensor_id)
+            if sensor and isinstance(sensor, GpioInputBinarySensor):
+                is_open = sensor.is_active
+                _LOGGER.debug(
+                    "Gate %s: initial open_sensor %s is_active=%s",
+                    gate.id, open_sensor_id, is_open,
+                )
+                if is_open:
+                    gate._state = OPEN
+                    gate._current_operation = IDLE
+                    gate._cycle_next = CYCLE_CLOSE
 
     # -- HA Discovery --------------------------------------------------------
 

{boneio-1.5.0.dev11 → boneio-1.5.0.dev13}/boneio/core/remote/wled.py

@@ -169,10 +169,25 @@ class WLEDRemoteDevice(RemoteDevice):
             _LOGGER.debug("Closed session for WLED '%s'", self._name)
     
     async def _get_session(self) -> aiohttp.ClientSession:
-        """Get or create aiohttp session."""
+        """Get or create aiohttp session.
+
+        Uses ``ThreadedResolver`` (system ``getaddrinfo`` via NSS) so that
+        mDNS ``.local`` hostnames are resolved correctly through Avahi.
+        The default aiohttp resolver (``AsyncResolver`` / c-ares) bypasses
+        NSS entirely, causing ``Name or service not known`` errors for
+        ``.local`` names even when ``ping`` from the same host works fine.
+
+        Timeout is kept short (3s total, 2s connect) so that unreachable
+        devices do not block the caller.
+        """
         if self._session is None or self._session.closed:
-            timeout = aiohttp.ClientTimeout(total=10)
-            self._session = aiohttp.ClientSession(timeout=timeout)
+            timeout = aiohttp.ClientTimeout(total=3, connect=2)
+            resolver = aiohttp.resolver.ThreadedResolver()
+            connector = aiohttp.TCPConnector(resolver=resolver)
+            self._session = aiohttp.ClientSession(
+                timeout=timeout,
+                connector=connector,
+            )
         return self._session
     
     async def _send_state(self, state: dict[str, Any]) -> bool:
@@ -366,6 +381,34 @@ class WLEDRemoteDevice(RemoteDevice):
         )
         
         return await self._send_state(state)
+
+    def control_light_fire_and_forget(
+        self,
+        **kwargs: Any,
+    ) -> None:
+        """Schedule ``control_light`` as a background task.
+
+        Use this when the caller must not be blocked by network I/O
+        (e.g. when called from the EventBus action handler).  The task
+        runs independently; failures are logged but do not propagate.
+
+        Args:
+            **kwargs: Forwarded to :meth:`control_light`.
+        """
+        asyncio.create_task(
+            self._control_light_safe(**kwargs),
+            name=f"wled_ff_{self._id}",
+        )
+
+    async def _control_light_safe(self, **kwargs: Any) -> None:
+        """Wrapper that catches all exceptions so fire-and-forget tasks never crash."""
+        try:
+            await self.control_light(**kwargs)
+        except Exception as exc:
+            _LOGGER.error(
+                "WLED fire-and-forget failed for '%s': %s",
+                self._name, exc,
+            )
     
     async def control_output(
         self,
@@ -487,12 +530,24 @@ class WLEDRemoteDevice(RemoteDevice):
                 # Update internal segments list
                 self._segments = segments
                 
+                # Persist effects/palettes/segments to JSON cache
+                # (they are no longer stored in config.yaml)
+                from boneio.core.remote.wled_cache import update_device_metadata
+                update_device_metadata(
+                    self._id,
+                    effects=effects,
+                    palettes=palettes,
+                    segments=segments,
+                )
+                
                 _LOGGER.info(
-                    "Discovered WLED '%s' v%s with %d segments, %d LEDs",
+                    "Discovered WLED '%s' v%s with %d segments, %d LEDs, %d effects, %d palettes",
                     self._device_info["name"],
                     self._device_info["version"],
                     len(segments),
-                    self._device_info["led_count"]
+                    self._device_info["led_count"],
+                    len(effects),
+                    len(palettes),
                 )
                 
                 return self._device_info