alexei.dolgolyov
67da014684
- Rewrite integration to target-centric model: each picture target becomes a HA device under a server hub with switch, FPS, and status sensors - Replace KC light entities with color sensors (hex state + RGB attributes) for better automation support via WebSocket real-time updates - Add WebSocket manager for Key Colors color streaming - Add KC per-stage timing metrics (calc_colors, broadcast) with rolling avg - Fix KC timing fields missing from API by adding them to Pydantic schema - Make start/stop processing idempotent to prevent intermittent 404 errors - Add HAOS localization support (en, ru) using translation_key system - Rename integration from "WLED Screen Controller" to "LED Screen Controller" - Remove obsolete select.py (display select) and README.md Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
110 lines
3.6 KiB
Python
110 lines
3.6 KiB
Python
"""Switch platform for LED Screen Controller."""
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from typing import Any
|
|
|
|
from homeassistant.components.switch import SwitchEntity
|
|
from homeassistant.config_entries import ConfigEntry
|
|
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
|
|
from .coordinator import WLEDScreenControllerCoordinator
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
|
|
async def async_setup_entry(
|
|
hass: HomeAssistant,
|
|
entry: ConfigEntry,
|
|
async_add_entities: AddEntitiesCallback,
|
|
) -> None:
|
|
"""Set up LED Screen Controller switches."""
|
|
data = hass.data[DOMAIN][entry.entry_id]
|
|
coordinator: WLEDScreenControllerCoordinator = data[DATA_COORDINATOR]
|
|
|
|
entities = []
|
|
if coordinator.data and "targets" in coordinator.data:
|
|
for target_id, target_data in coordinator.data["targets"].items():
|
|
entities.append(
|
|
WLEDScreenControllerSwitch(coordinator, target_id, entry.entry_id)
|
|
)
|
|
|
|
async_add_entities(entities)
|
|
|
|
|
|
class WLEDScreenControllerSwitch(CoordinatorEntity, SwitchEntity):
|
|
"""Representation of a LED Screen Controller target processing switch."""
|
|
|
|
_attr_has_entity_name = True
|
|
|
|
def __init__(
|
|
self,
|
|
coordinator: WLEDScreenControllerCoordinator,
|
|
target_id: str,
|
|
entry_id: str,
|
|
) -> None:
|
|
"""Initialize the switch."""
|
|
super().__init__(coordinator)
|
|
self._target_id = target_id
|
|
self._entry_id = entry_id
|
|
self._attr_unique_id = f"{target_id}_processing"
|
|
self._attr_translation_key = "processing"
|
|
self._attr_icon = "mdi:television-ambient-light"
|
|
|
|
@property
|
|
def device_info(self) -> dict[str, Any]:
|
|
"""Return device information."""
|
|
return {"identifiers": {(DOMAIN, self._target_id)}}
|
|
|
|
@property
|
|
def is_on(self) -> bool:
|
|
"""Return true if processing is active."""
|
|
target_data = self._get_target_data()
|
|
if not target_data or not target_data.get("state"):
|
|
return False
|
|
return target_data["state"].get("processing", False)
|
|
|
|
@property
|
|
def available(self) -> bool:
|
|
"""Return if entity is available."""
|
|
return self._get_target_data() is not None
|
|
|
|
@property
|
|
def extra_state_attributes(self) -> dict[str, Any]:
|
|
"""Return additional state attributes."""
|
|
target_data = self._get_target_data()
|
|
if not target_data:
|
|
return {}
|
|
|
|
attrs: dict[str, Any] = {"target_id": self._target_id}
|
|
state = target_data.get("state") or {}
|
|
metrics = target_data.get("metrics") or {}
|
|
|
|
if state:
|
|
attrs["fps_target"] = state.get("fps_target")
|
|
attrs["fps_actual"] = state.get("fps_actual")
|
|
|
|
if metrics:
|
|
attrs["frames_processed"] = metrics.get("frames_processed")
|
|
attrs["errors_count"] = metrics.get("errors_count")
|
|
attrs["uptime_seconds"] = metrics.get("uptime_seconds")
|
|
|
|
return attrs
|
|
|
|
async def async_turn_on(self, **kwargs: Any) -> None:
|
|
"""Start processing."""
|
|
await self.coordinator.start_processing(self._target_id)
|
|
|
|
async def async_turn_off(self, **kwargs: Any) -> None:
|
|
"""Stop processing."""
|
|
await self.coordinator.stop_processing(self._target_id)
|
|
|
|
def _get_target_data(self) -> dict[str, Any] | None:
|
|
"""Get target data from coordinator."""
|
|
if not self.coordinator.data:
|
|
return None
|
|
return self.coordinator.data.get("targets", {}).get(self._target_id)
|