Add OpenRGB profile select entity

homeassistant/components/openrgb/__init__.py

@@ -2,33 +2,14 @@
 
 from __future__ import annotations
 
-from homeassistant.const import CONF_NAME, Platform
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceEntry
 
 from .const import DOMAIN
 from .coordinator import OpenRGBConfigEntry, OpenRGBCoordinator
 
-PLATFORMS: list[Platform] = [Platform.LIGHT]
-
-
-def _setup_server_device_registry(
-    hass: HomeAssistant, entry: OpenRGBConfigEntry, coordinator: OpenRGBCoordinator
-):
-    """Set up device registry for the OpenRGB SDK server."""
-    device_registry = dr.async_get(hass)
-
-    # Create the parent OpenRGB SDK server device
-    device_registry.async_get_or_create(
-        config_entry_id=entry.entry_id,
-        identifiers={(DOMAIN, entry.entry_id)},
-        name=entry.data[CONF_NAME],
-        model="OpenRGB SDK Server",
-        manufacturer="OpenRGB",
-        sw_version=coordinator.get_client_protocol_version(),
-        entry_type=dr.DeviceEntryType.SERVICE,
-    )
+PLATFORMS: list[Platform] = [Platform.LIGHT, Platform.SELECT]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: OpenRGBConfigEntry) -> bool:
@@ -37,8 +18,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: OpenRGBConfigEntry) -> b
 
     await coordinator.async_config_entry_first_refresh()
 
-    _setup_server_device_registry(hass, entry, coordinator)
-
     entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)

homeassistant/components/openrgb/const.py

@@ -13,6 +13,8 @@
 
 DOMAIN = "openrgb"
 
+UID_SEPARATOR = "||"
+
 # Defaults
 DEFAULT_PORT = 6742
 DEFAULT_CLIENT_NAME = "Home Assistant"

homeassistant/components/openrgb/coordinator.py

@@ -14,7 +14,13 @@
 from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import CONNECTION_ERRORS, DEFAULT_CLIENT_NAME, DOMAIN, SCAN_INTERVAL
+from .const import (
+    CONNECTION_ERRORS,
+    DEFAULT_CLIENT_NAME,
+    DOMAIN,
+    SCAN_INTERVAL,
+    UID_SEPARATOR,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -111,7 +117,7 @@ def _get_device_key(self, device: Device) -> str:
             device.metadata.location or "none",
         )
         # Double pipe is readable and is unlikely to appear in metadata
-        return "||".join(parts)
+        return UID_SEPARATOR.join(parts)
 
     async def async_client_disconnect(self, *args) -> None:
         """Disconnect the OpenRGB client."""

homeassistant/components/openrgb/select.py

@@ -0,0 +1,121 @@
+"""Select platform for OpenRGB integration."""
+
+from __future__ import annotations
+
+from homeassistant.components.select import SelectEntity
+from homeassistant.const import CONF_NAME
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import CONNECTION_ERRORS, DOMAIN, UID_SEPARATOR
+from .coordinator import OpenRGBConfigEntry, OpenRGBCoordinator
+
+PARALLEL_UPDATES = 0
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: OpenRGBConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the OpenRGB select platform."""
+    coordinator = config_entry.runtime_data
+    async_add_entities([OpenRGBProfileSelect(coordinator, config_entry)])
+
+
+class OpenRGBProfileSelect(CoordinatorEntity[OpenRGBCoordinator], SelectEntity):
+    """Representation of an OpenRGB profile select entity."""
+
+    _attr_translation_key = "profile"
+    _attr_has_entity_name = True
+
+    _state_hash: int | None = None
+    _pending_profile: str | None = None
+
+    def __init__(
+        self, coordinator: OpenRGBCoordinator, entry: OpenRGBConfigEntry
+    ) -> None:
+        """Initialize the select entity."""
+        super().__init__(coordinator)
+        self._attr_unique_id = UID_SEPARATOR.join([entry.entry_id, "profile"])
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, entry.entry_id)},
+            name=entry.data[CONF_NAME],
+            model="OpenRGB SDK Server",
+            manufacturer="OpenRGB",
+            sw_version=coordinator.get_client_protocol_version(),
+            entry_type=DeviceEntryType.SERVICE,
+        )
+        self._update_attrs()
+
+    def _compute_state_hash(self) -> int:
+        """Compute a hash of device states (modes and all LED colors)."""
+        state_data = tuple(
+            (
+                device.active_mode,
+                tuple((color.red, color.green, color.blue) for color in device.colors),
+            )
+            for device in self.coordinator.client.devices
+        )
+        return hash(state_data)
+
+    @callback
+    def _update_attrs(self) -> None:
+        """Update the attributes based on the current profile list."""
+        profiles = self.coordinator.client.profiles
+        self._attr_options = [profile.name for profile in profiles]
+
+        # If a profile was just applied, set it as current
+        if self._pending_profile is not None:
+            self._attr_current_option = self._pending_profile
+            self._pending_profile = None
+            self._state_hash = self._compute_state_hash()
+        # Only check for state changes if we have a current option to potentially clear
+        elif self._attr_current_option is not None:
+            current_hash = self._compute_state_hash()
+            # If state changed, we can no longer assume current profile
+            if current_hash != self._state_hash:
+                self._attr_current_option = None
+                self._state_hash = None
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        self._update_attrs()
+        super()._handle_coordinator_update()
+
+    @property
+    def available(self) -> bool:
+        """Return if the select is available."""
+        return super().available and bool(self._attr_options)
+
+    async def async_select_option(self, option: str) -> None:
+        """Load the selected profile."""
+        async with self.coordinator.client_lock:
+            try:
+                await self.hass.async_add_executor_job(
+                    self.coordinator.client.load_profile, option
+                )
+            except CONNECTION_ERRORS as err:
+                raise HomeAssistantError(
+                    translation_domain=DOMAIN,
+                    translation_key="communication_error",
+                    translation_placeholders={
+                        "server_address": self.coordinator.server_address,
+                        "error": str(err),
+                    },
+                ) from err
+            except ValueError as err:
+                raise HomeAssistantError(
+                    translation_domain=DOMAIN,
+                    translation_key="openrgb_error",
+                    translation_placeholders={
+                        "error": str(err),
+                    },
+                ) from err
+
+        self._pending_profile = option
+        await self.coordinator.async_refresh()

homeassistant/components/openrgb/strings.json

@@ -65,6 +65,11 @@
           }
         }
       }
+    },
+    "select": {
+      "profile": {
+        "name": "Profile"
+      }
     }
   },
   "exceptions": {
@@ -79,6 +84,9 @@
     },
     "effect_no_color_support": {
       "message": "Effect `{effect}` does not support color control on {device_name}"
+    },
+    "profile_not_found": {
+      "message": "Profile `{profile}` not found"
     }
   }
 }

tests/components/openrgb/conftest.py

@@ -96,11 +96,13 @@ def mock_openrgb_client(mock_openrgb_device: MagicMock) -> Generator[MagicMock]:
         # Attributes
         client.protocol_version = 4
         client.devices = [mock_openrgb_device]
+        client.profiles = []
 
         # Methods
         client.update = MagicMock()
         client.connect = MagicMock()
         client.disconnect = MagicMock()
+        client.load_profile = MagicMock()
 
         # Store the class mock so tests can set side_effect
         client.client_class_mock = client_mock

tests/components/openrgb/snapshots/test_select.ambr

@@ -0,0 +1,54 @@
+# serializer version: 1
+# name: test_entities[select.test_computer_profile-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'options': list([
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'select',
+    'entity_category': None,
+    'entity_id': 'select.test_computer_profile',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Profile',
+    'platform': 'openrgb',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': 0,
+    'translation_key': 'profile',
+    'unique_id': '01J0EXAMPLE0CONFIGENTRY00||profile',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_entities[select.test_computer_profile-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'Test Computer Profile',
+      'options': list([
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'select.test_computer_profile',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'unavailable',
+  })
+# ---