Add OpenRGB profile select entity

homeassistant/components/openrgb/__init__.py

@@ -10,7 +10,7 @@
 from .const import DOMAIN
 from .coordinator import OpenRGBConfigEntry, OpenRGBCoordinator
 
-PLATFORMS: list[Platform] = [Platform.LIGHT]
+PLATFORMS: list[Platform] = [Platform.LIGHT, Platform.SELECT]
 
 
 def _setup_server_device_registry(
@@ -37,6 +37,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: OpenRGBConfigEntry) -> b
 
     await coordinator.async_config_entry_first_refresh()
 
+    # The server device must be created first as other devices are children of it
     _setup_server_device_registry(hass, entry, coordinator)
 
     entry.runtime_data = coordinator

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,109 @@
+"""Select platform for OpenRGB integration."""
+
+from __future__ import annotations
+
+from homeassistant.components.select import SelectEntity
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
+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 = {
+            "identifiers": {(DOMAIN, entry.entry_id)},
+        }
+        self._update_attrs()
+
+    def _compute_state_hash(self) -> int:
+        """Compute a hash of device states."""
+        return hash(
+            "\n".join(str(device.data) for device in self.coordinator.client.devices)
+        )
+
+    @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": {
@@ -77,6 +82,9 @@
     "openrgb_error": {
       "message": "An OpenRGB error occurred: {error}"
     },
+    "profile_not_found": {
+      "message": "Profile `{profile}` not found"
+    },
     "unsupported_effect": {
       "message": "Effect `{effect}` is not supported by {device_name}"
     }

tests/components/openrgb/conftest.py

@@ -66,6 +66,11 @@ def mock_openrgb_device() -> MagicMock:
     device = MagicMock(spec=device_obj)
     device.configure_mock(**vars(device_obj))
 
+    # Used by select entity to track state changes
+    type(device).data = property(
+        lambda self: {attr: getattr(self, attr) for attr in vars(device_obj)}
+    )
+
     # Methods
     device.set_color = MagicMock()
     device.set_mode = MagicMock()
@@ -96,11 +101,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',
+  })
+# ---

tests/components/openrgb/test_init.py

@@ -6,10 +6,9 @@
 from freezegun.api import FrozenDateTimeFactory
 from openrgb.utils import ControllerParsingError, OpenRGBDisconnected, SDKVersionError
 import pytest
-from syrupy.assertion import SnapshotAssertion
 
 from homeassistant.components.openrgb import async_remove_config_entry_device
-from homeassistant.components.openrgb.const import DOMAIN, SCAN_INTERVAL
+from homeassistant.components.openrgb.const import DOMAIN, SCAN_INTERVAL, UID_SEPARATOR
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import STATE_ON, STATE_UNAVAILABLE
 from homeassistant.core import HomeAssistant
@@ -39,31 +38,9 @@ async def test_entry_setup_unload(
 
 
 @pytest.mark.usefixtures("mock_openrgb_client")
-async def test_server_device_registry(
-    hass: HomeAssistant,
-    snapshot: SnapshotAssertion,
-    mock_config_entry: MockConfigEntry,
-    device_registry: dr.DeviceRegistry,
-) -> None:
-    """Test server device is created in device registry."""
-    mock_config_entry.add_to_hass(hass)
-
-    await hass.config_entries.async_setup(mock_config_entry.entry_id)
-    await hass.async_block_till_done()
-
-    assert mock_config_entry.state is ConfigEntryState.LOADED
-
-    server_device = device_registry.async_get_device(
-        identifiers={(DOMAIN, mock_config_entry.entry_id)}
-    )
-
-    assert server_device == snapshot
-
-
 async def test_remove_config_entry_device_server(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
-    mock_openrgb_client: MagicMock,
 ) -> None:
     """Test that server device cannot be removed."""
     mock_config_entry.add_to_hass(hass)
@@ -86,10 +63,10 @@ async def test_remove_config_entry_device_server(
     assert result is False
 
 
+@pytest.mark.usefixtures("mock_openrgb_client")
 async def test_remove_config_entry_device_still_connected(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
-    mock_openrgb_client: MagicMock,
 ) -> None:
     """Test that connected devices cannot be removed."""
     mock_config_entry.add_to_hass(hass)
@@ -116,10 +93,10 @@ async def test_remove_config_entry_device_still_connected(
         assert result is False
 
 
+@pytest.mark.usefixtures("mock_openrgb_client")
 async def test_remove_config_entry_device_disconnected(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
-    mock_openrgb_client: MagicMock,
     device_registry: dr.DeviceRegistry,
 ) -> None:
     """Test that disconnected devices can be removed."""
@@ -135,7 +112,16 @@ async def test_remove_config_entry_device_disconnected(
         identifiers={
             (
                 DOMAIN,
-                f"{entry_id}||KEYBOARD||Old Vendor||Old Device||OLD123||Old Location",
+                UID_SEPARATOR.join(
+                    [
+                        entry_id,
+                        "KEYBOARD",
+                        "Old Vendor",
+                        "Old Device",
+                        "OLD123",
+                        "Old Location",
+                    ]
+                ),
             )
         },
         name="Old Disconnected Device",
@@ -171,7 +157,16 @@ async def test_remove_config_entry_device_with_multiple_identifiers(
             ("other_domain", "some_other_id"),  # This should be skipped
             (
                 DOMAIN,
-                f"{entry_id}||DEVICE||Vendor||Name||SERIAL123||Location",
+                UID_SEPARATOR.join(
+                    [
+                        entry_id,
+                        "DEVICE",
+                        "Vendor",
+                        "Name",
+                        "SERIAL123",
+                        "Location",
+                    ]
+                ),
             ),  # This is a disconnected OpenRGB device
         },
         name="Multi-Domain Device",