fix: HA light target — brightness source, transition=0, dashboard type label

- Add brightness_value_source_id to HALightOutputTarget model, to_dict,
  from_dict, update_fields, register_with_manager, API response
- Wire value stream in HALightTargetProcessor: acquire/release on
  start/stop, multiply brightness in _update_lights loop
- Fix transition=0 not saving (parseFloat("0") || 0.5 was falsy)
- Fix dashboard showing "Key Colors" for HA targets — now "Home Assistant"
- Fix dashboard FPS showing 0/2 — HA targets show target/target
- Add CSS source subtitle to HA target dashboard cards

custom_components/wled_screen_controller/__init__.py

@@ -1,4 +1,5 @@
 """The LED Screen Controller integration."""
+
 from __future__ import annotations
 
 import logging
@@ -18,14 +19,12 @@ from .const import (
     CONF_SERVER_URL,
     CONF_API_KEY,
     DEFAULT_SCAN_INTERVAL,
-    TARGET_TYPE_KEY_COLORS,
+    TARGET_TYPE_HA_LIGHT,
     DATA_COORDINATOR,
-    DATA_WS_MANAGER,
     DATA_EVENT_LISTENER,
 )
 from .coordinator import WLEDScreenControllerCoordinator
 from .event_listener import EventStreamListener
-from .ws_manager import KeyColorsWebSocketManager
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -56,8 +55,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     await coordinator.async_config_entry_first_refresh()
 
-    ws_manager = KeyColorsWebSocketManager(hass, server_url, api_key)
-
     event_listener = EventStreamListener(hass, server_url, api_key, coordinator)
     await event_listener.start()
 
@@ -68,11 +65,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         for target_id, target_data in coordinator.data["targets"].items():
             info = target_data["info"]
             target_type = info.get("target_type", "led")
-            model = (
-                "Key Colors Target"
-                if target_type == TARGET_TYPE_KEY_COLORS
-                else "LED Target"
-            )
+            if target_type == TARGET_TYPE_HA_LIGHT:
+                model = "HA Light Target"
+            else:
+                model = "LED Target"
             device_registry.async_get_or_create(
                 config_entry_id=entry.entry_id,
                 identifiers={(DOMAIN, target_id)},
@@ -98,9 +94,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         current_identifiers.add(scenes_identifier)
 
     # Remove devices for targets that no longer exist
-    for device_entry in dr.async_entries_for_config_entry(
-        device_registry, entry.entry_id
-    ):
+    for device_entry in dr.async_entries_for_config_entry(device_registry, entry.entry_id):
         if not device_entry.identifiers & current_identifiers:
             _LOGGER.info("Removing stale device: %s", device_entry.name)
             device_registry.async_remove_device(device_entry.id)
@@ -109,20 +103,17 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     hass.data.setdefault(DOMAIN, {})
     hass.data[DOMAIN][entry.entry_id] = {
         DATA_COORDINATOR: coordinator,
-        DATA_WS_MANAGER: ws_manager,
         DATA_EVENT_LISTENER: event_listener,
     }
 
     # Track target and scene IDs to detect changes
-    known_target_ids = set(
-        coordinator.data.get("targets", {}).keys() if coordinator.data else []
-    )
+    known_target_ids = set(coordinator.data.get("targets", {}).keys() if coordinator.data else [])
     known_scene_ids = set(
         p["id"] for p in (coordinator.data.get("scene_presets", []) if coordinator.data else [])
     )
 
     def _on_coordinator_update() -> None:
-        """Manage WS connections and detect target list changes."""
+        """Detect target/scene list changes and trigger reload."""
         nonlocal known_target_ids, known_scene_ids
 
         if not coordinator.data:
@@ -130,30 +121,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
         targets = coordinator.data.get("targets", {})
 
-        # Start/stop WS connections for KC targets based on processing state
-        for target_id, target_data in targets.items():
-            info = target_data.get("info", {})
-            state = target_data.get("state") or {}
-            if info.get("target_type") == TARGET_TYPE_KEY_COLORS:
-                if state.get("processing"):
-                    if target_id not in ws_manager._connections:
-                        hass.async_create_task(ws_manager.start_listening(target_id))
-                else:
-                    if target_id in ws_manager._connections:
-                        hass.async_create_task(ws_manager.stop_listening(target_id))
-
         # Reload if target or scene list changed
         current_ids = set(targets.keys())
-        current_scene_ids = set(
-            p["id"] for p in coordinator.data.get("scene_presets", [])
-        )
+        current_scene_ids = set(p["id"] for p in coordinator.data.get("scene_presets", []))
         if current_ids != known_target_ids or current_scene_ids != known_scene_ids:
             known_target_ids = current_ids
             known_scene_ids = current_scene_ids
             _LOGGER.info("Target or scene list changed, reloading integration")
-            hass.async_create_task(
-                hass.config_entries.async_reload(entry.entry_id)
-            )
+            hass.async_create_task(hass.config_entries.async_reload(entry.entry_id))
 
     coordinator.async_add_listener(_on_coordinator_update)
 
@@ -167,9 +142,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             coord = entry_data.get(DATA_COORDINATOR)
             if not coord or not coord.data:
                 continue
-            source_ids = {
-                s["id"] for s in coord.data.get("css_sources", [])
-            }
+            source_ids = {s["id"] for s in coord.data.get("css_sources", [])}
             if source_id in source_ids:
                 await coord.push_segments(source_id, segments)
                 return
@@ -180,10 +153,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             DOMAIN,
             "set_leds",
             handle_set_leds,
-            schema=vol.Schema({
-                vol.Required("source_id"): str,
-                vol.Required("segments"): list,
-            }),
+            schema=vol.Schema(
+                {
+                    vol.Required("source_id"): str,
+                    vol.Required("segments"): list,
+                }
+            ),
         )
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
@@ -194,7 +169,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     entry_data = hass.data[DOMAIN][entry.entry_id]
-    await entry_data[DATA_WS_MANAGER].shutdown()
     await entry_data[DATA_EVENT_LISTENER].shutdown()
 
     unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

custom_components/wled_screen_controller/const.py

@@ -15,9 +15,8 @@ WS_MAX_RECONNECT_DELAY = 60  # seconds
 
 # Target types
 TARGET_TYPE_LED = "led"
-TARGET_TYPE_KEY_COLORS = "key_colors"
+TARGET_TYPE_HA_LIGHT = "ha_light"
 
 # Data keys stored in hass.data[DOMAIN][entry_id]
 DATA_COORDINATOR = "coordinator"
-DATA_WS_MANAGER = "ws_manager"
 DATA_EVENT_LISTENER = "event_listener"

custom_components/wled_screen_controller/coordinator.py

@@ -1,4 +1,5 @@
 """Data update coordinator for LED Screen Controller."""
+
 from __future__ import annotations
 
 import asyncio
@@ -14,7 +15,6 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 from .const import (
     DOMAIN,
     DEFAULT_TIMEOUT,
-    TARGET_TYPE_KEY_COLORS,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -74,27 +74,12 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
                         state = None
                         metrics = None
 
-                    result: dict[str, Any] = {
+                    return target_id, {
                         "info": target,
                         "state": state,
                         "metrics": metrics,
                     }
 
-                    # Fetch rectangles for key_colors targets
-                    if target.get("target_type") == TARGET_TYPE_KEY_COLORS:
-                        kc_settings = target.get("key_colors_settings") or {}
-                        template_id = kc_settings.get("pattern_template_id", "")
-                        if template_id:
-                            result["rectangles"] = await self._fetch_rectangles(
-                                template_id
-                            )
-                        else:
-                            result["rectangles"] = []
-                    else:
-                        result["rectangles"] = []
-
-                    return target_id, result
-
                 results = await asyncio.gather(
                     *(fetch_target_data(t) for t in targets_list),
                     return_exceptions=True,
@@ -108,13 +93,11 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
                     targets_data[target_id] = data
 
                 # Fetch devices, CSS sources, value sources, and scene presets in parallel
-                devices_data, css_sources, value_sources, scene_presets = (
-                    await asyncio.gather(
-                        self._fetch_devices(),
-                        self._fetch_css_sources(),
-                        self._fetch_value_sources(),
-                        self._fetch_scene_presets(),
-                    )
+                devices_data, css_sources, value_sources, scene_presets = await asyncio.gather(
+                    self._fetch_devices(),
+                    self._fetch_css_sources(),
+                    self._fetch_value_sources(),
+                    self._fetch_scene_presets(),
                 )
 
                 return {
@@ -176,23 +159,6 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
             resp.raise_for_status()
             return await resp.json()
 
-    async def _fetch_rectangles(self, template_id: str) -> list[dict]:
-        """Fetch rectangles for a pattern template (no cache — always fresh)."""
-        try:
-            async with self.session.get(
-                f"{self.server_url}/api/v1/pattern-templates/{template_id}",
-                headers=self._auth_headers,
-                timeout=self._timeout,
-            ) as resp:
-                resp.raise_for_status()
-                data = await resp.json()
-                return data.get("rectangles", [])
-        except Exception as err:
-            _LOGGER.warning(
-                "Failed to fetch pattern template %s: %s", template_id, err
-            )
-            return []
-
     async def _fetch_devices(self) -> dict[str, dict[str, Any]]:
         """Fetch all devices with capabilities and brightness."""
         try:
@@ -225,7 +191,8 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
                 except Exception as err:
                     _LOGGER.warning(
                         "Failed to fetch brightness for device %s: %s",
-                        device_id, err,
+                        device_id,
+                        err,
                     )
             return device_id, entry
 
@@ -256,7 +223,9 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
                 body = await resp.text()
                 _LOGGER.error(
                     "Failed to set brightness for device %s: %s %s",
-                    device_id, resp.status, body,
+                    device_id,
+                    resp.status,
+                    body,
                 )
                 resp.raise_for_status()
         await self.async_request_refresh()
@@ -273,25 +242,9 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
                 body = await resp.text()
                 _LOGGER.error(
                     "Failed to set color for device %s: %s %s",
-                    device_id, resp.status, body,
-                )
-                resp.raise_for_status()
-        await self.async_request_refresh()
-
-    async def set_kc_brightness(self, target_id: str, brightness: int) -> None:
-        """Set brightness for a Key Colors target (0-255 mapped to 0.0-1.0)."""
-        brightness_float = round(brightness / 255, 4)
-        async with self.session.put(
-            f"{self.server_url}/api/v1/output-targets/{target_id}",
-            headers={**self._auth_headers, "Content-Type": "application/json"},
-            json={"key_colors_settings": {"brightness": brightness_float}},
-            timeout=self._timeout,
-        ) as resp:
-            if resp.status != 200:
-                body = await resp.text()
-                _LOGGER.error(
-                    "Failed to set KC brightness for target %s: %s %s",
-                    target_id, resp.status, body,
+                    device_id,
+                    resp.status,
+                    body,
                 )
                 resp.raise_for_status()
         await self.async_request_refresh()
@@ -353,7 +306,9 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
                 body = await resp.text()
                 _LOGGER.error(
                     "Failed to push colors to source %s: %s %s",
-                    source_id, resp.status, body,
+                    source_id,
+                    resp.status,
+                    body,
                 )
                 resp.raise_for_status()
 
@@ -369,7 +324,9 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
                 body = await resp.text()
                 _LOGGER.error(
                     "Failed to push segments to source %s: %s %s",
-                    source_id, resp.status, body,
+                    source_id,
+                    resp.status,
+                    body,
                 )
                 resp.raise_for_status()
 
@@ -384,7 +341,9 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
                 body = await resp.text()
                 _LOGGER.error(
                     "Failed to activate scene %s: %s %s",
-                    preset_id, resp.status, body,
+                    preset_id,
+                    resp.status,
+                    body,
                 )
                 resp.raise_for_status()
         await self.async_request_refresh()
@@ -401,7 +360,9 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
                 body = await resp.text()
                 _LOGGER.error(
                     "Failed to update source %s: %s %s",
-                    source_id, resp.status, body,
+                    source_id,
+                    resp.status,
+                    body,
                 )
                 resp.raise_for_status()
 
@@ -417,7 +378,9 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
                 body = await resp.text()
                 _LOGGER.error(
                     "Failed to update target %s: %s %s",
-                    target_id, resp.status, body,
+                    target_id,
+                    resp.status,
+                    body,
                 )
                 resp.raise_for_status()
         await self.async_request_refresh()
@@ -435,7 +398,9 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
                 body = await resp.text()
                 _LOGGER.error(
                     "Failed to start target %s: %s %s",
-                    target_id, resp.status, body,
+                    target_id,
+                    resp.status,
+                    body,
                 )
                 resp.raise_for_status()
         await self.async_request_refresh()
@@ -453,7 +418,9 @@ class WLEDScreenControllerCoordinator(DataUpdateCoordinator):
                 body = await resp.text()
                 _LOGGER.error(
                     "Failed to stop target %s: %s %s",
-                    target_id, resp.status, body,
+                    target_id,
+                    resp.status,
+                    body,
                 )
                 resp.raise_for_status()
         await self.async_request_refresh()

custom_components/wled_screen_controller/number.py

@@ -1,4 +1,5 @@
-"""Number platform for LED Screen Controller (device & KC target brightness)."""
+"""Number platform for LED Screen Controller (device brightness & HA light settings)."""
+
 from __future__ import annotations
 
 import logging
@@ -10,7 +11,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN, DATA_COORDINATOR, TARGET_TYPE_KEY_COLORS
+from .const import DOMAIN, DATA_COORDINATOR, TARGET_TYPE_HA_LIGHT
 from .coordinator import WLEDScreenControllerCoordinator
 
 _LOGGER = logging.getLogger(__name__)
@@ -21,24 +22,24 @@ async def async_setup_entry(
     entry: ConfigEntry,
     async_add_entities: AddEntitiesCallback,
 ) -> None:
-    """Set up LED Screen Controller brightness numbers."""
+    """Set up LED Screen Controller number entities."""
     data = hass.data[DOMAIN][entry.entry_id]
     coordinator: WLEDScreenControllerCoordinator = data[DATA_COORDINATOR]
 
-    entities = []
+    entities: list[NumberEntity] = []
     if coordinator.data and "targets" in coordinator.data:
         devices = coordinator.data.get("devices") or {}
 
         for target_id, target_data in coordinator.data["targets"].items():
             info = target_data["info"]
+            target_type = info.get("target_type", "led")
 
-            if info.get("target_type") == TARGET_TYPE_KEY_COLORS:
-                # KC target — brightness lives in key_colors_settings
-                entities.append(
-                    WLEDScreenControllerKCBrightness(
-                        coordinator, target_id, entry.entry_id,
-                    )
-                )
+            if target_type == TARGET_TYPE_HA_LIGHT:
+                # HA Light target — expose tunable settings
+                entities.append(HALightUpdateRate(coordinator, target_id, entry.entry_id))
+                entities.append(HALightTransition(coordinator, target_id, entry.entry_id))
+                entities.append(HALightMinBrightness(coordinator, target_id, entry.entry_id))
+                entities.append(HALightColorTolerance(coordinator, target_id, entry.entry_id))
                 continue
 
             # LED target — brightness lives on the device
@@ -56,7 +57,10 @@ async def async_setup_entry(
 
             entities.append(
                 WLEDScreenControllerBrightness(
-                    coordinator, target_id, device_id, entry.entry_id,
+                    coordinator,
+                    target_id,
+                    device_id,
+                    entry.entry_id,
                 )
             )
 
@@ -117,53 +121,113 @@ class WLEDScreenControllerBrightness(CoordinatorEntity, NumberEntity):
         await self.coordinator.set_brightness(self._device_id, int(value))
 
 
-class WLEDScreenControllerKCBrightness(CoordinatorEntity, NumberEntity):
-    """Brightness control for a Key Colors target."""
+# --- HA Light target number entities ---
+
+
+class _HALightNumberBase(CoordinatorEntity, NumberEntity):
+    """Base class for HA Light target number entities."""
 
     _attr_has_entity_name = True
-    _attr_native_min_value = 0
-    _attr_native_max_value = 255
-    _attr_native_step = 1
     _attr_mode = NumberMode.SLIDER
-    _attr_icon = "mdi:brightness-6"
 
     def __init__(
         self,
         coordinator: WLEDScreenControllerCoordinator,
         target_id: str,
         entry_id: str,
+        *,
+        field_name: str,
     ) -> None:
-        """Initialize the KC brightness number."""
         super().__init__(coordinator)
         self._target_id = target_id
         self._entry_id = entry_id
-        self._attr_unique_id = f"{target_id}_brightness"
-        self._attr_translation_key = "brightness"
+        self._field_name = field_name
 
     @property
     def device_info(self) -> dict[str, Any]:
-        """Return device information."""
         return {"identifiers": {(DOMAIN, self._target_id)}}
 
     @property
     def native_value(self) -> float | None:
-        """Return the current brightness value (0-255)."""
-        if not self.coordinator.data:
-            return None
-        target_data = self.coordinator.data.get("targets", {}).get(self._target_id)
+        target_data = self._get_target_data()
         if not target_data:
             return None
-        kc_settings = target_data.get("info", {}).get("key_colors_settings") or {}
-        brightness_float = kc_settings.get("brightness", 1.0)
-        return round(brightness_float * 255)
+        return target_data.get("info", {}).get(self._field_name)
 
     @property
     def available(self) -> bool:
-        """Return if entity is available."""
-        if not self.coordinator.data:
-            return False
-        return self._target_id in self.coordinator.data.get("targets", {})
+        return self._get_target_data() is not None
 
     async def async_set_native_value(self, value: float) -> None:
-        """Set brightness value."""
-        await self.coordinator.set_kc_brightness(self._target_id, int(value))
+        await self.coordinator.update_target(self._target_id, **{self._field_name: round(value, 2)})
+
+    def _get_target_data(self) -> dict[str, Any] | None:
+        if not self.coordinator.data:
+            return None
+        return self.coordinator.data.get("targets", {}).get(self._target_id)
+
+
+class HALightUpdateRate(_HALightNumberBase):
+    """Update rate (Hz) for an HA Light target."""
+
+    _attr_native_min_value = 0.5
+    _attr_native_max_value = 5.0
+    _attr_native_step = 0.5
+    _attr_native_unit_of_measurement = "Hz"
+    _attr_icon = "mdi:update"
+
+    def __init__(
+        self, coordinator: WLEDScreenControllerCoordinator, target_id: str, entry_id: str
+    ) -> None:
+        super().__init__(coordinator, target_id, entry_id, field_name="update_rate")
+        self._attr_unique_id = f"{target_id}_update_rate"
+        self._attr_translation_key = "ha_light_update_rate"
+
+
+class HALightTransition(_HALightNumberBase):
+    """Transition time (seconds) for an HA Light target."""
+
+    _attr_native_min_value = 0.0
+    _attr_native_max_value = 10.0
+    _attr_native_step = 0.1
+    _attr_native_unit_of_measurement = "s"
+    _attr_icon = "mdi:transition-masked"
+
+    def __init__(
+        self, coordinator: WLEDScreenControllerCoordinator, target_id: str, entry_id: str
+    ) -> None:
+        super().__init__(coordinator, target_id, entry_id, field_name="transition")
+        self._attr_unique_id = f"{target_id}_transition"
+        self._attr_translation_key = "ha_light_transition"
+
+
+class HALightMinBrightness(_HALightNumberBase):
+    """Minimum brightness threshold for an HA Light target."""
+
+    _attr_native_min_value = 0
+    _attr_native_max_value = 255
+    _attr_native_step = 1
+    _attr_icon = "mdi:brightness-4"
+
+    def __init__(
+        self, coordinator: WLEDScreenControllerCoordinator, target_id: str, entry_id: str
+    ) -> None:
+        super().__init__(coordinator, target_id, entry_id, field_name="min_brightness_threshold")
+        self._attr_unique_id = f"{target_id}_min_brightness"
+        self._attr_translation_key = "ha_light_min_brightness"
+
+
+class HALightColorTolerance(_HALightNumberBase):
+    """Color tolerance (RGB delta skip threshold) for an HA Light target."""
+
+    _attr_native_min_value = 0
+    _attr_native_max_value = 50
+    _attr_native_step = 1
+    _attr_icon = "mdi:palette-outline"
+
+    def __init__(
+        self, coordinator: WLEDScreenControllerCoordinator, target_id: str, entry_id: str
+    ) -> None:
+        super().__init__(coordinator, target_id, entry_id, field_name="color_tolerance")
+        self._attr_unique_id = f"{target_id}_color_tolerance"
+        self._attr_translation_key = "ha_light_color_tolerance"

custom_components/wled_screen_controller/select.py

@@ -1,4 +1,5 @@
 """Select platform for LED Screen Controller (CSS source & brightness source)."""
+
 from __future__ import annotations
 
 import logging
@@ -10,12 +11,12 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN, DATA_COORDINATOR, TARGET_TYPE_KEY_COLORS
+from .const import DOMAIN, DATA_COORDINATOR, TARGET_TYPE_HA_LIGHT
 from .coordinator import WLEDScreenControllerCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
-NONE_OPTION = "— None —"
+NONE_OPTION = "\u2014 None \u2014"
 
 
 async def async_setup_entry(
@@ -31,23 +32,20 @@ async def async_setup_entry(
     if coordinator.data and "targets" in coordinator.data:
         for target_id, target_data in coordinator.data["targets"].items():
             info = target_data["info"]
+            target_type = info.get("target_type", "led")
 
-            # Only LED targets
-            if info.get("target_type") == TARGET_TYPE_KEY_COLORS:
-                continue
+            # Both LED and HA Light targets have a CSS source
+            entities.append(CSSSourceSelect(coordinator, target_id, entry.entry_id))
 
-            entities.append(
-                CSSSourceSelect(coordinator, target_id, entry.entry_id)
-            )
-            entities.append(
-                BrightnessSourceSelect(coordinator, target_id, entry.entry_id)
-            )
+            # Only LED targets have a brightness value source
+            if target_type != TARGET_TYPE_HA_LIGHT:
+                entities.append(BrightnessSourceSelect(coordinator, target_id, entry.entry_id))
 
     async_add_entities(entities)
 
 
 class CSSSourceSelect(CoordinatorEntity, SelectEntity):
-    """Select entity for choosing a color strip source for an LED target."""
+    """Select entity for choosing a color strip source for a target."""
 
     _attr_has_entity_name = True
     _attr_icon = "mdi:palette"
@@ -100,9 +98,7 @@ class CSSSourceSelect(CoordinatorEntity, SelectEntity):
         if source_id is None:
             _LOGGER.error("CSS source not found: %s", option)
             return
-        await self.coordinator.update_target(
-            self._target_id, color_strip_source_id=source_id
-        )
+        await self.coordinator.update_target(self._target_id, color_strip_source_id=source_id)
 
     def _name_to_id_map(self) -> dict[str, str]:
         sources = (self.coordinator.data or {}).get("css_sources") or []
@@ -165,13 +161,10 @@ class BrightnessSourceSelect(CoordinatorEntity, SelectEntity):
             source_id = ""
         else:
             name_map = {
-                s["name"]: s["id"]
-                for s in (self.coordinator.data or {}).get("value_sources") or []
+                s["name"]: s["id"] for s in (self.coordinator.data or {}).get("value_sources") or []
             }
             source_id = name_map.get(option)
             if source_id is None:
                 _LOGGER.error("Value source not found: %s", option)
                 return
-        await self.coordinator.update_target(
-            self._target_id, brightness_value_source_id=source_id
-        )
+        await self.coordinator.update_target(self._target_id, brightness_value_source_id=source_id)

custom_components/wled_screen_controller/sensor.py

@@ -1,8 +1,8 @@
 """Sensor platform for LED Screen Controller."""
+
 from __future__ import annotations
 
 import logging
-from collections.abc import Callable
 from typing import Any
 
 from homeassistant.components.sensor import (
@@ -17,12 +17,10 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import (
     DOMAIN,
-    TARGET_TYPE_KEY_COLORS,
+    TARGET_TYPE_HA_LIGHT,
     DATA_COORDINATOR,
-    DATA_WS_MANAGER,
 )
 from .coordinator import WLEDScreenControllerCoordinator
-from .ws_manager import KeyColorsWebSocketManager
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -35,34 +33,19 @@ async def async_setup_entry(
     """Set up LED Screen Controller sensors."""
     data = hass.data[DOMAIN][entry.entry_id]
     coordinator: WLEDScreenControllerCoordinator = data[DATA_COORDINATOR]
-    ws_manager: KeyColorsWebSocketManager = data[DATA_WS_MANAGER]
 
     entities: list[SensorEntity] = []
     if coordinator.data and "targets" in coordinator.data:
         for target_id, target_data in coordinator.data["targets"].items():
+            entities.append(WLEDScreenControllerFPSSensor(coordinator, target_id, entry.entry_id))
             entities.append(
-                WLEDScreenControllerFPSSensor(coordinator, target_id, entry.entry_id)
-            )
-            entities.append(
-                WLEDScreenControllerStatusSensor(
-                    coordinator, target_id, entry.entry_id
-                )
+                WLEDScreenControllerStatusSensor(coordinator, target_id, entry.entry_id)
             )
 
-            # Add color sensors for Key Colors targets
+            # Add mapped lights sensor for HA Light targets
             info = target_data["info"]
-            if info.get("target_type") == TARGET_TYPE_KEY_COLORS:
-                rectangles = target_data.get("rectangles", [])
-                for rect in rectangles:
-                    entities.append(
-                        WLEDScreenControllerColorSensor(
-                            coordinator=coordinator,
-                            ws_manager=ws_manager,
-                            target_id=target_id,
-                            rectangle_name=rect["name"],
-                            entry_id=entry.entry_id,
-                        )
-                    )
+            if info.get("target_type") == TARGET_TYPE_HA_LIGHT:
+                entities.append(HALightMappedLightsSensor(coordinator, target_id, entry.entry_id))
 
     async_add_entities(entities)
 
@@ -177,79 +160,58 @@ class WLEDScreenControllerStatusSensor(CoordinatorEntity, SensorEntity):
         return self.coordinator.data.get("targets", {}).get(self._target_id)
 
 
-class WLEDScreenControllerColorSensor(CoordinatorEntity, SensorEntity):
-    """Color sensor reporting the extracted screen color for a Key Colors rectangle."""
+class HALightMappedLightsSensor(CoordinatorEntity, SensorEntity):
+    """Sensor showing the number of mapped HA lights for an HA Light target."""
 
     _attr_has_entity_name = True
-    _attr_icon = "mdi:palette"
+    _attr_icon = "mdi:lightbulb-group"
 
     def __init__(
         self,
         coordinator: WLEDScreenControllerCoordinator,
-        ws_manager: KeyColorsWebSocketManager,
         target_id: str,
-        rectangle_name: str,
         entry_id: str,
     ) -> None:
-        """Initialize the color sensor."""
+        """Initialize the sensor."""
         super().__init__(coordinator)
         self._target_id = target_id
-        self._rectangle_name = rectangle_name
-        self._ws_manager = ws_manager
         self._entry_id = entry_id
-        self._unregister_ws: Callable[[], None] | None = None
-
-        sanitized = rectangle_name.lower().replace(" ", "_").replace("-", "_")
-        self._attr_unique_id = f"{target_id}_{sanitized}_color"
-        self._attr_translation_key = "rectangle_color"
-        self._attr_translation_placeholders = {"rectangle_name": rectangle_name}
+        self._attr_unique_id = f"{target_id}_mapped_lights"
+        self._attr_translation_key = "mapped_lights"
 
     @property
     def device_info(self) -> dict[str, Any]:
         """Return device information."""
         return {"identifiers": {(DOMAIN, self._target_id)}}
 
-    async def async_added_to_hass(self) -> None:
-        """Register WS callback when entity is added."""
-        await super().async_added_to_hass()
-        self._unregister_ws = self._ws_manager.register_callback(
-            self._target_id, self._handle_color_update
-        )
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Unregister WS callback when entity is removed."""
-        if self._unregister_ws:
-            self._unregister_ws()
-            self._unregister_ws = None
-        await super().async_will_remove_from_hass()
-
-    def _handle_color_update(self, colors: dict) -> None:
-        """Handle incoming color update from WebSocket."""
-        if self._rectangle_name in colors:
-            self.async_write_ha_state()
-
     @property
-    def native_value(self) -> str | None:
-        """Return the hex color string (e.g. #FF8800)."""
-        color = self._get_color()
-        if color is None:
+    def native_value(self) -> int | None:
+        """Return the number of mapped lights."""
+        target_data = self._get_target_data()
+        if not target_data:
             return None
-        return f"#{color['r']:02X}{color['g']:02X}{color['b']:02X}"
+        mappings = target_data.get("info", {}).get("light_mappings", [])
+        return len(mappings)
 
     @property
     def extra_state_attributes(self) -> dict[str, Any]:
-        """Return r, g, b, brightness as attributes."""
-        color = self._get_color()
-        if color is None:
+        """Return light mapping details as attributes."""
+        target_data = self._get_target_data()
+        if not target_data:
             return {}
-        r, g, b = color["r"], color["g"], color["b"]
-        brightness = int(0.299 * r + 0.587 * g + 0.114 * b)
+        mappings = target_data.get("info", {}).get("light_mappings", [])
+        entity_ids = [m.get("entity_id", "") for m in mappings]
         return {
-            "r": r,
-            "g": g,
-            "b": b,
-            "brightness": brightness,
-            "rgb_color": [r, g, b],
+            "entity_ids": entity_ids,
+            "mappings": [
+                {
+                    "entity_id": m.get("entity_id", ""),
+                    "led_start": m.get("led_start", 0),
+                    "led_end": m.get("led_end", -1),
+                    "brightness_scale": m.get("brightness_scale", 1.0),
+                }
+                for m in mappings
+            ],
         }
 
     @property
@@ -257,16 +219,6 @@ class WLEDScreenControllerColorSensor(CoordinatorEntity, SensorEntity):
         """Return if entity is available."""
         return self._get_target_data() is not None
 
-    def _get_color(self) -> dict[str, int] | None:
-        """Get the current color for this rectangle from WS manager."""
-        target_data = self._get_target_data()
-        if not target_data or not target_data.get("state"):
-            return None
-        if not target_data["state"].get("processing"):
-            return None
-        colors = self._ws_manager.get_latest_colors(self._target_id)
-        return colors.get(self._rectangle_name)
-
     def _get_target_data(self) -> dict[str, Any] | None:
         if not self.coordinator.data:
             return None

custom_components/wled_screen_controller/strings.json

@@ -54,13 +54,25 @@
           "unavailable": "Unavailable"
         }
       },
-      "rectangle_color": {
-        "name": "{rectangle_name} Color"
+      "mapped_lights": {
+        "name": "Mapped Lights"
       }
     },
     "number": {
       "brightness": {
         "name": "Brightness"
+      },
+      "ha_light_update_rate": {
+        "name": "Update Rate"
+      },
+      "ha_light_transition": {
+        "name": "Transition"
+      },
+      "ha_light_min_brightness": {
+        "name": "Min Brightness"
+      },
+      "ha_light_color_tolerance": {
+        "name": "Color Tolerance"
       }
     },
     "select": {

custom_components/wled_screen_controller/translations/en.json

@@ -54,13 +54,25 @@
           "unavailable": "Unavailable"
         }
       },
-      "rectangle_color": {
-        "name": "{rectangle_name} Color"
+      "mapped_lights": {
+        "name": "Mapped Lights"
       }
     },
     "number": {
       "brightness": {
         "name": "Brightness"
+      },
+      "ha_light_update_rate": {
+        "name": "Update Rate"
+      },
+      "ha_light_transition": {
+        "name": "Transition"
+      },
+      "ha_light_min_brightness": {
+        "name": "Min Brightness"
+      },
+      "ha_light_color_tolerance": {
+        "name": "Color Tolerance"
       }
     },
     "select": {

custom_components/wled_screen_controller/translations/ru.json

@@ -54,13 +54,25 @@
           "unavailable": "Недоступен"
         }
       },
-      "rectangle_color": {
-        "name": "{rectangle_name} Цвет"
+      "mapped_lights": {
+        "name": "Привязанные светильники"
       }
     },
     "number": {
       "brightness": {
         "name": "Яркость"
+      },
+      "ha_light_update_rate": {
+        "name": "Частота обновления"
+      },
+      "ha_light_transition": {
+        "name": "Переход"
+      },
+      "ha_light_min_brightness": {
+        "name": "Мин. яркость"
+      },
+      "ha_light_color_tolerance": {
+        "name": "Допуск цвета"
       }
     },
     "select": {

custom_components/wled_screen_controller/ws_manager.py

@@ -1,136 +0,0 @@
-"""WebSocket connection manager for Key Colors target color streams."""
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import json
-import logging
-from collections.abc import Callable
-from typing import Any
-
-import aiohttp
-
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import WS_RECONNECT_DELAY, WS_MAX_RECONNECT_DELAY
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class KeyColorsWebSocketManager:
-    """Manages WebSocket connections for Key Colors target color streams."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        server_url: str,
-        api_key: str,
-    ) -> None:
-        self._hass = hass
-        self._server_url = server_url
-        self._api_key = api_key
-        self._connections: dict[str, asyncio.Task] = {}
-        self._callbacks: dict[str, list[Callable]] = {}
-        self._latest_colors: dict[str, dict[str, dict[str, int]]] = {}
-        self._shutting_down = False
-
-    def _get_ws_url(self, target_id: str) -> str:
-        """Build WebSocket URL for a target."""
-        ws_base = self._server_url.replace("http://", "ws://").replace(
-            "https://", "wss://"
-        )
-        return f"{ws_base}/api/v1/output-targets/{target_id}/ws?token={self._api_key}"
-
-    async def start_listening(self, target_id: str) -> None:
-        """Start WebSocket connection for a target."""
-        if target_id in self._connections:
-            return
-        task = self._hass.async_create_background_task(
-            self._ws_loop(target_id),
-            f"wled_screen_controller_ws_{target_id}",
-        )
-        self._connections[target_id] = task
-
-    async def stop_listening(self, target_id: str) -> None:
-        """Stop WebSocket connection for a target."""
-        task = self._connections.pop(target_id, None)
-        if task:
-            task.cancel()
-            with contextlib.suppress(asyncio.CancelledError):
-                await task
-        self._latest_colors.pop(target_id, None)
-
-    def register_callback(
-        self, target_id: str, callback: Callable
-    ) -> Callable[[], None]:
-        """Register a callback for color updates. Returns unregister function."""
-        self._callbacks.setdefault(target_id, []).append(callback)
-
-        def unregister() -> None:
-            cbs = self._callbacks.get(target_id)
-            if cbs and callback in cbs:
-                cbs.remove(callback)
-
-        return unregister
-
-    def get_latest_colors(self, target_id: str) -> dict[str, dict[str, int]]:
-        """Get latest colors for a target."""
-        return self._latest_colors.get(target_id, {})
-
-    async def _ws_loop(self, target_id: str) -> None:
-        """WebSocket connection loop with reconnection."""
-        delay = WS_RECONNECT_DELAY
-        session = async_get_clientsession(self._hass)
-
-        while not self._shutting_down:
-            try:
-                url = self._get_ws_url(target_id)
-                async with session.ws_connect(url) as ws:
-                    delay = WS_RECONNECT_DELAY  # reset on successful connect
-                    _LOGGER.debug("WS connected for target %s", target_id)
-                    async for msg in ws:
-                        if msg.type == aiohttp.WSMsgType.TEXT:
-                            self._handle_message(target_id, msg.data)
-                        elif msg.type in (
-                            aiohttp.WSMsgType.CLOSED,
-                            aiohttp.WSMsgType.ERROR,
-                        ):
-                            break
-            except asyncio.CancelledError:
-                raise
-            except (aiohttp.ClientError, asyncio.TimeoutError, OSError) as err:
-                _LOGGER.debug("WS connection error for %s: %s", target_id, err)
-            except Exception as err:
-                _LOGGER.error("Unexpected WS error for %s: %s", target_id, err)
-
-            if self._shutting_down:
-                break
-
-            await asyncio.sleep(delay)
-            delay = min(delay * 2, WS_MAX_RECONNECT_DELAY)
-
-    def _handle_message(self, target_id: str, raw: str) -> None:
-        """Handle incoming WebSocket message."""
-        try:
-            data = json.loads(raw)
-        except json.JSONDecodeError:
-            return
-
-        if data.get("type") != "colors_update":
-            return
-
-        colors: dict[str, Any] = data.get("colors", {})
-        self._latest_colors[target_id] = colors
-
-        for cb in self._callbacks.get(target_id, []):
-            try:
-                cb(colors)
-            except Exception:
-                _LOGGER.exception("Error in WS color callback for %s", target_id)
-
-    async def shutdown(self) -> None:
-        """Stop all WebSocket connections."""
-        self._shutting_down = True
-        for target_id in list(self._connections):
-            await self.stop_listening(target_id)